黑马程序员Java零基础视频教程笔记-字符串

一、API和API帮助文档

1. API

应用程序编程接口

2. 简单理解

API就是别人已经写好的东西，我们不需要自己编写，直接使用即可

3. Java API

指的就是JDK中提供的各种功能的Java类
这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只要学习这些类如何使用即可

4. 样例

package com.itheima.apidemo;
import java.util.Scanner;
public class ScannerDemo1{
    public static void main(String[] args){
        //1.创建对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个小数");
        //2.接收一个小数
        double result = sc.nextDouble();
        //3.输出打印
        System.out.println(result);
    }
}

二、String概述

1. 字符串学习内容

① String,StringBuilder,StringJonier,StringBuffer,Pattern,Matcher
可以掌握字符串的一些常见操作了
② 实际开发中的一些常见案例
掌握分析问题，解决问题的能力
③ 字符串相关的底层原理
掌握原理更好的通过面试，处理开发中的一些复杂问题
④ 字符串的练习题
锻炼大家独立解决问题的能力

2. String概述

java.lang.String 类代表字符串，Java程序中的所有字符串文字都为此类的对象

3. 总结

① String是Java定义好的一个类。定义在java.lang包中，所以使用的时候不需要导包
② Java程序中的所有字符串文字（例如"abcdefg"）都为此类的对象
③ 字符串不可变，它们的值在创建后不能被更改

三、String构造方法代码实现和内存分析

1. 创建String对象的两种方式

① 直接赋值
② new

2. 样例

package com.itheima.stringdemo;
public class StringDemo1{
    public static void main(String[] args){
        //1.使用直接赋值的方式获取一个字符串对象
        String s1 = "abc";
        System.out.println(s1);//abc


        //2.使用new的方式来获取一个字符串对象
        //空参构造：可以获取一个空白的字符串对象
        String s2 = new String();
        System.out.println("@" + s2 + "!");//""

        //传递一个字符串，根据传递的字符串内容再创建一个新的字符串对象
        String s3 = new String("abc");
        System.out.println(s3);

        //传递一个字符数组，根据字符数组的内容再创建一个新的字符串对象
        char[] chs = {'a','b','c','d'};
        String s4 = new String(chs);
        System.out.println(s4);//abcd

        //传递一个字节数组，根据字节数组的内存再创建一个新的字符串对象
        //应用场景：以后在网络当中传输的数据其实是字节信息
        //我们一般要把字节信息进行转换，转成字符串，此时就要用到这个构造了
        byte[] bytes = {97,98,99,100};
        String s5 = new String(bytes);
        System.out.println(s5);//abcd
    }    
}

3. Java的内存模型

当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在

① 不存在：创建新的
② 存在：复用

四、字符串的比较

1. ==号比的到底是什么

①基本数据类型比较的是数据值
②引用数据类型比较的是地址值

2. 字符串比较

① boolean equals方法(要比较的字符串)
注：完全一样结果才是true，否则为false

② boolean equalsIgnoreCase(要比较的字符串)
注：忽略大小写的比较

3. 样例

package com.itheima.stringdemo;
public class StringDemo2{
    public static void main(String[] args){
        //1.创建两个字符串对象
        String s1 = new String("abc");
        String s2 = "Abc";
        
        //2. == 号比较
        //基本数据类型：比的是数据值
        //引用数据类型：比的是地址值
        System.out.println(s1 == s2);
        
        //3.比较字符串对象中的内容是否相等
        boolean result = s1.equals(s2);
        System.out.println(result);
        
        //4.比较字符串对象中的内容是否相等，忽略大小写
        boolean result = s1.equalsIgnoreCase(s2);
        System.out.println(result);//true     
    }
}

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo3{
    public static void main(String[] args){
        //1.假设我现在键盘录入一个abc
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str1 = sc.next();//abc
        
        //2.代码再定义一个字符串abc
        String str2 = "abc";
        
        //3.用==比较，这两者能一样吗
        System.out.println(str1 == str2);//false
    }
}

五、练习-用户登录

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo4{
    public static void main(String[] args){
	    //读题拆解法
	    
	    //1.定义两个变量记录正确的用户名和密码
	    String rightUsername = "zhangsan";
	    String rightPassword = "123456";
	    
	    Scanner sc = new Scanner(System.in);
	    //2.键盘录入用户名和密码
	    for(int i = 0; i < 3; i++){
		    System.out.println("请输入用户名：");
		    String username = sc.next();
		    System.out.println("请输入密码：");
		    String password = sc.next();  
		    
		    //3.比较
		    if(username.equals(rightUsername) && password.equals(rightPassword)){
		        System.out.println("用户登录成功");
		        break;
		    }else{
		        if(i == 2){
		            //最后一次机会也输入错误，此时要提示账号被锁定
		            System.out.println("账号" + username + "被锁定，请联系管理员")
		        }else{
		            System.out.println("用户登录失败，用户名或密码有误，您还剩下" + (2 - i) + "次机会");
		        }
		    }
		}   
	} 
}

