1.Scanner类与String类

1.1 Scanner类

Scanner类作用

用Scanner类的方法可以完成接收键盘录入的数据

  1. package com.igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-24-10:08
  6.  */
  8. import java.util.Scanner;
  10. /**
  11.  * 用于字符串的获取
  12.  * Scanner用于获取键盘输入的数据（基本类型，字符串类型）
  13.  * 获取字符串类型：nextLine();--获取下一行字符串的数据（换行）
  14.  *              next();--获取下一个字符开始的数据（不换行）
  15.  * 获取int类型：nextInt();
  16.  *
  17.  */
  18. public class ScannerDemo {
  19.     public static void main(String[] args) {
  20.         //实例化Scanner--系统中提供好的api
  21.         Scanner sc=new Scanner(System.in);//System.in表示系统中输入的内容获取
  22.         //接收数据
  23.         System.out.println("请输入数据：");
  24.         String s=sc.nextLine();
  25.         String s1=sc.next();
  26.         int n=sc.nextInt();
  27.         System.out.println("s:"+s);
  28.         System.out.println("s1:"+s1);
  29.         System.out.println("n:"+n);
  30.         //Scanner其实就是一个占用的资源，使用结束以后记得关闭
  31.         //如果不关闭，会一直占用内存
  32.         sc.close();
  33.     }
  34. }

1.2 String类

String类概述

通过JDK提供的API，查看String类的说明
A:”abc”是String类的一个实例,或者成为String类的一个对象
B:字符串字面值”abc”也可以看成是一个字符串对象
C:字符串是常量，一旦被赋值，就不能被改变
D:字符串本质是一个字符数组

  1. package com.igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-24-10:25
  6.  */
  8. /**
  9.  * 字符串：string
  10.  * 属于java.lang包下的api，使用的时候不需要导包
  11.  *
  12.  * 字符串是一个串，是多个字符连接而成
  13.  *
  14.  * 字符串的底层其实就是字符类型的数组
  15.  */
  16. public class PreString {
  17.     public static void main(String[] args) {
  18.         //储备知识
  19.         String s="王嘉尔好帅！";
  21.         //底层的实现--字符类型的数组
  22.         char[] c={'王','嘉','尔','好','帅','！'};
  23.     }
  24. }

String类的构造方法

  1.           String(String original):把字符串数据封装成字符串对象<br />              String(char[] value):把字符数组的数据封装成字符串对象<br />              String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象<br />**注意：字符串是一种比较特殊的引用数据类型，直接输出字符串对象输出的是该对象中的数据。**<br />/**<br />* **面试题：**<br />* String s="hello";s=s+"world",<br />* 问：原始值变了没有<br />* 答案：没有<br />* 解释：因为String是不可变类，即类的实例是不可被修改的。<br />*在这段代码中，s原来指向一个String对象，内容是“hello”，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个String对象，内容为”helloworld！",原来那个对象还存在内存中，只是s这个引用变量不再指向他了。<br />*/<br />//        String s="hello";<br />//        s1=s+"world";<br />//        System.out.println(s);<br />//        System.out.println(s1);
  1. package com.igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-24-10:30
  6.  */
  8. /**
  9.  * 演示String常用的构造方法
  10.  *
  11.  * 构造函数：
  12.  * String(String original):把字符串封装成字符串对象
  13.  * String(char[] value):把字符数组封装成字符串对象
  14.  * String(char[] value，int index,int count):把一部分字符数组封装成字符串对象
  15.  *
  16.  * 注意：
  17.  * 字符串是一个比较特殊的引用类型数据，直接输出字符串对象的时候输出的就是对象中的数据
  18.  */
  19. public class StringDemo {
  20.     public static void main(String[] args) {
  21.         //方式1--用的最多
  22.         String s1=new String("hello");
  23.         //在String的底层重写了toString()方法
  24.         System.out.println(s1);//hello
  25.         System.out.println("---------------");
  27.         //方式2
  28.         char[] chs={'h','e','l','l','o'};
  29.         //char chs[]={'h','e','l','l','o'};//也可以
  30.         String s2=new String(chs);
  31.         System.out.println(s2);//hello
  33.         //方式3
  34.         String s3=new String(chs,0, chs.length);
  35.         System.out.println(s3);//hello
  37.         String s4=new String(chs,1,3);
  38.         System.out.println(s4);//ell
  40.         //方式4--字符串的特殊声明方式，直接按照基本类型的声明格式使用！！
  41.         // --是Java对于String的恩赐
  42.         String s5="故事的";
  43.         System.out.println(s5);//故事的
  44.         int a=10;
  45. //        Integer i=new Integer(a);
  46.         System.out.println(a);//10
  48.         /**
  49.          * 面试题：
  50.          * String s="hello";s=s+"world",
  51.          * 问：原始值变了没有
  52.          * 答案：没有
  53.          * 解释：因为String是不可变类，即类的实例是不可被修改的。
  54.          */
  55. //        String s="hello";
  56. //        s1=s+"world";
  57. //        System.out.println(s);
  58. //        System.out.println(s1);
  60.     }
  61. }

