2、String类

String类

1. String 对象用于保存字符串，也就是一组字符序列

2. 字符串常量对象是用双引号括起来的字符序列，例如："你好"、"12.07"、"boy"等

3. 字符串的字符使用 Unicode 字符编码，一个字符（不区分字母还是汉字）占两个字节

4. String 类有很多构造器，构造器的重载

   String s1 = new String();
   String s2 = new String(String original);
   String s3 = new String(char[] a);
   String s4 = new String(char[] a,int startIndex,int count);
   String s5 = new String(byte[] b);
   //String 类实现了接口 Serializable 【String 可以串行化：可以在网络传输】
   //				接口 Comparable 【String 对象可以比较大小】
   //String 是final 类，不能被其他的类继承
   //String 有属性 private final char value[]; 用于存放字符串内容
   //一定注意：value 是一个final类型，不可以修改：即value 不能指向新的地址，但是单个字符内容是可以变化
   final char[] value = {'a', 'b','c'};
   char[] v2 = {'t','o','m'};
   value[0] = 'H';
   //value = v2; 不可以修改value 地址
   

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

   • 方式一：直接赋值 String s = "hsp";

     • 先从常量池查看是否有"hsp"数据空间，如果有，直接指向；如果没有则重新创建，然后指向。

       s最终指向的是常量池的空间地址

   • 方式二：调用构造器 String s2 = new String("hsp");

     • 先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp"，重新创建，
       
       如果有，直接通过value指向，最终指向的是堆中的空间地址
       
       

6. 练习题

   String a = "hsp";
   String b = new String("hsp");
   
   System.out.println(a==b.intern()); //T
   System.out.println(b==b,intern()); //F
   
   /*
   知识点：
       当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用equals(Object) 方法确定），
         则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用
    解读：b.intern()方法最终返回的是常量池的地址（对象）
   */
   
   String a = "hello" + "abc"; //==>等价优化 String a = "helloabc";
   
   

7. String对象特性

   String a = "hello";
   String b = "abc";
   //1. 先创建一个 StringBuilder sb = StringBuilder()
   //2. 执行 sb.append("hello")
   //3. sb.append("abc");
   //4. String c = sb.toString()
   //最后其实是 c 指向堆中的对象(String) value[] -> 池中 "helloabc"
   String c = a + b;
   //String c1 = "ab" + "cd"; 常量相加，看的是池。
   //String c1 = a + b; 变量相加，是在堆中
   

   

8. String类的常用方法

   • String 类是保存 字符串常量的，每次更新都需要重新开辟空间，效率极低，因此java设计者还提供了 StringBuilder 和 StringBuffer来增强String的功能，并提高效率。

   • 常用方法

     • equals // 区分大小写，判断内容是否相等

     • equalsIgnoreCase // 忽略大小写的判断内容是否相等

     • length //获取字符的个数，字符串的长度

     • indexOf //获取字符（字符串）在字符串中第一次出现的索引，索引从0开始，如果找不到，返回-1

     • lastIndexOf // 获取字符（字符串）在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1

     • substring // 截取指定范围的字符串

       String name = "hello,张三";
       //下面name.substring(6) 从索引6开始截取后面所有的内容
       System.out.println(name.substring(6));
       //name.substring(0,5) 从索引0开始截取，截取到索引 5-1=4位置
       System.out.println(name.substring(0,5));
       

     • trim // 去前后空格

     • charAt ：获取某索引处的字符，注意不能使用Str[index]这种方式

       String str = "hello";
       //str[0] 不对
       //str.charAt(0) => h
       

     • toUpperCase 转换成大写

     • toLowerCase 转换成小写

     • concat 拼接字符串

       String s1 = "宝玉";
       s1 = s1.concat("林黛玉").concat("薛宝钗").concat("together");
       

     • replace 替换字符串中的字符

       //s1.replace() 方法执行后，返回的结果才是替换过的
       //注意 对 s1 没有任何影响
       
       s1 = "宝玉 and 林黛玉 林黛玉 林黛玉";
       //s1中，将所有的 林黛玉 替换成 薛宝钗
       s11 = s1.replace("林黛玉","薛宝钗");
       System.out.println(s1); // 宝玉 and 林黛玉 林黛玉 林黛玉
       System.out.println(s11); // 宝玉 and 薛宝钗 薛宝钗 薛宝钗
       

     • split 分割字符串，对于某些分割字符，我们需要转义比如 | \\等

       //1. 以 , 为标准对 poem 进行分割，返回一个数组
       //2. 在对字符串进行分割时，如果有特殊字符，需要加入转义符 \
       String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
       String[] split = poem.split(",");
       for (int i = 0; i < split.length; i++) {
           System.out.println(split[i]);
       }
       
       poem = "E\\aaa\\bbb";
       split = poem.split("\\\\");
       for (int i = 0; i < split.length; i++) {
           System.out.println(split[i]);
       }
       
       /*
       	运行结果：
       		锄禾日当午
               汗滴禾下土
               谁知盘中餐
               粒粒皆辛苦
               E
               aaa
               bbb
       */
       

     • toCharArray 转换成字符数组

       String s = "happy";
       char[] chs = s.toCharArray();
       for (int i = 0; i < chs.length; i++) {
           System.out.println(chs[i]);
       }
       
       /*
       	运行结果：
       		h
               a
               p
               p
               y
       */
       

     • compareTo 比较两个字符串的大小，如果前者大，则返回正数，后者大，则返回负数，如果相等，返回0

       //1. 如果长度相同，并且每个字符也相同，就返回0
       //2. 如果长度相同或者不相同，但是在进行比较时，可以区分大小
       //   就返回 if (c1 != c2) {
       //                return c1 - c2;
       //            }
       //3. 如果前面的部分都相同，就返回 str1.len - str2.len
       String a = "jchn";
       String b = "jack";
       System.out.println(a.compareTo(b)); //返回值是 'c' - 'a' = 2 的值
       
       //compareTo 源代码
       public int compareTo(String anotherString) {
           int len1 = value.length;
           int len2 = anotherString.value.length;
           int lim = Math.min(len1, len2);
           char v1[] = value;
           char v2[] = anotherString.value;
           int k = 0;
           while (k < lim) {
               char c1 = v1[k];
               char c2 = v2[k];
               if (c1 != c2) {
                   return c1 - c2;
               }
               k++;
           }
           return len1 - len2;
       }
       

     • format 格式字符串

       // %d 是整数来替换
       // %s 表示后面由字符串来替换
       // %.2f 表示使用小数来替换，替换后，只会保留小数点后两位，并且进行四舍五入的处理
       // %c 使用char 类型来替换
       
       int aaa = 10;
       System.out.format("aaa=%d ",aaa);
       String info1 = "aaa=%d";
       String info2 = String.format(info1,aaa);
       System.out.println(info2);
       
       /*
       	运行结果：
       		aaa=10 aaa=10
       */
       

图片来自于 韩顺平 零基础30天学会Java