2022.4.21 常用类 String类

string

特点：

引用类型

字符串是常量;它们的值在创建之后不能更改（在常量池中的字符串不能改变，但是变量指向的地址可以改变）。字符串缓冲区支持可变的字符串。因为 String对象是不可变的，所以可以共享（先检查常量池有没有这个字符串，如果有就不用创建字符串，变量直接指向这个字符串的地址即可）

 

 

 

 

 

 

 

 

特点：

• 如果发现在方法区中没有对应的字符串，会自动开辞内存存储新的字符串

• 字符串一旦创建了，是不能够被修改的

• 字符串虽然不能够被修改，但是可以共享

• 如果字符串频繁的拼接字符串，都会在方法区开辟空间，这样是非常消耗内存空间的，所有如果字符串拼接比较频繁不建议使用String类型，这时我们可以改用StringBuffer或者StringBuilder

 package com.xing.String;
 ​
 public class Test01 {
     public static void main(String[] args) {
         String name = "zhangsan";
         name+="6666";
         System.out.println(name);//zhangsan6666
 ​
         name="haha";
         System.out.println(name);//haha
     }
 }

构造方法：

 package com.xing.String;
 ​
 public class Test02 {
     public static void main(String[] args) {
         //String类型是一个引用类型，那么必然会有对应的构造方法
         String name1 = new String();
         System.out.println(name1);//
 ​
         String name2 = new String("zhangsan");
         System.out.println(name2);//zhangsan
 ​
         char[] c = {'a','b','c'};
         String name3 = new String(c);
         System.out.println(name3);//abc
 ​
         //字符数组c从下标1开始的两个字符
         String name4 = new String(c,1,2);
         System.out.println(name4);//bc
 ​
     }
 }

​

通过构造器获取的String类型和通过字符串字面值获取的字符串的区别

 package com.xing.String;
 ​
 public class Test03 {
     public static void main(String[] args) {
         String name1 = new String("zhangsan");
         String name2 = "zhangsan";
 ​
         System.out.println(name1 == name2);//false 比较的是地址002和001，zhangsan是在name1（形参）时创建的，把形参赋值给了构造器中的char类型数组(也是引用类型，也有地址)
         System.out.println(name1.equals(name2));//true 比较字符串的值
     }
 }

常用方法

 返回类型 方法名 参数
 char charAt (int index) //返回指定索引处的char值
 int indexof (int ch) //返回指定字符在此字符串中第一次出现处的索引    不存在返回-1
 int indexOf(String str) //返回指定字符串在此字符串中第一次出现处的索引   不存在返回-1
 int indexof (int ch,int fromIndex)  //从指定的索引开始搜索,返回在此字符串中第一次出现指定字符处的索引
 ​
 int indexof(String str,int fromIndex)//从指定的索引开始搜索,返回在此字符串中第一次出现指定字符串处的索引
 int lastIndexof(int ch)  //返回指定字符在此字符串中最后一次出现处的索引
 int lastIndexOf(int ch,int fromIndex)//从指定的索引处开始进行反向搜索。返回指定字符在此字符串中最后一次出现处的索引
 ​
 int lastIndexof (String str,int fromIndex)
 String substring (int start)//返回一个新的字符串，它是此字符串的一个子字符串
 String substring (int start,int end)
 int length ()

​

 package com.xing.String;
 ​
 public class Test04 {
     public static void main(String[] args) {
         String str = "HelloWorld";
         System.out.println(str.charAt(0));//H
 ​
         System.out.println(str.indexOf('o'));//4
         System.out.println(str.indexOf('a'));//-1
 ​
         System.out.println(str.indexOf("llo"));//2
         System.out.println(str.indexOf("lla"));//-1
 ​
         //字符串同理
         System.out.println(str.indexOf('o',5));//6  从下标5开始向后搜索o  返回该字符在字符串的索引
         System.out.println(str.indexOf('o',4));//4  从下标4开始搜索o  返回该字符在字符串的索引
 ​
         System.out.println(str.lastIndexOf('o'));// 6  从后向前找o;但是索引值从前向后数
 ​
         //字符串同理
         System.out.println(str.lastIndexOf('o',5));//4 从下标5开始向前搜索o  返回该字符在字符串的索引
         System.out.println(str.lastIndexOf('o',6));//6
 ​
         System.out.println(str.substring(5));//World 从下标5开始截取字符串(包括下标5)
         System.out.println(str.substring(5,7));//Wo 从下标5开始截取字符串到第7个(包括下标5,不包括下标7)
 ​
         
     }
 }
 

面试题 ：length、length()、size()的区别

• length:是数组的属性

• length():是字符串或者其他类的一个方法

• size():是集合或者其他类的一个长度

课堂案例: 从键盘输入一个字符串，统计这个字符串中的大写字母，小写字母及数字的个数

 package com.xing.String;
 import java.util.Scanner;
 ​
 public class Test05 {
     public static void main(String[] args) {
         Scanner scanner = new Scanner(System.in);
 ​
         String s = scanner.nextLine();
         int uppercase = 0;
         int lowercase = 0;
         int number = 0;
         for (int i = 0; i < s.length(); i++) {
             char c = s.charAt(i);
             if (c >= 'A' && c <= 'Z') {
                 uppercase++;
             } else if (c > 'a' && c <= 'z') {
                 lowercase++;
             } else if (c >= '0' && c <= '9'){
                 number++;
             }
         }
 ​
     }
 }
 

返回结果为布尔型的方法

