java入门~第十三天 Scanner类和String类

1.Scanner(用于接收键盘录入数据)

1.Scanner的概述: JDK5以后用于获取用户的键盘输入
2.Scanner的构造方法原理
Scanner(InputStream source)
System类下有一个静态的字段：

public static final InputStream in; 标准的输入流，对应着键盘录入。

public class MyTest {
    public static void main(String[] args) {
      /*  Scanner(InputStream source)
        构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。*/
        //in
        //public static final InputStream in“标准”输入流。此流已打开并准备提供输入数据。通常，此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。
        InputStream in= System.in;

        Scanner sc = new Scanner(in);
        //nextXXX 系列的方法
        /*sc.nextInt();
        sc.nextDouble();
        sc.nextLine();*/

     /*   hasNextXxx() 判断下一个是否是某种类型的元素, 其中Xxx可以是Int, Double等。
        如果需要判断是否包含下一个字符串，则可以省略Xxx*/
        System.out.println("请输入一个整数");
        if(sc.hasNextInt()){
            int i = sc.nextInt();
        }else{
            System.out.println("你输入的类型不正确,请重新输入");
        }

        //关闭扫描器
        sc.close();
    }
}

录入字符串时，你上次敲了个回车换行默认被nextLine()录入了，会发现字符串没让你录入

public class MyTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int i = sc.nextInt();
        System.out.println(i);
        System.out.println("请输入一个字符串");
        //当你先录入整数，然后使用nextLine();录入字符串时，会发现字符串没让你录入，原因就是你上次敲了个回车换行默认被nextLine()录入了，
        //但是这不是我想要的效果，那怎么解决。
        //解决方式1：可以在录入字符字符串时，在创建一个Scanner对象。
        //解决方式2：可以使用next() 来录入字符串
         sc = new Scanner(System.in);
        String s = sc.nextLine();
        //String s = sc.next();
        System.out.println(s);

    }
}

3.Scanner类的hasNextXxx()和nextXxx()方法的讲解：

基本格式
hasNextXxx() 判断下一个是否是某种类型的元素,其中Xxx可以是Int,Double等。
如果需要判断是否包含下一个字符串，则可以省略Xxx
nextXxx() 获取下一个输入项。Xxx的含义和上个方法中的Xxx相同

输入一个整数：

public class MyTest3 {
    public static void main(String[] args) {
        Scanner sc=null;
        while (true){
           sc= new Scanner(System.in);
           // System.out.println("请输入一个整数");
            if (sc.hasNextInt()) {
                int i = sc.nextInt();
                System.out.println(i);
                break;
            } else {
                System.out.println("你输入的类型不正确,请重新输入");
            }
        }
    }
}

用调用的方式输入整数： (不用重复写方法)

public class ScannerUtils {
    private ScannerUtils() {
    }

    public static int getNumber(Scanner sc){
        int num=0;
        while (true) {
            sc = new Scanner(System.in);
            //System.out.println("请输入一个整数");
            if (sc.hasNextInt()) {
               num = sc.nextInt();
                break;
            } else {
                System.out.println("你输入的类型不正确,请重新输入");
            }
        }
        return num;

    }
}

public class MyTest4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int number = ScannerUtils.getNumber(sc);
    }
}

2.String(字符串)

2.1String类的概述

字符串是由多个字符组成的一串数据(字符序列)，字符串可以看成是字符数组。每一个字符从左往后编有索引，从0开始。

String类的概述：
通过JDK提供的API，查看String类的说明
可以看到这样的两句话。
a:字符串字面值"abc"也可以看成是一个字符串对象。
b:字符串是常量，一旦被创建，就不能被改变。

String() 初始化一个新创建的 String 对象，使其表示一个空字符序列。

String有两种赋值方式：

1、通过"字面量"赋值。
String str = "Hello";
2、通过new关键字创建新对象。
String str = new String("Hello");