六、遍历字符串

1. 遍历字符串

① public char charAt(int index)：根据索引返回字符
② public int length()：返回字符串长度
③ 数组的长度：数组名.length
④ 字符串的长度：字符串对象.length()

2. 样例

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo5{
    public static void main(String[] args){
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        //2.进行遍历
        for(int i =0; i < str.length(); i++){
            // i 依次表示字符串的每一个索引
            char c = str.charAt(i);
            System.out.println(c);
        }
    }
}

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo6{
    public static void main(String[] args){
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        //2.统计 --- 计数器思想
        //定义三个计数器
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        for(int i = 0; i < str.length(); i++){
            //i 依次表示字符串中的每一个索引
            char c = str.charAt(i);
            if(c >= 'a' && c <= 'z'){
                //char类型的变量在参与计算的时候自动类型提升为int 查询ascii码表
                smallCount++;
            }else if(c >= 'A' && c <= 'Z'){
                bigCount++;
            }else if(c >= '0' && c <= '9'){
                numberCount++;
            }
        }
        //3.输出打印
        System.out.println("小写字母有：" + smallCount + "个");
         System.out.println("大写字母有：" + bigCount + "个");
          System.out.println("数字字符有：" + numberCount + "个");
    }
}

七、字符串拼接和反转

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo7{
    public static void main(String[] args){
        int[] arr = {1,2,3};
        String str = arrToString(arr);
        System.out.println(str);
    }
    
    //1.我要干嘛？  --- 遍历数组并把数组拼接成一个字符串
    //2.我干这件事情需要什么才能完成？ --- 数组
    //3.我干完了是否要把结果返回给调用处 --- 返回一个拼接之后的字符串
    //如果调用此需要继续使用，那么必须返回
    //如果调用此不需要继续使用，那么可以返回也可以不返回
    
    public static String arrToString(int[] arr){
        if(arr == null){
            return "";
        }
        
        if(arr.length == 0){
            return "[]";
        }
        
        String result = "[";
        //当代码执行到这里表示什么？
        //表示数组不是null，也不是长度为0的
        for(int i = 0; i <= arr.length; i++){
            //i 索引 arr[i] 元素
            if(i == arr.length - 1){
                result = result + arr[i];
            }else{
                result = result + arr[i] + ", ";
            }
            
        }
        //此时拼接右括号
        result = result + "]";
        return result;
    }
}

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo8{
    public static void main(String[] args){
        String result = reverse("abc");
        System.out.println(result);
    }
    
    //1.我要干嘛？ --- 字符串反转
    //2.我干这件事情，需要什么才能完成？ --- 需要一个字符串
    //3.调用处是否需要继续使用方法的结果呢？ --- 需要结果并进行输出
    public static String reverser(String str){
        String result = "";
        for(int i = str.length() - 1; i >= 0; i--){
            //i 依次表示字符串中的每一个索引 （倒着的）
            char c = str.charAt(i);
            result = result + c;
        }
        return result;
    }
}

八、练习-金额转换

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo9{
    public static void main(String[] args){
        //1.键盘录入一个金额
        Scanner sc = new Scanner(System.in);
        int money;
        while(true){
            System.out.println("请记录一个金额");
            money = sc.nextInt();
            if(money >= 0 && money <= 9999999){
                break;
            }else{
                System.out.println("金额无效");
            }
        }
        
        //定义一个变量，用来表示钱的大写
        String moneyStr = "";
        //2.得到money里面的每一位数字
        while(true){
            //从右往左获取数据，因为右侧是数据的个位
            int ge = money % 10;
            String capitalNumber = getCapitalNumber(ge);
            //把转换之后的大写拼接到moneyStr当中
            moneyStr =  capitalNumber + moneyStr;
            //第一次循环："伍" + "" = "伍"
            //第二次循环："叁" + "伍" = "叁伍"
            //去掉刚刚获取的数据
            money = money / 10;
            
            //如果数字上的每一位全部获取到了，那么money记录的就是0，此时循环结束
            if(money == 0){
                break;
            }
        }

        //3.在前面补0，补齐7位
        int count = 7 - moneyStr.length();
        
        for(int i = 0; i < count; i++){
            moneyStr = "零" + moneyStr;
        }
        System.out.println(moneyStr);
        
        //4.插入单位
        //定义一个数组表示单位
        String[] arr = {"佰","拾","万","仟","佰","拾","元"};
        //遍历moneyStr
        //然后把arr的单位插入进去
        
        String result = "";
        for(int i = 0; i < moneyStr.length(); i++){
            char c = moneyStr.charAt(i);
            //把大写数字和单位拼接到result当中
            result = result + c + arr[i];
        }
        System.out.println(moneyStr);
    }
    
    //定义一个方法把数字变成大写的中文
    //1 -- 壹
    public static String getCapitalNumber(int number){
        //定义数组，让数字跟大写的中文产生一个对应关系
        String[] arr = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
        //返回结果
        return arr[number];
    }
}