创建字符串对象两种方式的区别

1.通过构造函数创建的字符串保存在堆中
2.直接声明的字符串保存在方法区中的常量池中

常量池的作用：

  • Java字符串的优化机制

  • 1.如果说利用直接声明字符串的时候会去常量池查找，如果有相同的字符串存在

    1.    则直接拿来使用，不再创建新的字符串

  • 2.如果使用构造函数声明字符串（new），那么不管常量池中有没有相同的字符串都会在堆中

  • 创建一个新的字符串对象
  • ==：
  • 基本类型：比较的是数据类型的值是不是相同
  • 引用类型：比较的是引用类型的地址值是否相同 ```java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-11-24-11:07 */

/**

  • 当前案例演示通过构造函数创建字符串和直接声明字符串的区别
  • 1.通过构造函数创建的字符串保存在堆中
  • 2.直接声明的字符串保存在方法区中的常量池中 *
  • 常量池的作用：
  • Java字符串的优化机制
  • 1.如果说利用直接声明字符串的时候会去常量池查找，如果有相同的字符串存在
  • 则直接拿来使用，不再创建新的字符串 *2.如果使用构造函数声明字符串（new），那么不管常量池中有没有相同的字符串都会在堆中
  • 创建一个新的字符串对象 *
  • ==：
  • 基本类型：比较的是数据类型的值是不是相同

  • 引用类型：比较的是引用类型的地址值是否相同 */ public class StringDemo02 { public static void main(String[] args) {

    1.  //构造函数创建
    2.  String s1=new String("hello");
    4.  //直接声明
    5.  String s2="hello";
    6.  System.out.println(s1);
    7.  System.out.println(s2);
    9.  //比较地址值
    10.  System.out.println("s1==s2:"+(s1==s2));//s1==s2:false
    12.  //s3直接从常量池中去拿的，并没有创建新的对象，其实就是s2
    13.  String s3="hello";
    14.  System.out.println("s1==s3:"+(s1==s3));//s1==s3:false
    15.  System.out.println("s2==s3:"+(s2==s3));//s2==s3:true

    } } ``` image.png，

    String类的判断功能

    boolean equals(Object obj):比较字符串的内容是否相同
    boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
    boolean startsWith(String str):判断字符串对象是否以指定的str开头
    boolean endsWith(String str):判断字符串对象是否以指定的str结尾 ```java package com.igeek_04;

/**

  • @author Lynn
  • @create 2020-11-25-0:34 */

/**

  • String判断的演示 *对象的顶级父类：Object
  • 是类层级结构中的根类（是Java中的顶级父类），所有的类都直接或者是间接的继承Object *
  • String判断功能
  • boolean equals（Object）：比较两个字符串的内容是不是相同（比较两个双胞胎像不像）
  • boolean equalsIgnoreCase（String str）：比较两个字符串的内容是不是一样，忽略大小写
  • boolean startWith（String str）：判断这个字符串是不是以指定的str开头
  • boolean endWith（String str）：判断这个字符串是不是以指定的str结束 *
  • 注意:
  • ==与equals的区别（面试题）
  • 1.==在基本类型中比较的是两个变量的值是不是相等
  • 2.==在引用类型中比较的是两个对象的地址值是不是相同
  • 3.equals在引用类型中比较的是两个对象像不像

  • 4.在Object类中有一个equals方法，这个方法如果不重写，是按照==的比较规则进行比较的 */ //public class StringDemo extends Object{ // String name; // // @Override // public String toString() { // return “StringDemo{“ + // “name=’” + name + ‘\’’ + // ‘}’; // } //} public class StringDemo{ public static void main(String[] args) {

    1.  //创建字符串的对象--直接赋值方式
    2.  String s1="hello";
    3.  String s2="hello";
    4.  String s3="HELLO";
    6.  //boolean equals(Object):比较两个字符串的内容是不是相同（比较两个双胞胎像不像）
    7.  System.out.println(s1.equals(s2));//true
    8.  System.out.println(s1.equals(s3));//false
    9.  System.out.println(s1.equalsIgnoreCase(s3));//true
    11.  //boolean startWith（String str）：判断这个字符串是不是以指定的str开头--大小写敏感
    12.  System.out.println(s1.startsWith("h"));//true
    14.  //boolean endWith（String str）：判断这个字符串是不是以指定的str结束--大小写敏感
    15.  System.out.println(s1.endsWith("o"));//true

    } } ```

    判断功能案例

    需求:模拟登录,给三次机会,并提示还有几次 ```java package com.igeek_04;

/**

  • @author Lynn
  • @create 2020-11-26-20:42 */

import java.util.Scanner;

/**

  • 需求:模拟登录,给三次机会,并提示还有几次
  • 分析：
  • A:定义两个字符串对象，用于存储已经存在的用户名和密码
  • B:键盘录入用户名和密码
  • C:拿键盘录入的用户名和密码和已经存在的用户名和密码进行比较
  • 如果内容相同，提示登录成功
  • 如果内容不同，提示登录失败，并提示还有几次机会 */ public class Test { public static void main(String[] args) { //定义两个字符串对象，用于存储已经存在的用户名和密码 String username=”wlll”; String userpswd=”wlll”;
  1.     //给三次机会，用for循环实现
  2.     for (int i = 0; i <3 ; i++) {
  3.         //键盘录入用户名和密码
  4.         Scanner sc=new Scanner(System.in);
  5.         System.out.println("请输入用户名");
  6.         String name=sc.nextLine();
  7.         System.out.println("请输入密码");
  8.         String pswd=sc.nextLine();
  10.         //拿键盘录入的用户名和密码和已经存在的用户名和密码进行比较
  11.         if (username.equals(name) && userpswd.equals(pswd)){
  12.             System.out.println("登录成功!");
  13.             break;
  14.         }else if (i==2){
  15.             System.out.println("用户名和密码被锁定,请与管理员联系!");
  16.         }else {
  17.             System.out.println("登录失败,你还有"+(2-i)+"次机会！");//2,1,0
  18.             //break;
  19.         }
  20.     }
  21. }

}

  1. <a name="aXBvn"></a>
  2. ### String类的获取功能
  3. String类的获取功能：
  5. - int length():获取字符串的长度，其实也就是字符个数
  6. - char charAt(int index):获取指定索引处的字符
  7. - int indexOf(String str):获取str在字符串对象中第一次出现的索引
  8. - String substring(int start):从start开始截取字符串
  9. - String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end
  10. ```java
  11. package com.igeek_02_04;
  13. /**  
  14. * @ClassName: StringDemo  
  15. * @Description: String类的获取功能
  16. * @date 2017年11月11日 上午11:03:08    
  17. * Company www.igeekhome.com
  18. *    
  19. * String类的获取功能：
  20. *     int length():获取字符串的长度，其实也就是字符个数
  21. *     char charAt(int index):获取指定索引处的字符
  22. *     int indexOf(String str):获取str在字符串对象中第一次出现的索引
  23. *     String substring(int start):从start开始截取字符串
  24. *     String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end
  25. */
  27. public class StringDemo {
  28.     public static void main(String[] args) {
  29.         //创建字符串对象
  30.         String s = "helloworld";
  32.         //int length():获取字符串的长度，其实也就是字符个数
  33.         System.out.println(s.length());
  34.         System.out.println("--------");
  36.         //char charAt(int index):获取指定索引处的字符
  37.         System.out.println(s.charAt(0));
  38.         System.out.println(s.charAt(1));
  39.         System.out.println("--------");
  41.         //int indexOf(String str):获取str在字符串对象中第一次出现的索引
  42.         System.out.println(s.indexOf("l"));
  43.         System.out.println(s.indexOf("owo"));
  44.         System.out.println(s.indexOf("ak"));
  45.         System.out.println("--------");
  47.         //String substring(int start):从start开始截取字符串
  48.         System.out.println(s.substring(0));
  49.         System.out.println(s.substring(5));
  50.         System.out.println("--------");
  52.         //String substring(int start,int end):从start开始，到end结束截取字符串
  53.         System.out.println(s.substring(0, s.length()));
  54.         System.out.println(s.substring(3,8));
  56.     }
  57. }