public class MyTest {
    public static void main(String[] args) {
        //String 字符串：就是有一个或多个字符组成的序列。
        //字符串可以看成是字符数组,每一个字符从左往后编有索引，从0开始

        //String 类代表字符串。
       //1. Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
       //2. 字符串是常量；它们的值在创建之后不能更改。

       // String() 初始化一个新创建的 String 对象，使其表示一个空字符序列。

        String s = new String();
        //String 类他重写了父类的toString方法，打印的是字符串字面值
        System.out.println(s);
        //"" 空串
        System.out.println("");

        System.out.println("=====================================");
        String s1 = new String("abc");
        System.out.println(s1);

    }
}
运行结果：

=====================================
abc

2.2String类的构造方法

1==.常见构造方法==
public String():空构造 即空串
public String(byte[] bytes):把字节数组转成字符串

public class MyTest2 {
    public static void main(String[] args) {
       // public String( byte[] bytes):把字节数组转成字符串
        byte[] bytes = {97, 98, 99, 100, -28, -67, -96};
        String s = new String(bytes);
        System.out.println(s);
        //把字节数组的一部分转换成字节 0 起始索引 4表示转换4个字节
        String s1 = new String(bytes, 0,4);
        System.out.println(s1); //abc
        // StringIndexOutOfBoundsException 字符串索引越界
        //
        String s2 = new String(bytes, 4, 3);
        System.out.println(s2);//你

    }
}

​ public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串==(index:表示的是从第几个索引开始, length表示的是长度)==
​ public String(char[] value):把字符数组转成字符串

​ public String(char[] value,int index,int count):把字符数组的一部分转成字符串

public class Mytest {
    public static void main(String[] args) {
        char[] chars={'a','b','c','你','好'};
        String s=new String();
        for (int i = 0; i < chars.length; i++) {
            s+=chars[i];
        }
        System.out.println(s);
        String s1=new String(chars,3,2);
        System.out.println(s1);
    }
}
运行结果：abc你好
		你好

​ public String(String original):把字符串常量值转成字符串。

2.String 类代表字符串。

Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。

字符串是常量；它们的值在创建之后不能更改。因为字符串的值是在堆内存的常量池中划分空间 分配地址值的

length(); 获取字符串的长度

public class Mytest {
    public static void main(String[] args) {
        String s = new String("abc");
        int length=s.length();
        System.out.println(length);
    }
}
运行结果：3

public static void main(String[] args) {
    //2. 字符串是常量；它们的值在创建之后不能更改。
    String s = "hello";
    s = "world" + "java";
    //问s的结果是多少 ?
    System.out.println(s);
}
运行结果:worldjava  //此时只是将常量池中的s的地址指向worldjava ，"hello"并没有被修改

图2：

图3：

2.3String的特点一旦被创建就不能改变

String类的常见面试题

public static void main(String[] args) {
   /* A:
    面试题1
    String s = new String("hello") 和String s ="abc";
    的区别*/
    String s = new String("hello");

    String s2 = "abc";
    //s在堆里面开创出地址指向字符串常量池里的s地址值，而s2直接指向字符串常量池里的s2地址值

}
如图2



面试题2.  ==和equals()的区别?   

**==号判断的是两个字符串的地址值是否相同，而 equals() 判断的是两个字符串的值是否相同，String类重写了这个方法；**

