• Java String、StringBuilder、StringJoiner区别实例讲解

    String创建的俩种方式

    1.直接赋值

    String str = "Hello World!";

            当使用直接赋值的方式去创建字符串的时候，虚拟机会去串池里去检查字符串是否存在，如果没有会创建一个然后将地址值赋值给变量；有的话就直接将地址赋值给变量，可以复用，推荐这样写节省内存。记住！！！存储在串池！！！

    2.使用new去创建

    //常用的构造，其他构造方法可以自己去api文档查看
    String str = new String();
    String str = new String(char[] arr);//将字符类型数组转换为字符串
    String str = new String(byte[] arr);//将字节类型数组转换为字符串

            使用new去创建字符串，虚拟机会在堆里开辟一个新的空间，然后将地址值赋值给变量，不推荐空参创建。 

    字符串的比较 

    小tips: ==号比的是什么？

            分为俩种情况一种是基本数据类型，一种是引用类型

            基本数据类型：具体比的是值

            引用数据类型： 比的是地址值

            进入真题

            字符串我们已经知道是引用数据类型，那我们就不能使用==去比较他们的值，除了直接赋值去可以比较他们的地址值，因为串池里的字符串是可以复用的。

            字符串的比较主要有俩种方式：

    boolean equals(); //区分大小写

    boolean equalsIgnoreCase() //不区分大小写

    常用方法

            常用方法主要有俩种，一种是截取，一种是替换：

    Sting substring(开始索引, 结束索引); //截取字符串，包头不包尾，取不到结束索引

    String replace(旧值，要替换的值); //旧值都替换成要替换的值

     StringBuilder跟StringJoiner

            它们都可以看成一个容器，创建之后里面的内容是可变的。

            StringBuilder主要作用是提高字符串的操作效率

            StingJoiner主要作用是提升拼接字符串的效率

            StringBuilder的常用方法

    public StringBuilder append(任意类型);      //添加数据返回对象本身

    public StringBuilder reverse()                     //反转容器中的内容

    public int length()                                        //返回长度(字符出现的个数)

    public String toString()                                //实现在StringBuilder转成String

            StringJoiner的构造方法

    new StringJoiner("间隔符号");     

    new StringJoiner(间隔符号,开始符号,结束符号); 

             StringJoiner的常用方法 

    add();         //添加元素到容器

    length();     //返回字符的个数

    toString();   //转成字符串

    附上例题 

     1. 键盘录入一个字符串 要求长度小于9 只能是数字转换为阿拉伯数字

    1.  public static void main(String[] args) {
    2.         Scanner sc = new Scanner(System.in);
    3.  
    4.         //1. 键盘录入一个字符串 要求长度小于9 只能是数字
    5.         System.out.print("请输入符合规则的字符串: ");
    6.         String str = "";
    7.         while (true) {
    8.             str = sc.next();
    9.             boolean b = checkStr(str);
    10.             if (b) {
    11.                 break;
    12.             } else {
    13.                 System.out.print("您输入的字符串不符合规则，请重新输入: ");
    14.             }
    15.         }
    16.  
    17.         //2. 将字符串转换为罗马数字
    18.         StringBuilder sb = new StringBuilder();
    19.         for (int i = 0; i < str.length(); i++) {
    20.             int index = str.charAt(i) - 48;
    21.             sb.append(changeLuoMa(index));
    22.         }
    23.  
    24.         //4. 输出结果
    25.         System.out.println(sb.toString());
    26.  
    27.     }
    28.  
    29.  
    30.     // 将字符转换为罗马数字
    31.     public static String changeLuoMa(int index) {
    32.         String[] str = {" ", "I ", "II ", "III ", "IV ", "VI ", "VII ", "VIII ", "IX "};
    33.         return str[index];
    34.     }
    35.  
    36.     //字符串检查
    37.     public static boolean checkStr(String str) {
    38.         if (str.length() > 9) {
    39.             return false;
    40.         }
    41.         for (int i = 0; i < str.length(); i++) {
    42.             if (str.charAt(i) < '0' || str.charAt(i) > '9') {
    43.                 return false;
    44.             }
    45.         }
    46.         return true;
    47.     }

     2. 旋转比较俩个字符串是否会相等

    1. public static void main(String[] args) {
    2.  
    3.         String str1 = "abcd";
    4.         String str2 = "bcda";
    5.  
    6.         boolean flag = check(str1, str2);
    7.  
    8.         System.out.println(flag);
    9.  
    10.     }
    11.  
    12.     private static boolean check(String str1, String str2) {
    13.         for (int i = 0; i < str1.length(); i++) {
    14.             str1 = rotate(str1);
    15.             if(str1.equals(str2)) {
    16.                 return true;
    17.             }
    18.         }
    19.         return false;
    20.     }
    21.  
    22.     public static String rotate(String str) {
    23.         char first = str.charAt(0);
    24.         String end = str.substring(1);
    25.         return end + first;
    26.     }

    3. 键盘输入任意字符串，打乱里面的内容

    1. public static void main(String[] args) {
    2.         //键盘输入任意字符串，打乱里面的内容
    3.         Scanner sc = new Scanner(System.in);
    4.         Random random = new Random();
    5.  
    6.         System.out.print("请输入字符串: ");
    7.         String str = sc.next();
    8.  
    9.         char[] arr = str.toCharArray();
    10.  
    11.         for (int i = 0; i < arr.length; i++) {
    12.             int index = random.nextInt(arr.length);
    13.             char temp = arr[i];
    14.             arr[i] = arr[index];
    15.             arr[index] = temp;
    16.         }
    17.  
    18.         System.out.println(new String(arr));
    19.  
    20.  
    21.     }

    4.  生成验证码

    1. //生成验证码                                                               
    2. //内容：可以是小写字母，也可以是大写字母，还可以是数字                                          
    3. //规则：                                                                 
    4. //长度为5                                                                
    5. //内容中是四位字母，1位数字。                                                      
    6. //其中数字只有1位，但是可以出现在任意的位置。                                              
    7. public static void main(String[] args) {                              
    8.     Random random = new Random();                                     
    9.     char[] arr = getCharArr();                                        
    10.     char[] numArr = {'0','1','2','3','4','5','6','7','8','9'};        
    11.     char[] result = new char[5];                                      
    12.                                                                       
    13.     for (int i = 0; i < result.length - 1; i++) {                     
    14.         int index = random.nextInt(arr.length);                       
    15.         result[i] = arr[index];                                       
    16.     }                                                                 
    17.                                                                       
    18.     result[result.length - 1] = numArr[random.nextInt(numArr.length)];
    19.                                                                       
    20.     for (int i = 0; i < result.length; i++) {                         
    21.         int index = random.nextInt(result.length);                    
    22.         char temp = result[i];                                        
    23.         result[i] = result[index];                                    
    24.         result[index] = temp;                                         
    25.     }                                                                 
    26.                                                                       
    27.     System.out.println(result);                                       
    28.                                                                       
    29. }                                                                     
    30.                                                                       
    31. //创建随机的字母数组                                                           
    32. public static char[] getCharArr() {                                   
    33.     char[] arr = new char[48];                                        
    34.     for (int i = 0; i < arr.length; i++) {                            
    35.         if (i < 24) {                                                 
    36.             arr[i] = (char) (65 + i);                                 
    37.         } else {                                                      
    38.             arr[i] = (char) (97 + i - 24);                            
    39.         }                                                             
    40.     }                                                                 
    41.     return arr;                                                       
    42. }

    5. 由键盘录入一个字符串，统计字符串中英文字母和数字分别有多少个

    1.  //请编写程序，由键盘录入一个字符串，统计字符串中英文字母和数字分别有多少个。比如：Hello12345World中字母：10个，数字：5个。
    2.     public static void main(String[] args) {
    3.  
    4.         int numberCount = 0;
    5.         int charCount = 0;
    6.  
    7.         Scanner sc = new Scanner(System.in);
    8.  
    9.         System.out.print("请输入字符串: ");
    10.         String str = sc.next();
    11.  
    12.         char[] arr = str.toCharArray();
    13.  
    14.         for (int i = 0; i < arr.length; i++) {
    15.             if(arr[i] >= '0' && arr[i] <= '9') {
    16.                 numberCount++;
    17.             }else if((arr[i] >= 'a' && arr[i] <= 'z') || (arr[i] > 'A' && arr[i] < 'Z')) {
    18.                 charCount++;
    19.             }
    20.         }
    21.  
    22.         System.out.println("numberCount => " + numberCount);
    23.         System.out.println("charCount => " + charCount);
    24.     }

     6. 判断一个字符串是否是对称的字符串

    1.  //请定义一个方法用于判断一个字符串是否是对称的字符串，并在主方法中测试方法。例如："abcba"、"上海自来水来自海上"均为对称字符串。
    2.     public static void main(String[] args) {
    3.         Scanner sc = new Scanner(System.in);
    4.         System.out.print("请输入字符串: ");
    5.         String str = sc.next();
    6.         StringBuilder sb = new StringBuilder(str);
    7.         String s = sb.reverse().toString();
    8.         boolean result = str.equals(s);
    9.         System.out.println("result => " + result);
    10.     }

    7.  检验身份证

    1. //我国的居民身份证号码，由由十七位数字本体码和一位数字校验码组成。请定义方法判断用户输入的身份证号码是否合法，
    2.     // 并在主方法中调用方法测试结果。规则为：号码为18位，不能以数字0开头，前17位只可以是数字，最后一位可以是数字或者大写字母X。
    3.     public static void main(String[] args) {
    4.         Scanner sc = new Scanner(System.in);
    5.         System.out.print("请输入您的身份证: ");
    6.         String id = sc.next();
    7.         boolean result = isOk(id);
    8.         System.out.println("result => " + result);
    9.     }
    10.  
    11.     public static boolean isOk(String str) {
    12.         if (str.length() != 18) {
    13.             return false;
    14.         }
    15.         if (str.charAt(0) == '0') {
    16.             return false;
    17.         }
    18.         for (int i = 0; i < str.length() - 1; i++) {
    19.             if (str.charAt(i) < '0' || str.charAt(i) > '9') {
    20.                 return false;
    21.             }
    22.         }
    23.         char end = str.charAt(str.length() - 1);
    24.         if (end == 'X' || end == 'x' || (end < '9' && end > '0')) {
    25.  
    26.         }else {
    27.             return false;
    28.         }
    29.         return true;
    30.     }

     8.  int数组转换为字符串

    1. //定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。
    2.     public static void main(String[] args) {
    3.         int[] arr = {1, 2, 3, 4, 5, 6};
    4.         String result = print(arr);
    5.         System.out.println("result => " + result);
    6.     }
    7.  
    8.     public static String print(int[] arr) {
    9.         StringJoiner sj = new StringJoiner(", ", "[", "]");
    10.         for (int i = 0; i < arr.length; i++) {
    11.             sj.add(arr[i] + "");
    12.         }
    13.         return sj.toString();
    14.     }

    好了， 以上是本文所有内容，希望对大家有所帮助，也希望大家对码农之家多多支持，你们的支持是我创作的动力！祝大家生活愉快！   

  • 相关阅读:
    day4|gin的中间件和路由分组
    达梦数据库-日期类型常用函数汇总
    辉芒微IO单片机FT60F12F-MRB
    openGauss向量化Merge Join--inner join
    30岁本科男，在测试行业干了五年还只会功能测试，难道真的要去送外卖吗？
    [NAS] Synology (群晖) DSM7.0 使用自定义供应商DDNS
    [学习记录] SpringBoot 4. 开发技巧
    年轻人如何预防胆囊结石？
    数据特征选择 | Lasso特征选择（Python）
    Java(JavaEE)学习线路图
  • 原文地址：https://blog.csdn.net/wuxiaopengnihao1/article/details/127852506