案例

  1. package com.igeek_02_04;
  3. /**  
  4. * @ClassName: StringTest  
  5. * @Description: 遍历字符串(获取字符串中的每一个字符)
  6. * @date 2017年11月11日 上午11:09:15    
  7. * Company www.igeekhome.com
  8. *    
  9. */
  10. public class StringTest {
  11.     public static void main(String[] args) {
  12.         //创建一个字符串对象
  13.         String s = "abcde";
  15.         //原始做法
  16.         System.out.println(s.charAt(0));
  17.         System.out.println(s.charAt(1));
  18.         System.out.println(s.charAt(2));
  19.         System.out.println(s.charAt(3));
  20.         System.out.println(s.charAt(4));
  21.         System.out.println("---------");
  23.         //用for循环改进
  24.         for(int x=0; x<5; x++) {
  25.             System.out.println(s.charAt(x));
  26.         }
  27.         System.out.println("---------");
  29.         //用length()方法获取字符串的长度
  30.         for(int x=0; x<s.length(); x++) {
  31.             System.out.println(s.charAt(x));
  32.         }
  33.     }
  35. }
  1. package com.igeek_02_04;
  3. import java.util.Scanner;
  5. /**  
  6. * @ClassName: StringTest2  
  7. * @Description: 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
  8. * @date 2017年11月11日 上午11:10:44    
  9. * Company www.igeekhome.com
  10. *    
  11. * 分析：
  12. *         A:键盘录入一个字符串数据
  13. *         B:定义三个统计变量，初始化值都是0
  14. *         C:遍历字符串，得到每一个字符
  15. *         D:拿字符进行判断
  16. *             假如ch是一个字符。
  17. *             大写：ch>='A' && ch<='Z'
  18. *             小写：ch>='a' && ch<='z'
  19. *             数字：ch>='0' && ch<='9'
  20. *         E:输出结果
  21. */
  23. public class StringTest2 {
  24.     public static void main(String[] args) {
  25.         //键盘录入一个字符串数据
  26.         Scanner sc = new Scanner(System.in);
  27.         System.out.println("请输入一个字符串数据：");
  28.         String s = sc.nextLine();
  30.         //定义三个统计变量，初始化值都是0
  31.         int bigCount = 0;
  32.         int smallCount = 0;
  33.         int numberCount = 0;
  35.         //遍历字符串，得到每一个字符
  36.         for(int x=0; x<s.length(); x++) {
  37.             char ch = s.charAt(x);
  38.             //拿字符进行判断
  39.             if(ch>='A' && ch<='Z') {
  40.                 bigCount++;
  41.             }else if(ch>='a' && ch<='z') {
  42.                 smallCount++;
  43.             }else if(ch>='0' && ch<='9') {
  44.                 numberCount++;
  45.             }else {
  46.                 System.out.println("该字符"+ch+"非法");
  47.             }
  48.         }
  50.         //输出结果
  51.         System.out.println("大写字符："+bigCount+"个");
  52.         System.out.println("小写字符："+smallCount+"个");
  53.         System.out.println("数字字符："+numberCount+"个");
  54.     }
  56. }