九、练习-手机号屏蔽-身份证号码信息查看-游戏骂人敏感词替换

⭐ 截取字符串

① String substring(int beginIndex,int endIndex) 截取

注意点：包头不包尾，包左不包右，只有返回值才是截取的小串

② String substring(int beginIndex) 截取到末尾

2. 手机号屏蔽

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo10{
    public static void main(String[] args){
        //1.获取一个手机号码
        String phoneNumber = "13112349468";
        
        //2.截取手机号码前面三位
        String start = phoneNumber.substring(0,3);
        
        //3.截取手机号码后面四位
        String end = phoneNumber.substring(7);
        
        //4.拼接
        String result = start + "****" + end;
        
        //5.打印
        System.out.println(result);
        
    }
}

3. 身份证信息查看

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo11{
    public static void main(String[] args){
        //1.定义一个字符串记录身份证号码
        String id = "321281202001011234";
        
        //2.获取出生年月
        String year = id.substring(6,10);
        String month = id.substring(10,12);
        String day = id.substring(12,14);
        
        System.out.println("人物信息为：");
        System.out.println("出生年月日：" + year + "年" + month + "月" + day + "日");
        
        //3.获取性别
        char gender = id.charAt(16);
        //利用ASCII码进行转换
        //'0' ---> 48
        //'1' ---> 49
        //'2' ---> 50
        //'3' ---> 51
        //'4' ---> 52
        //'5' ---> 53
        //'6' ---> 54
        //'7' ---> 55
        //'8' ---> 56
        //'9' ---> 57
        
        int num = gender - 48;
        if(num % 2 == 0){
            System.out.println("性别为：女");
        }else{
            System.out.println("性别为：男");
        }
    }
}

⭐ 替换字符串

String replace(旧值,新值) 替换

注意点：只有返回值才是替换之后的结果

3. 游戏骂人敏感词替换

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo12{
    public static void main(String[] args){
        //1.获取到说的话
        String talk = "你玩的真好，以后不要再玩了，TMD";
        
        //2.把里面的敏感词TMD替换为***
        String result = talk.replace("TMD","***");
        
        //3.打印结果
        System.out.println(result);
    }
}

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo13{
    public static void main(String[] args){
        //1.获取到说的话
        String talk = "你玩的真好，以后不要再玩了，TMD";
        
        //2.定义一个敏感词库
        String arr[] = {"TMD","CNM","SB","MLGB"};
        
        //3.循环得到数组中的每一个敏感词，依次进行替换
        for(int i = 0; i < arr.length; i++){
            talk = talk.replace(arr[i],"***");
        }
        
        //3.打印结果
        System.out.println(talk);        
    }
}

十、StringBuilder的基本操作

1. StringBuilder概述

① 简介：StringBuilder 可以看成是一个容器，创建之后里面的内容是可变的
② 作用：提高字符串的操作效率

2. StringBuilder构造方法

StringBuilder sb = new StringBuiler("abc");

3. StringBuilder常用方法

4. 样例

package com.itheima.stringbuilderdemo;
public class StringBuliderDemo1{
    public static void main(String[] args){
        String s = "";
        for(int i = 0; i < 1000000; i++){
            s = s + "abc";
        }
        System.out.println(s);
    }
}

package com.itheima.stringbuilderdemo;
public class StringBuliderDemo2{
    public static void main(String[] args){
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < 1000000; i++){
            sb.append("abc");
        }
        System.out.println(sb);
    }
}

package com.itheima.stringbuilderdemo;
public class StringBuliderDemo3{
    public static void main(String[] args){
        //1.创建对象
        StringBuilder sb = new StringBuilder();
        
        //2.添加元素
        sb.append(1);
        sb.append(2.3);
        sb.append(true);
        
        //反转
        sb.reverse();
        
        //获取长度
        int len = sb.length();
        System.out.println(len);

        //打印
        //普及
        //因为StringBuilder是Java已经写好的类
        //Java在底层对他做了一些特殊处理
        //打印对象不是地址值而是属性值
        System.out.println(sb);
    }
}