"" 与null

 

 boolean isEmpty():判断字符串是否为空。
 boolean equals(object obj):将此字符串的内容与指定的对象比较,区分大小写。
 boolean equalsIgnoreCase(String str):将此String 与另一个String 比较,忽略大小写。
 boolean contains(String str):判断字符串中是否包含方法传入的字符串。
 boolean startswith(String str):判断字符串是否以某个指定的字符串开头。
 boolean endswith(String str):判断字符串是否以某个指定的字符串结尾。
 boolean isEmpty ( ):判断字符串是否为空。

 package com.xing.String;
 ​
 public class Test06 {
     public static void main(String[] args) {
         String str1 = "HelloWorld123";
         String str2 = null;
         String str3 = "";
 ​
         System.out.println(str1.isEmpty());//false
         //System.out.println(str2.isEmpty());  报错  方法有实例调用  可是str2为空
         System.out.println(str3.isEmpty());//true
 ​
         //在实际开发中判断字符串是否为空
         if("".equals(str1) || str1 == null){
             System.out.println("为空");
         }
 ​
         System.out.println(str1.contains("123"));//true
 ​
         System.out.println(str1.startsWith("Hello"));//true
         System.out.println(str1.endsWith("123"));//true
     }
 }

类型转换的相关方法

 返回值类型 方法名 参数
 byte[] getBytes () :将字符串转化为字节数组。
 char[] toCharArray ():将字符串转化为字符数组。
 static String valueof(char[] chs):将字符数组转换为字符串
 static String valueof(int i) :将整型转换为字符串
               valueOf(char c)
               valueOf(long l)
               valueOf(float f)
               valueOf(double d)
               valueOf(boolean b)
               valueOf(char[] data)
 ​
 String toLowerCase():将此string中的所有字符都转换为小写。
 String toUpperCase () :将此string 中的所有字符都转换为大写。
 String concat(String str):将指定字符串连接到此字符串的结尾。​

 package com.xing.String;
 ​
 public class Test07 {
     public static void main(String[] args) {
         String str = "aaBBccDDeeFF";
         byte[] b = str.getBytes();
         for (byte b1 : b) {
             System.out.println(b1);//打印的是ASCLL码值
             System.out.println((char) b1);//打印每个字符
         }
 ​
         char[] c = str.toCharArray();
         for (char c1 : c) {
             System.out.println(c1);//打印每个字符
         }
 ​
         System.out.println(String.valueOf(c));//将字符数组转换为字符串
         
         System.out.println(String.valueOf(97));//将int型97 转换为String型97
         System.out.println("" + 97);//与上面同理
 ​
         System.out.println(str.toLowerCase());
         System.out.println(str.toUpperCase());
 ​
         System.out.println(str.concat("abc"));//aaBBccDDeeFFabc
         System.out.println(str + "abc");//与上面同理
     }
 } 

练习

将一个字符串的首字母转换为大写，其他字母转换为小写，同时将每个字符使用__下划线分割开分析: 原字符串: helloworldHahahaA 转换后的字符串:H_e_l_l_o_w_o_r_l_d_h_a_h_a_h_a_a

第一种思路:

• 将字符串转换为字符数组

• 遍历字符数组

• 判断如果i=0将字符转换为大写然后拼接 _

• 如果i!=0将字符转换为小写如果i != length-1拼接

 package com.xing.String;
 ​
 public class Test08 {
     public static void main(String[] args) {
         String str = "helloworld";
         String result = "";//保存结果
 ​
         char[] ch1 = str.toCharArray();
         for (int i = 0; i < ch1.length; i++) {
             char c = ch1[i];
             String s = String.valueOf(c);//将字符转换为字符串
             if (i == 0) {
                 result += s.toUpperCase();
                 result += "_";
             } else if (i == ch1.length - 1) {
                 result += s.toLowerCase();
             }else{
                 result += s.toLowerCase();
                 result += "_";
             }
         }
         System.out.println(result);
         
         System.out.println("法二");
 ​
         String first = str.substring(0,1).toUpperCase();//截取首字母变为大写
         String other = str.substring(1).toUpperCase();//出首字母外都变为小写
         first.concat(other);//拼接
     }
 }​

其他方法

 String replace (char old, char new) :替换功能。
 String replace (String old,String new) :替换功能。
 String trim ():去除字符串两空格。
 int compareTo(String str) :按字典顺序比较两个字符串。
 int compareToIgnoreCase(String str):按字典顺序比较两个字符串，忽略大小写。
 public String[] split(String regex):分隔字符串成字符数组。

​
     

 package com.xing.String;
 ​
 public class Test09 {
     public static void main(String[] args) {
         String str = "HelloWorld";
         System.out.println(str.replace('o','Z'));//HellZWZrld   替换所有符合字符
         System.out.println(str.replace("World","111"));//Hello111   替换字符串
         System.out.println(str.replace("abc","aaa"));//HelloWorld   不存在返回原来字符串
 ​
         String str1 = "  asd a 1   ";
         System.out.println(str1.trim());//asd a 1   去除字符串两端空格
 ​
 ​
         String s1 = "abc";
         String s2 = "adf";
         System.out.println(s1.compareTo(s2));//-2 s1的字符与s2的字符相比 大于正数,小于负数,相等为0 字母越靠后越大
 ​
         String s3 = "abc,herk,89,a0a8,h";
         String[] s4= s3.split(",");//通过,分割字符串
         for (String s : s4) {
             System.out.print(s+" ");
         }//abc herk 89 a0a8 h
     }
 }​

案例：字符串倒置

 package com.xing.String;
 ​
 public class Test10 {
     public static void main(String[] args) {
         String s1 = "abcdefg";
         String result="";//接收结果
 ​
         char[] c = s1.toCharArray();
         for (int i = c.length - 1; i >= 0; i--) {
             String s = String.valueOf(c[i]);
             result += s;
 ​
             //result+=c[i]   相当于上面两步;
         }
         System.out.println(result);
     }
 }

 

 ​