String类的转换功能

char[] toCharArray():把字符串转换为字符数组
String toLowerCase():把字符串转换为小写字符串
String toUpperCase():把字符串转换为大写字符串

案例

  1. package com.igeek_02_05;
  3. /**  
  4. * @ClassName: StringDemo  
  5. * @Description: String类的转换功能
  6. * @date 2017年11月11日 上午11:13:33    
  7. * Company www.igeekhome.com
  8. *    
  9. * String类的转换功能：
  10. *     char[] toCharArray():把字符串转换为字符数组
  11. *     String toLowerCase():把字符串转换为小写字符串
  12. *     String toUpperCase():把字符串转换为大写字符串
  13. * 
  14. * 字符串的遍历：
  15. *         A:length()加上charAt()
  16. *         B:把字符串转换为字符数组，然后遍历数组
  17. */
  19. public class StringDemo {
  20.     public static void main(String[] args) {
  21.         //创建字符串对象
  22.         String s = "abcde";
  24.         //char[] toCharArray():把字符串转换为字符数组
  25.         char[] chs = s.toCharArray();
  26.         for(int x=0; x<chs.length; x++) {
  27.             System.out.println(chs[x]);
  28.         }
  29.         System.out.println("-----------");
  31.         //String toLowerCase():把字符串转换为小写字符串
  32.         System.out.println("HelloWorld".toLowerCase());
  33.         //String toUpperCase():把字符串转换为大写字符串
  34.         System.out.println("HelloWorld".toUpperCase());
  35.     }
  37. }
  1. package com.igeek_02_05;
  3. import java.util.Scanner;
  5. /**  
  6. * @ClassName: StringTest  
  7. * @Description: 键盘录入一个字符串，把该字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
  8. * @date 2017年11月11日 上午11:16:20    
  9. * Company www.igeekhome.com
  10. *    
  11. * 分析：
  12. *         A:键盘录入一个字符串
  13. *         B:截取首字母
  14. *         C:截取除了首字母以外的字符串
  15. *         D:B转大写+C转小写
  16. *         E:输出即可
  17. */
  19. public class StringTest {
  20.     public static void main(String[] args) {
  21.         //键盘录入一个字符串
  22.         Scanner sc = new Scanner(System.in);
  23.         System.out.println("请输入一个字符串：");
  24.         String s = sc.nextLine();
  26.         //截取首字母
  27.         String s1 = s.substring(0, 1);
  29.         //截取除了首字母以外的字符串
  30.         String s2 = s.substring(1);
  32.         //B转大写+C转小写
  33.         String s3 = s1.toUpperCase()+s2.toLowerCase();
  35.         //输出即可
  36.         System.out.println("s3:"+s3);
  37.     }
  39. }