```java
public static void main(String[] args) {
    String s1 = new String("abc");
    String s2="abc";
    String s3 = "abc";
    String s4="aaa";
    System.out.println(s1==s2); //false 一个是堆的地址值，一个是字符串常量地址值
    System.out.println(s2==s3); //true两个都是字符串常量地址值，且是同一个
    System.out.println(s3==s4); //false 两个都是字符串常量地址值，但不是同一个
}

public static void main(String[] args) {
    String s1 = new String("hello");
    String s2 = new String("hello");
    System.out.println(s1 == s2); //false
    //String 类 已经重写过了父类的equals方法不再比较地址值是否相同，
    // 而是比较两个字符串的字面内容是否相同。
    System.out.println(s1.equals(s2)); //true

    String s3 = new String("hello");
    String s4 = "hello";
    System.out.println(s3 == s4);//false
    System.out.println(s3.equals(s4)); //true

    String s5 = "hello";
    String s6 = "hello";
    System.out.println(s5 == s6); //true
    System.out.println(s5.equals(s6)); //true
}

public static void main(String[] args) {
    String s1 = "Hello";
    String s2 = "Hello";
    String s3 = "Hel" + "lo";
    String s4 = "Hel" + new String("lo");
    String s5 = new String("Hello");
    String s6 = s5.intern();//intern()取这个字符串在常量池的地址值
    String s7 = "H";
    String s8 = "ello";
    String s9 = s7 + s8;

    System.out.println(s1 == s2);//true
    System.out.println(s1 == s3); //true
    System.out.println(s1 == s4); //false
    System.out.println(s1 == s9);// false
    System.out.println(s4 == s5);//false
    System.out.println(s1 == s6);//true

}
//1、s1在创建对象的同时，在字符串池中也创建了其对象的引用。
//2、由于s2也是利用字面量创建，所以会先去字符串池中寻找是否有相等的字符串，显然s1已经帮它创建好了，它可以直接使用其引用。那么s1和s2所指向的都是同一个地址，所以s1==s2。
//3、s3是一个字符串拼接操作，参与拼接的部分都是字面量，编译器会进行优化，在编译时s3就变成"Hello"了，所以s1==s3。
//4、s4虽然也是拼接，但“lo”是通过new关键字创建的，在编译期无法知道它的地址，所以不能像s3一样优化。所以必须要等到运行时才能确定，必然新对象的地址和前面的不同。
//5、同理，s8由两个变量拼接，编译期也不知道他们的具体位置，不会做出优化。
//6、s5是new出来的，在堆中的地址肯定和s4不同。
//7、s7利用intern()方法得到了s5在字符串池的引用，并不是s5本身的地址。由于它们在字符串池的引用都指向同一个"Hello"对象，自然s1==s7。

public static void main(String[] args) {
                                    //0x001
    String s1 = new String("abc");
    String s2 = "abc"; //0x001
    System.out.println(s1 == s2);
    //intern()取这个字符串在常量池的地址值
    String s4 = s1.intern();
    System.out.println(s2 == s4);//true
    System.out.println(s1==s4); //false

}

如图3
总结：

1、字符串一旦被创建，就不能被改变，指的是这个值不能被改变，你改变的无非是这个栈内存字符串的指向；
2、字面量创建字符串会先在字符串池中找，看是否有相等的对象，没有的话就在堆中创建，把地址驻留在字符串池；有的话则直接用池中的引用，避免重复创建对象。
3、new关键字创建时，前面的操作和字面量创建一样，只不过最后在运行时会创建一个新对象，变量所引用的都是这个新对象的地址。

Java中的String类为什么不可变？

2.4String类的判断功能(返回都是布尔值)

String类的判断功能
1.public boolean equals(Object obj): 比较字符串的内容是否相同,区分大小写

​ public boolean equalsIgnoreCase(String str): 比较字符串的内容是否相同**,忽略大小写**

boolean b = "abc".equals("abc");
//不区分大小写比较
b = "abc".equalsIgnoreCase("ABC");
System.out.println(b);//true

​ public boolean contains(String str): 判断字符串中是否包含传递进来的字符串
​ public boolean startsWith(String str): 判断字符串是否以传递进来的字符串开头
​ public boolean endsWith(String str): 判断字符串是否以传递进来的字符串结尾

System.out.println("王百万".startsWith("王"));//true
System.out.println("王百万".endsWith("百万"));//true

System.out.println("王百万".contains("百万"));//true

​ public boolean isEmpty(): 判断字符串的内容是否为空串""。

String str="";
//str.isEmpty();判断一个字符串不是空串
boolean empty = str.isEmpty();
System.out.println(empty);

例题：模拟用户登录

public class Mytest {
    public static void main(String[] args) {
        String name="zhangsan";
        String password="123456";
        Scanner sc = new Scanner(System.in);
        for (int i = 1; i <= 3; i++) {
            System.out.println("请输入你的用户名");
            String uname = sc.nextLine();
            System.out.println("请输入你的密码");
            String pwd = sc.nextLine();
            if(uname.equals(name)&&pwd.equals(password)){
                System.out.println("登录成功");
                break;
            }else {
                if((3 - i)>0){
                    System.out.println("用户名或密码错误 你还剩余" + (3 - i) + "次机会");
                }else{
                    System.out.println("你的次数用完，银行卡已被回收");
                }
            }
        }

    }

}

2.5String类的获取功能

String类的获取功能
public int length(): 获取字符串的长度。

System.out.println("abc".length());

​ public char charAt(int index): 获取指定索引位置的字符。

String str="abc";
//根据索引，获取字符串中的单个字符
 //StringIndexOutOfBoundsException:
char c = str.charAt(1);
System.out.println(c);

​ public int indexOf(int ch): 返回指定字符在此字符串中第一次出现处的索引。

String str2="开西部开源教育科技有限公司";
int index = str2.indexOf('开');
System.out.println(index);
//如果返回 -1 表示没有找到

​ public int indexOf(String str): 返回指定字符串在此字符串中第一次出现处的索引。

​ public int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
​ public int indexOf(String str,int fromIndex): 返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

String str2="开西部开源教育科技有限公司";
//从你指定的索引出开始查找改字符第一次出现的索引
int index1 = str2.indexOf("开", 1);//从引脚1开始找"开"出现的地方
System.out.println(index1);//3
int index3 = str2.indexOf("开", str2.indexOf("开") + 1);//从第一次"开"出现的地方+1引脚即1
System.out.println(index3); //3

​ 可以顺带提一下lastIndexOf系列

String str2="开西部开源教育科技有限公司";
//从后往前进行检索
int index4 = str2.lastIndexOf("开");
System.out.println(index4);

​ public String substring(int start): 从指定位置开始截取字符串,默认到末尾。(留下后面)

String str3 = "西部开源教育科技有限公司";
//从指定的索引出，截取到末尾返回
String substring = str3.substring(4);
System.out.println(substring);//教育科技有限公司

​ public String substring(int start,int end): 从指定位置开始到指定位置结束截取字符串。

String str3 = "西部开源教育科技有限公司";
//从指定的索引出，截取到末尾返回
String substring = str3.substring(4);
System.out.println(substring);
//根据起始索引和终止索引截取一部分字符串，，是含头不含尾
String substring2 = str3.substring(0,4);
System.out.println(substring2);
运行结果：教育科技有限公司
        西部开源

例题：字符串的遍历

public static void main(String[] args) {
    String str="往后余生，洗衣是你，做饭是你，带娃也是你";
    for (int i = 0; i < str.length(); i++) {
        char c = str.charAt(i);
        System.out.print(c);
    }
    System.out.println("===========================");
    for (int length = str.length()-1; length >= 0; length--) {
        char c = str.charAt(length);
        System.out.print(c);
    }
}
//运行结果：往后余生，洗衣是你，做饭是你，带娃也是你===========================
//你是也娃带，你是饭做，你是衣洗，生余后往b

例题：统计不同类型字符个数

public static void main(String[] args) {
    /*A:
    案例演示:
    需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)*/
    String str="asdfASFAEZSf5244dsfsdf555asdfa36425444asdfasdf";
    int xiao=0;
    int da=0;
    int num=0;
    for (int i = 0; i < str.length(); i++) {
        char ch = str.charAt(i);
        if(ch>='a'&&ch<='z'){
            xiao++;
        }else if(ch >= 'A' && ch <= 'Z'){
            da++;
        }else{
             num++;
        }
    }

    System.out.println("小写字符有"+xiao+"个");
    System.out.println("大写字符有" + da + "个");
    System.out.println("数字字符有" + num + "个");
}

2.6String类的转换功能

String的转换功能：
public byte[] getBytes(): 把字符串转换为字节数组。

String str = "我爱你";
byte[] bytes = str.getBytes();
for (int i = 0; i < bytes.length; i++) {
    System.out.println(bytes[i]);
}/*-26
-120
-111
-25
-120
-79
-28
-67
-96*/
String s = new String(bytes);
System.out.println(s);//我爱你

​ public char[] toCharArray(): 把字符串转换为字符数组。

public static void main(String[] args) {
        String str2 = "我爱你";
        //把一个字符串转换成字符数组
        char[] chars = str2.toCharArray();
        System.out.println(chars);
    }运行结果：我爱你

​ public static String valueOf(char[] chs): 把字符数组转成字符串。

​ public static String valueOf(int i): 把int类型的数据转成字符串。
​ 注意：String类的valueOf方法可以把任意类型的数据转成字符串。

public static void main(String[] args) {
    String s4 = String.valueOf(100);
    String s5 = String.valueOf(false);
    System.out.println(s4); //"100"
    System.out.println(s5);//"false"
}

​ public String toLowerCase(): 把字符串转成小写。

​ public String toUpperCase(): 把字符串转成大写。

public static void main(String[] args) {
    String s2 = "abc".toUpperCase();
    String s3 = "BcD".toLowerCase();
    System.out.println(s2);//ABC
    System.out.println(s3);//bcd
}

​ public String concat(String str): 把字符串拼接。

String abc = "abc".concat("ABC").concat("dddd").concat("555555");
System.out.println(abc);//abcABCdddd555555

例题：按要求转换字符,需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)

public static void main(String[] args) {
    String str="aasdfaFDFDwefsdfaaaasdfasdf";
    String s = str.substring(0, 1).toUpperCase().concat(str.substring(1).toLowerCase());
    System.out.println(s);
}//Aasdfafdfdwefsdfaaaasdfasdf

2.7String类的其他功能

String的替换功能及案例演示
public String replace(char old,char new) 将指定字符进行互换

​ public String replace(String old,String new) 将指定字符串进行互换
String的去除字符串两空格及案例演示:

public static void main(String[] args) {
    String replace = "奥巴马和特朗普是美国".replace("奥巴马", "xxx").replace("特朗普", "***");
    System.out.println(replace);

}//xxx和***是美国

public static void main(String[] args) {
    String str = "aaa=bbb=ccc";// "aaabbbccc"
    String replace1 = str.replace("=", "");
    System.out.println(replace1);//aaabbbccc

    String s = "     张    三   ";
    String replace2 = s.replace(" ", "");
    System.out.println("-----"+replace2+"-------------");//-----张三-------------
}

​ public String trim() 去除两端空格

public static void main(String[] args) {
    String s = "     张    三   ";
    //去除字符串的两端空格
    String trim = s.trim();
    System.out.println(trim);
}//张    三

String的按字典顺序比较两个字符串及案例演示:

​ public int compareTo(String str) 会对照ASCII 码表 从第一个字母进行减法运算 返回的就是这个减法的结果,如果前面几个字母一样会根据两个字符串的长度进行减法运算返回的就是这个减法的结果。如果连个字符串一摸一样 返回的就是0。

​ public int compareToIgnoreCase(String str) 跟上面一样 只是忽略大小写的比较

public static void main(String[] args) {
    int i = "abc".compareTo("abcd");
    System.out.println(i);//-1
    i= "abc".compareToIgnoreCase("ABC");
    System.out.println(i);//0
}

例题：把数组转成字符串

需求：把数组中的数据按照指定个格式拼接成一个字符串
举例：
int[] arr = {1,2,3};
拼接结果：
“[1, 2, 3]”

public static void main(String[] args) {
   int[] arr={1,2,3};
   String s="[";
    for (int i = 0; i < arr.length; i++) {
        if(i==arr.length-1){
            s+=arr[i]+"]";
        }else {
            s+=arr[i]+",";
        }
    }
    System.out.println(s);
} //"[1,2,3]"

例题：字符串反转并断点查看

需求：把字符串反转
举例：键盘录入"abc"
反转结果：“cba”

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一段字符串");
    String s = scanner.nextLine();//abc
    String str="";
    for (int length = s.length()-1; length >= 0; length--) {
        char ch = s.charAt(length);//先遍历 获取指定索引位置的字符。
         System.out.println(ch);    //c
                  					//b
									//a
        str+=ch;
    }
    System.out.println(str);//cba

}

例题：在大串中查找小串出现的次数思路图解

需求：统计大串中小串出现的次数
举例: “woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun” 中java出现了5次

public static void main(String[] args) {
    String maxStr = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";

    String minStr = "java";

    int index = maxStr.indexOf(minStr);
    //定义一个统计变量
    int count = 0;
    while (index != -1) {
        count++;
        maxStr = maxStr.substring(index + 4);//截断
        //再次查找重新赋值索引
        index = maxStr.indexOf(minStr);
    }

    System.out.println("java 出现了 "+count+" 次");
}

String maxStr = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";

String minStr = "java";
int count = 0;
if (!maxStr.contains("*")) {
    String s = maxStr.replace(minStr, "*");
    for (int i = 0; i < s.length(); i++) {
        char ch = s.charAt(i);//获取指定索引位置的字符
        if(ch=='*'){
            count++;
        }
    }


}

System.out.println(count);

public static void main(String[] args) {
    String maxStr = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";

    String minStr = "java";

    int length = maxStr.length();

    int length1 = maxStr.replace(minStr, "").length();//替换

    System.out.println((length - length1) / 4); //5
}

3.StringBuffer和StringBuilder

3.1StringBuffer类

1.01StringBuffer类的概述

StringBuffer类概述：
我们如果对字符串进行拼接操作，每次拼接都会构建一个新的String对象或者使用+号，既耗时又浪费空间。而StringBuffer就可以解决这个问题，它是线程安全的可变字符序列，在大量拼接字符串时，就可以使用长度可变的字符容器，构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。

1.02StringBuffer类的构造方法

StringBuffer的构造方法：
public StringBuffer(): 无参构造方法
public StringBuffer(int capacity): 指定容量的字符串缓冲区对象
public StringBuffer(String str): 指定字符串内容的字符串缓冲区对象

/* StringBuffer()
 构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。*/

 //创建一个空的字符容器。
 StringBuffer sb = new StringBuffer();
 //往容器中追加数据
 sb.append("abcaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
 //获取容器的容量 一旦超过容量，可以自动扩容。
 int capacity = sb.capacity();
 System.out.println(capacity);
 //获取容器的长度。
 int length = sb.length();
 System.out.println(length);

 //容量指本身容纳的量 57，长度指实际存放的了，量57

StringBuffer的成员方法：

public int capacity()：返回当前容量——理论值
public int length()：返回长度（字符数）——实际值

1.03StringBuffer的添加功能

StringBuffer的添加功能：
public StringBuffer append(String str)：可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str)：在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

public static void main(String[] args) {
      
        //append("abc"); 往容器中追加数据，返回的还是原来的那个容器对象。
        StringBuffer sb2 = sb.append("abc");

        System.out.println(sb==sb2);//true

        sb.append(100).append(200).append(true).append(new char[]{'a','b','c'});
        System.out.println(sb.toString());//"abc100200trueabc"
        //StringBuffer 重写了toString()方法，然后把容器中的数据转换成字符串返回
        StringBuffer insert = sb2.insert(1本位置上, 12);
       
        System.out.println(insert);//a12bc100200trueabc
    }
}

1.04StringBuffer的删除功能

StringBuffer的删除功能：
public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身

public static void main(String[] args) {
        /*
         *   你聪明有人会说你心机重，你靠的是努力有人会说你运气好。
         * */
        String str="你聪明有人会说你心机重，你靠的是努力有人会说你运气好。";
        StringBuffer sb = new StringBuffer(str);
        //根据指定索引，删除容器中的单个字符，返回的还是容器本身。
        StringBuffer sb2 = sb.deleteCharAt(0);//聪明有人会说你心机重，你靠的是努力有人会说你运气好。

        System.out.println(sb);//true

        System.out.println(sb==sb2);//，你靠的是努力有人会说你运气好。

        //根据起始索引和终止索引，删除容器中的一部分内容，返回的还是容器本身。
        StringBuffer buffer = sb.delete(0,10);
        System.out.println(buffer);

}

1.05StringBuffer的替换和反转功能

StringBuffer的替换功能：
public StringBuffer replace(int start,int end,String str): 从start开始到end用str替换
StringBuffer的反转功能：
public StringBuffer reverse()

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一段字符串");
    String s = scanner.nextLine();
    String s1 = new StringBuffer(s).reverse().toString();
    System.out.println(s1);
} //请输入一段字符串
//absd
//dsba

1.06StringBuffer的截取功能及注意事项

StringBuffer的截取功能：
public String substring(int start): 从指定位置截取到末尾
public String substring(int start,int end): 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置，

注意事项：返回值类型不再是StringBuffer本身

1.07StringBuffer和String的相互转换

public static void main(String[] args) {
   /* A:
    String-- StringBuffer*/

   String str="abc";

   //方式1
    StringBuffer sb = new StringBuffer(str);

    //方式2：
    StringBuffer sb2 = new StringBuffer();
    sb2.append(str);

    //方式3：

    StringBuffer sb3 = new StringBuffer();
    sb3.insert(0,str);//在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

    System.out.println("=================================");
   /* B:
    StringBuffer-- String*/

    StringBuffer sb4 = new StringBuffer("aaaaa");
    //方式1：toString()
    String s = sb4.toString();

    String s1 = sb4.substring(0);

    //String 类中有一个构造方法
    String s2 = new String(sb4);

}

例题1：把数组转成字符串

需求：把数组中的数据按照指定个格式拼接成一个字符串
举例：
int[] arr = {1,2,3};
输出结果：
"[1, 2, 3]"用StringBuffer的功能实现

public static void main(String[] args) {
 

    int[] arr = {1, 2, 3};

    StringBuffer sb = new StringBuffer("[");

    for (int i = 0; i < arr.length; i++) {
        if(i==arr.length-1){
            sb.append(arr[i]).append("]");
        }else{
            sb.append(arr[i]).append(",");
        }
    }

    String s = sb.toString();
    System.out.println(s);

}

例题2：字符串反转

需求：把字符串反转
举例：键盘录入"abc"
输出结果：“cba”
用StringBuffer的功能实现

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一段字符串");
    String s = scanner.nextLine();
    String s1 = new StringBuffer(s).reverse().toString();
    System.out.println(s1);
}

3.2StringBuilder类

3.1StringBuffer和StringBuilder的区别

StringBuilder——适用于单线程下大量数据，效率高，线程非安全；
StringBuffer——适用于多线程下大量数据，效率低，线程安全；
String——适用于使用少量数据；

3.2String和StringBuffer分别作为参数传递

String虽然是引用类型，但是它是一个常量，所以在做传递的时候，完全可以将其看成基本数据类型数据进行传递；

StringBuffer作为参数传递是引用类型传递,形参的改变会影响实参；

public static void main(String[] args) {
    //引用类型作为参数传递，形参的改变会影响实参。
    //注意：String 类型作为参数传递，属于值传递。会这把字符串的值传递过去
    String str = "abc";
    change(str);
    System.out.println(str);//abc 
    StringBuffer sb = new StringBuffer("Hello");
    change(sb);
    sb.reverse();
    System.out.println(sb);  //呵呵哈哈olleH
}

private static void change(StringBuffer sb) {
    sb.append("哈哈").append("呵呵");
}

private static void change(String str) {
    str+="你好";
    System.out.println(str); //abc你好 之后会弹栈
}

本文地址：https://blog.csdn.net/weixin_41924998/article/details/107690794