package com.itheima.stringbuilderdemo;
public class StringBuliderDemo4{
    public static void main(String[] args){
        //1.创建对象
        StringBuilder sb = new StringBuilder();
        //2.添加字符串
        sb.append("aaa");
        sb.append("bbb");
        sb.append("ccc");
        sb.append("ddd");
        
        System.out.println(sb);//aaabbbcccddd
        
        //3.再把StringBuilder变回字符串
        String str = sb.toString();
        System.out.println(str);
    }
}

package com.itheima.stringbuilderdemo;
public class StringBuliderDemo5{
    public static void main(String[] args){
        //链式编程：
        //当我们在调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法

        int len = getString().substring(1).replace("A","Q").length();
        System.out.println(len);
    }
    
    public static String getString(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        return str;
    }
}

package com.itheima.stringbuilderdemo;
public class StringBuliderDemo6{
    //使用StringBuilder的场景：
    //1.字符串的拼接
    //2.字符串的反转    
    public static void main(String[] args){
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();

        //2.反转键盘录入的字符串
        String result = new StringBuiler().append(str).reverse().toString();
        
        //3.比较
        if(str.equals(result)){
            System.out.println("当前字符串是对称字符串");
        }else{
            System.out.println("当前字符串不是对称字符串");
        }
    }
}

package com.itheima.stringbuilderdemo;
public class StringBuliderDemo7{
    public static void main(String[] args){
        //1.定义数组
        int[] arr = {1,2,3};
        
        //2.调用方法把数组变成字符串
        String str = arrToString(arr);
        System.out.println(str);
    }
    
    public static String arrToString(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i = 0; i < arr.length; i++){
            if(i == arr.length - 1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i].append(", "));
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

十一、Stringjoiner

1. StringJoiner概述

① 简介：StringJoiner跟StringBuiler一样，也可以看成是一个容器，创建之后里面的内容是可变的
② 作用：提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上很少有人用
③ JDK8出现的

2. StringJoiner的构造方法

3. StringJoiner的成员方法

4. 样例

package com.itheima.stringjoinerdemo;
import java.util.StringJoiner;
public class StringJoinerDemo1{
    public static void main(String[] args){
        //1.创建一个对象，并指定中间的间隔符号
        StringJoiner sj = new StringJoiner("---");
        
        //2.添加元素
        sj.add("aaa").add("bbb").add("ccc");
        
        //3.打印结果
        System.out.println(sj);//aaa---bbb---ccc
    }
}

package com.itheima.stringjoinerdemo;
import java.util.StringJoiner;
public class StringJoinerDemo2{
    public static void main(String[] args){
        //1.创建对象
        StringJoiner sj = new StringJoiner(", ","[","]");
        //2.添加元素
        sj.add("aaa").add("bbb").add("ccc");

        int len = sj.length();
        System.out.println(len);//15

        //3.打印
        System.out.println(sj);

        String str = sj.toString();
        System.out.println(str);//[aaa, bbb, ccc]
    }
}

5. 总结

① String

表示字符串的类，定义了很多操作字符串的方法

② StringBuilder

一个可变的操作字符串的容器
可以高效的拼接字符串，还可以将容器里面的内容反转

③ StringJoiner

JDK8出现的一个可变的字符串的容器，可以高效，方便的拼接字符串。在拼接的时候，可以指定间隔符号，开始符号，结束符号

十二、字符串相关类的底层原理

扩展底层原理1：字符串存储的内存原理

① 直接赋值会复用字符串常量池中的
② new出来不会复用，而是开辟一个新的空间

扩展底层原理2：==号比较的到底是什么

① 基本数据类型比较数据值
② 引用数据类型比较地址值

扩展底层原理3：字符串拼接的底层原理

① 如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串
② 如果有变量参与，每一行拼接的代码，都会在内存中创建新的字符串，浪费内存

扩展底层原理4：StringBuilder提高效率原理图

① 所有要拼接的内容都会往StringBuilder中放，不会创建很多无用的空间，节约内存

扩展底层原理5：StringBuilder源码分析

① 默认创建一个长度为16的字节数组
② 添加的内容长度小于16，直接存
③ 添加的内容大于16会扩容（原来的容量*2+2）文章来源地址https://www.toymoban.com/news/detail-429328.html

附：更多内容

到了这里，关于黑马程序员Java零基础视频教程笔记-字符串的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！