String类的其它功能

去除字符串两端空格

  1.   String trim()

按照指定符号分割字符串

  1.   String[] split(String str)

案例

  1. package com.igeek_02_06;
  3. /**  
  4. * @ClassName: StringDemo  
  5. * @Description: String类的其它功能
  6. * @date 2017年11月11日 上午11:18:31    
  7. * Company www.igeekhome.com
  8. *    
  9. * 去除字符串两端空格    
  10. *        String trim()
  11. * 按照指定符号分割字符串    
  12. *        String[] split(String str)
  13. */
  15. public class StringDemo {
  16.     public static void main(String[] args) {
  17.         //创建字符串对象
  18.         String s1 = "helloworld";
  19.         String s2 = "  helloworld  ";
  20.         String s3 = "  hello  world  ";
  21.         System.out.println("---"+s1+"---");
  22.         System.out.println("---"+s1.trim()+"---");
  23.         System.out.println("---"+s2+"---");
  24.         System.out.println("---"+s2.trim()+"---");
  25.         System.out.println("---"+s3+"---");
  26.         System.out.println("---"+s3.trim()+"---");
  27.         System.out.println("-------------------");
  29.         //String[] split(String str)
  30.         //创建字符串对象
  31.         String s4 = "aa,bb,cc";
  32.         String[] strArray = s4.split(",");
  33.         for(int x=0; x<strArray.length; x++) {
  34.             System.out.println(strArray[x]);
  35.         }
  36.     }
  38. }

String类的其它案例

  1. package com.igeek_02_06;
  3. /**  
  4. * @ClassName: StringTest  
  5. * @Description: 把数组中的数据按照指定个格式拼接成一个字符串
  6. * @date 2017年11月11日 上午11:20:04    
  7. * Company www.igeekhome.com
  8. *    
  9. * 举例：int[] arr = {1,2,3};    
  10. * 输出结果：[1, 2, 3]
  11. * 
  12. * 分析：
  13. *         A:定义一个int类型的数组
  14. *         B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串
  15. *         C:调用方法
  16. *         D:输出结果
  17. */
  18. public class StringTest {
  19.     public static void main(String[] args) {
  20.         //定义一个int类型的数组
  21.         int[] arr = {1,2,3};
  23.         //写方法实现把数组中的元素按照指定的格式拼接成一个字符串
  25.         //调用方法
  26.         String s = arrayToString(arr);
  28.         //输出结果
  29.         System.out.println("s:"+s);
  30.     }
  32.     /*
  33.     * 两个明确：
  34.     *         返回值类型：String
  35.     *         参数列表：int[] arr
  36.     */
  37.     /**  
  38.     * @Title: arrayToString  
  39.     * @Description: 数组转成字符串  
  40.     * @param arr
  41.     * @return    
  42.     */
  43.     public static String arrayToString(int[] arr) {
  44.         String s = "";
  46.         //[1, 2, 3]
  47.         s += "[";
  48.         for(int x=0; x<arr.length; x++) {
  49.             if(x==arr.length-1) {
  50.                 s += arr[x];
  51.             }else {
  52.                 s += arr[x];
  53.                 s += ", ";
  54.             }
  55.         }
  56.         s += "]";
  57.         return s;
  58.     }
  60. }

字符串反转

  1. package com.igeek_02_06;
  3. import java.util.Scanner;
  5. /**  
  6. * @ClassName: StringTest2  
  7. * @Description: 字符串反转
  8. * @date 2017年11月11日 上午11:23:19    
  9. * Company www.igeekhome.com
  10. *    
  11. * 举例：键盘录入”abc”        
  12. * 输出结果：”cba”
  13. * 
  14. * 分析：
  15. *         A:键盘录入一个字符串
  16. *         B:写方法实现字符串的反转
  17. *             a:把字符串倒着遍历，得到的每一个字符拼接成字符串。
  18. *             b:把字符串转换为字符数组，然后对字符数组进行反转，最后在把字符数组转换为字符串
  19. *         C:调用方法
  20. *         D:输出结果
  21. */
  23. public class StringTest2 {
  24.     public static void main(String[] args) {
  25.         //键盘录入一个字符串
  26.         Scanner sc = new Scanner(System.in);
  27.         System.out.println("请输入一个字符串：");
  28.         String s = sc.nextLine();
  30.         //写方法实现字符串的反转
  32.         //调用方法
  33.         String result = reverse(s);
  35.         //输出结果
  36.         System.out.println("result:"+result);
  37.     }
  39.     /*
  40.     * 把字符串倒着遍历，得到的每一个字符拼接成字符串。
  41.     * 
  42.     * 两个明确：
  43.     *         返回值类型：String
  44.     *         参数列表：String s
  45.     */
  46.     /*
  47.     public static String reverse(String s) {
  48.         String ss = "";
  50.         for(int x=s.length()-1; x>=0; x--) {
  51.             ss += s.charAt(x);
  52.         }
  54.         return ss;
  55.     }
  56.     */
  58.     /**  
  59.     * @Title: reverse  
  60.     * @Description: 把字符串转换为字符数组，然后对字符数组进行反转，最后在把字符数组转换为字符串
  61.     * @param s
  62.     * @return    
  63.     */
  64.     public static String reverse(String s) {
  65.         //把字符串转换为字符数组
  66.         char[] chs = s.toCharArray();
  68.         //对字符数组进行反转
  69.         for(int start=0,end=chs.length-1; start<=end; start++,end--) {
  70.             char temp = chs[start];
  71.             chs[start] = chs[end];
  72.             chs[end] = temp;
  73.         }
  75.         //最后在把字符数组转换为字符串
  76.         String ss = new String(chs);
  77.         return ss;
  78.     }
  80. }

1.3 StringBuilder类

StringBuffer和StringBuilder的区别：

  • 1.StringBuffer是可追加的字符串，使用的方式和StringBuilder完全一样
  • 2.区别：
  • StringBuilder是jdk5.0推出的，线程不安全，但是效率高，优先选择使用
  • StringBuffer是jdk1.0推出的，线程是安全的，但是效率低（非特殊情况，可以不使用）
  • 3.Java在当初设计的时候做了过度设计，所以在jdk5.0的时候就推出了StringBuilder

  • 线程安全：一群人过安检—一个一个的过
  • 线程不安全：一群难民抢馒头吃 ```java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-11-25-10:04 */

/**

  • StringBuffer和StringBuilder的区别：
  • 1.StringBuffer是可追加的字符串，使用的方式和StringBuilder完全一样
  • 2.区别：
  • StringBuilder是jdk5.0推出的，线程不安全，但是效率高，优先选择使用
  • StringBuffer是jdk1.0推出的，线程是安全的，但是效率低（非特殊情况，可以不使用）
  • 3.Java在当初设计的时候做了过度设计，所以在jdk5.0的时候就推出了StringBuilder *
  • 线程安全：一群人过安检—一个一个的过

  • 线程不安全：一群难民抢馒头吃 / public class StringBufferDemo { public static void main(String[] args) {

    1.  //创建对象
    2.  StringBuffer sb=new StringBuffer();//不需要导包，就属于lang包
    3.  //StringBuilder sb=new StringBuilder();结果一样
    5.  //链式编程
    6.  sb.append("黄药师，").append("洪七公，").append("欧阳锋，").append("段王爷，").append("王重阳");
    7.  System.out.println(sb);

    } } ```

    StringBuilder类概述

    StringBuilder：是一个可变的字符串。字符串缓冲区类。
    String和StringBuilder的区别：
    String的内容是固定的
    StringBuilder的内容是可变的

    StringBuilder类的常用方法

    A:构造方法:
    StringBuilder()
    B:成员方法:
    public int capacity():返回当前容量 (理论值)
    public int length():返回长度(已经存储的字符个数)
    public StringBuilder append(任意类型):添加数据，并返回自身对象
    public StringBuilder reverse():反转功能 ```java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-11-25-10:17 */

/**

  • StringBuilder:是一个可变长度的字符串 *
  • 构造函数：StringBuilder（）
  • 常用的成员方法：
  • public int capacity():返回当前的容量—理论值(默认值—16)
  • public int length():返回长度（字符数）—实际值 */ public class StringBuilderDemo { public static void main(String[] args) {
    1.  //创建对象
    2.  StringBuilder sb=new StringBuilder();
    3.  System.out.println(sb);//空的可变字符串
    4.  System.out.println("sb.capacity():"+sb.capacity());//16  --默认值
    5.  System.out.println("sb.length():"+sb.length());//0
    } } ```

    ```java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-11-25-10:26 */

/**

  • 其他的用法：
  • 1.添加功能：append(任意类型的数据)

  • 2.反转功能：reverse（） */ public class StringBuilderDemo02 { public static void main(String[] args) {

    1.  //创建对象
    2.  StringBuilder sb=new StringBuilder();
    3.  //添加
    4.  StringBuilder sb2=sb.append("你好");
    5.  //输出结果
    6.  System.out.println("sb:"+sb);//sb:你好
    7.  System.out.println("sb2:"+sb2);//sb2:你好
    8.  System.out.println(sb==sb2);//true
    10.  //StringBuilder中的append方法会将所有的追加的元素统一转换为字符串进行处理--其实际效果就是：任意类型的数据+“
    11.  sb.append(true);
    12.  sb.append(9999);
    13.  sb.append("王嘉尔");
    14.  System.out.println(sb);//你好true9999王嘉尔
    16.  //反转功能
    17.  sb.reverse();
    18.  System.out.println(sb);//尔嘉王9999eurt好你

    } } ```

    案例

    ```java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-11-25-10:43 */

import java.util.Scanner;

/**

  • 回文：
  • 上海自来水来自海上 *
  • 判断是不是回文
  • 是：返回true

  • 否：返回false */ public class Test { public static void main(String[] args) {

    1.  //作用：程序的主入口，在业务逻辑中调用层--main方法中的业务逻辑越少越好
    2.  Scanner sc=new Scanner(System.in);
    3.  System.out.println("请输入字符串：");
    4.  String s=sc.nextLine();
    6.  //调用方法
    7.  boolean flag=isSymmetry(s);//s表示通过sc获取到的字符串
    8.  System.out.println(flag);
    10.  sc.close();

    // StringBuilder sb=new StringBuilder(“上海自来水来自海上”); // StringBuilder sb2=new StringBuilder(sb.reverse()); // // System.out.println(); // System.out.println(sb.equals(sb2));//true

// sb.append(12321); // System.out.println(sb.reverse()); // System.out.println(sb==sb.reverse()); // System.out.println(“————————————————“); // // System.out.println(sb2.reverse()); // System.out.println(sb2==sb2.reverse()); } //封装一个方法—业务逻辑的封装—封装的越彻底越好 public static boolean isSymmetry(String s){ //逻辑代码—把字符串进行反转，之后的结果相同 //String转化成StringBuilder—再调用reverse()—再转回String //通过构造函数 StringBuilder sb=new StringBuilder(s); sb.reverse(); //转回String String result= sb.toString();

  1.     //比较结果是不是一样，--两个字符串是不是一样（反转前后）
  2.     //result是经过反转之后的字符串
  3.     //s是sc获取到用户输入的字符串
  4.     return result.equals(s);
  5. }

} ```