• Java-认识String类

    本章重点：

    1. 认识 String 类

    2. 了解 String 类的基本用法

    3. 熟练掌握 String 类的常见操作

    4. 认识字符串常量池

    5. 认识 StringBuffer 和 StringBuilder

    1.String类的重要性

    在C语言中已经涉及到字符串了，但是在C语言中要表示字符串只能使用字符数组或者字符指针，可以使用标准库提 供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字 符串应用又非常广泛，因此Java语言专门提供了String类。 

    2.常用方法

    2.1 字符串构造

    以下是常用的三种：

    1. public static void main(String[] args) {
    2.     // 使用常量串构造
    3.     String s1 = "hello xiaofan";
    4.     System.out.println(s1);
    5.     // 直接newString对象
    6.     String s2 = new String("hello xiaofan");
    7.     System.out.println(s1);
    8.     // 使用字符数组进行构造
    9.     char[] array = {'a','b','c','d'};
    10.     String s3 = new String(array);
    11.     System.out.println(s1);
    12. }

    注意：

    1. String是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下：

    1. public static void main(String[] args) {
    2.     // s1和s2引用的是不同对象 s1和s3引用的是同一对象
    3.     String s1 = new String("hello");
    4.     String s2 = new String("world");
    5.     String s3 = s1;
    6.     System.out.println(s1.length()); // 获取字符串长度---输出5
    7.     System.out.println(s1.isEmpty()); // 如果字符串长度为0，返回true，否则返回false
    8. }

     

    2.2 String对象的比较 

    字符串的比较是常见操作之一，比如：字符串排序。Java中总共提供了4中方式：

    1. ==比较是否引用同一个对象，比较的是地址相不相同

    1.     public static void main(String[] args) {
    2.         int a = 10;
    3.         int b = 20;
    4.         int c = 10;
    5.         // 对于基本类型变量，==比较两个变量中存储的值是否相同
    6.         System.out.println(a == b); // false
    7.         System.out.println(a == c); // true
    8.         // 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
    9.         String s1 = new String("hello");
    10.         String s2 = new String("hello");
    11.         String s3 = new String("world");
    12.         String s4 = s1;
    13.         System.out.println(s1 == s2); // false
    14.         System.out.println(s2 == s3); // false
    15.         System.out.println(s1 == s4); // true
    16.     }

    2. boolean equals(Object anObject) 方法：按照字典序比较

    字典序：字符大小的顺序 String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照 如下规则进行比较，比如： s1.equals(s2)

    1. public boolean equals(Object anObject) {
    2. // 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
    3.     if (this == anObject) {
    4.         return true;
    5.     }
    6. // 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
    7.     if (anObject instanceof String) {
    8. // 将anObject向下转型为String类型对象
    9.         String anotherString = (String)anObject;
    10.         int n = value.length;
    11. // 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
    12.         if (n == anotherString.value.length) {
    13.             char v1[] = value;
    14.             char v2[] = anotherString.value;
    15.             int i = 0;
    16. // 4. 按照字典序，从前往后逐个字符进行比较
    17.             while (n-- != 0) {
    18.                 if (v1[i] != v2[i])
    19.                     return false;
    20.                 i++;
    21.             }
    22.             return true;
    23.         }
    24.     }
    25.     return false;
    26. }
    1.     public static void main(String[] args) {
    2.         String s1 = new String("hello");
    3.         String s2 = new String("hello");
    4.         String s3 = new String("Hello");
    5. // s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
    6.         System.out.println(s1 == s2); // false
    7.         System.out.println(s1 == s3); // false
    8. // equals比较：String对象中的逐个字符
    9. // 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
    10. // s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
    11.         System.out.println(s1.equals(s2)); // true
    12.         System.out.println(s1.equals(s3)); // false
    13.     }

    3. int compareTo(String s) 方法: 按照字典序进行比较

    与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：

    1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值

    2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

    1.     public static void main(String[] args) {
    2.         String s1 = new String("abc");
    3.         String s2 = new String("ac");
    4.         String s3 = new String("abc");
    5.         String s4 = new String("abcdef");
    6.         System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
    7.         System.out.println(s1.compareTo(s3)); // 相同输出 0
    8.         System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
    9.     }

    4. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较

    1. public static void main(String[] args) {
    2.     String s1 = new String("abc");
    3.     String s2 = new String("ac");
    4.     String s3 = new String("ABc");
    5.     String s4 = new String("abcdef");
    6.     System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
    7.     System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
    8.     System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
    9. }

    2.3 字符串查找

    字符串查找也是字符串中非常常见的操作，String类提供的常用查找的方法

     

    1. public static void main(String[] args) {
    2.     String s = "aaabbbcccaaabbbccc";
    3.     System.out.println(s.charAt(3)); // 'b'
    4.     System.out.println(s.indexOf('c')); // 6
    5.     System.out.println(s.indexOf('c', 10)); // 15
    6.     System.out.println(s.indexOf("bbb")); // 3
    7.     System.out.println(s.indexOf("bbb", 10)); // 12
    8.     System.out.println(s.lastIndexOf('c')); // 17
    9.     System.out.println(s.lastIndexOf('c', 10)); // 8
    10.     System.out.println(s.lastIndexOf("bbb")); // 12
    11.     System.out.println(s.lastIndexOf("bbb", 10)); // 3
    12. }

    2.4 转化

    1. 数值和字符串转化

    1. public static void main(String[] args) {
    2. // 数字转字符串
    3.     String s1 = String.valueOf(1234);
    4.     String s2 = String.valueOf(12.34);
    5.     String s3 = String.valueOf(true);
    6.     //String s4 = String.valueOf(new Student("Hanmeimei", 18));
    7.     System.out.println(s1);
    8.     System.out.println(s2);
    9.     System.out.println(s3);
    10.     //System.out.println(s4);
    11.     System.out.println("=================================");
    12. // 字符串转数字
    13. // 注意：Integer、Double等是Java中的包装类型，这个后面会讲到
    14.     int data1 = Integer.parseInt("1234");
    15.     double data2 = Double.parseDouble("12.34");
    16.     System.out.println(data1);
    17.     System.out.println(data2);
    18. }

    2. 大小写转换

    1. public static void main(String[] args) {
    2.     String s1 = "hello";
    3.     String s2 = "HELLO";
    4. // 小写转大写
    5.     System.out.println(s1.toUpperCase());
    6. // 大写转小写
    7.     System.out.println(s2.toLowerCase());
    8. }

    3. 字符串转数组

    1. public static void main(String[] args) {
    2.     String s = "hello";
    3. // 字符串转数组
    4.     char[] ch = s.toCharArray();
    5.     for (int i = 0; i < ch.length; i++) {
    6.         System.out.print(ch[i]);
    7.     }
    8.     System.out.println();
    9. // 数组转字符串
    10.     String s2 = new String(ch);
    11.     System.out.println(s2);
    12. }

    4. 格式化

    1. public static void main(String[] args) {
    2.     String s = String.format("%d-%d-%d", 2019, 9,14);
    3.     System.out.println(s);
    4. }

    2.5 字符串替换

    使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

     

    1. public static void main(String[] args) {
    2.     String str = "helloworld" ;
    3.     System.out.println(str.replaceAll("l", "_")); //替换所有
    4.     System.out.println(str.replaceFirst("l", "_"));  //替换第一个
    5. }

    由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串.

    2.6 字符串拆分

    可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。

     

    1. public static void main(String[] args) {
    2.     String str = "hello world hello xiaofan" ;
    3.     String[] result = str.split(" ") ; // 按照空格拆分
    4.     for(String s: result) {
    5.         System.out.println(s);
    6.     }
    7.     String str1 = "hello world hello xiaofan" ;
    8.     String[] result1 = str.split(" ",2) ;
    9.     for(String s: result1) {
    10.         System.out.println(s);
    11.     }
    12.  
    13. //特殊情况，拆分ip地址
    14.     String str = "192.168.1.1" ;
    15.     String[] result = str.split("\\.") ;
    16.     for(String s: result) {
    17.         System.out.println(s);
    18.     }
    19. }
    20.  
    21.

    注意事项:

    1. 字符"|","*","+"都得加上转义字符，前面加上"\\" .

    2. 而如果是"\\" ，那么就得写成"\\\\" .

    3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

    1. public static void main(String[] args) {
    2.     //多次拆分
    3.     String str = "name=zhangsan&age=18" ;
    4.     String[] result = str.split("&") ;
    5.     for (int i = 0; i < result.length; i++) {
    6.         String[] temp = result[i].split("=") ;
    7.         System.out.println(temp[0]+" = "+temp[1]);
    8.     }
    9. }

    2.7 字符串截取

    1. public static void main(String[] args) {
    2.     String str = "helloworld" ;
    3.     System.out.println(str.substring(5));
    4.     System.out.println(str.substring(0, 5));
    5. }

    1. 索引从0开始

    2. 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标

    2.8 其他操作方法

    1.     public static void main(String[] args) {
    2.         //trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).
    3.         String str = " hello world " ;
    4.         System.out.println("["+str+"]");
    5.         System.out.println("["+str.trim()+"]");
    6.  
    7.     }

     2.9 字符串的不可变性

    String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：

    1. String类在设计时就是不可改变的，String类实现描述中已经说明了

    2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象

    final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内 容是可以修改的。 

    为什么 String 要设计成不可变的?(不可变对象的好处是什么?)

     1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了.

    2. 不可变对象是线程安全的.

    3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中.

    2.10 字符串修改

    注意：尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下。

    1. public static void main(String[] args) {
    2.     String s = "hello";
    3.     s += " world";
    4.     System.out.println(s); // 输出：hello world
    5.  
    6.  
    7.     long start = System.currentTimeMillis();
    8.     String s = "";
    9.     for(int i = 0; i < 10000; ++i){
    10.         s += i;
    11.     }
    12.     long end = System.currentTimeMillis();
    13.     System.out.println(end - start);
    14.     start = System.currentTimeMillis();
    15.     StringBuffer sbf = new StringBuffer("");
    16.     for(int i = 0; i < 10000; ++i){
    17.         sbf.append(i);
    18.     }
    19.     end = System.currentTimeMillis();
    20.     System.out.println(end - start);
    21.     start = System.currentTimeMillis();
    22.     StringBuilder sbd = new StringBuilder();
    23.     for(int i = 0; i < 10000; ++i){
    24.         sbd.append(i);
    25.     }
    26.     end = System.currentTimeMillis();
    27.     System.out.println(end - start);
    28. }

    可以看待在对String类进行修改时，效率是非常慢的，因此：尽量避免对String的直接需要，如果要修改建议尽量 使用StringBuffer或者StringBuilder。 借助StringBuffer 和 StringBuilder来修改

    3. StringBuilder和StringBuffer

    3.1 StringBuilder的介绍

    由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大 部分功能是相同的，这里介绍 StringBuilder常用的一些方法

    1. public static void main(String[] args) {
    2.     StringBuilder sb1 = new StringBuilder("hello");
    3.     StringBuilder sb2 = sb1;
    4. // 追加：即尾插-->字符、字符串、整形数字
    5.     sb1.append(' '); // hello
    6.     sb1.append("world"); // hello world
    7.     sb1.append(123); // hello world123
    8.     System.out.println(sb1); // hello world123
    9.     System.out.println(sb1 == sb2); // true
    10.     System.out.println(sb1.charAt(0)); // 获取0号位上的字符 h
    11.     System.out.println(sb1.length()); // 获取字符串的有效长度14
    12.     System.out.println(sb1.capacity()); // 获取底层数组的总大小
    13.     sb1.setCharAt(0, 'H'); // 设置任意位置的字符 Hello world123
    14.     sb1.insert(0, "Hello world!!!"); // Hello world!!!Hello world123
    15.     System.out.println(sb1);
    16.     System.out.println(sb1.indexOf("Hello")); // 获取Hello第一次出现的位置
    17.     System.out.println(sb1.lastIndexOf("hello")); // 获取hello最后一次出现的位置
    18.     sb1.deleteCharAt(0); // 删除首字符
    19.     sb1.delete(0,5); // 删除[0, 5)范围内的字符
    20.     String str = sb1.substring(0, 5); // 截取[0, 5)区间中的字符以String的方式返回
    21.     System.out.println(str);
    22.     sb1.reverse(); // 字符串逆转
    23.     str = sb1.toString(); // 将StringBuffer以String的方式返回
    24.     System.out.println(str);
    25. }

    String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。频繁修改字符串的情况考虑使用StringBuilder。

    注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则: String变为StringBuilder: 利用StringBuilder的构造方法或append()方法 StringBuilder变为String: 调用toString()方法。

     String、StringBuffer、StringBuilder的区别：

    String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.

    StringBuffer与StringBuilder大部分功能是相似的

    StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作

    String的OJ练习题：

    1. import jdk.nashorn.internal.ir.WhileNode;
    2.  
    3. import java.util.Arrays;
    4. import java.util.Scanner;
    5.  
    6. /**
    7.  * @author xiaofan
    8.  * @version 1.0
    9.  * @date 2023/11/18 22:03
    10.  */
    11. public class Test1 {
    12.     //字符串中的第一个唯一字符
    13.     //在给定一个字符s，找到它的第一个不重复的字符，并返回它的索引，如果不存在，则返回-1
    14.     public static int  firstUniqChar(String s){
    15.         int[] count = new int[26];
    16.         for (int i = 0; i < s.length(); i++) {
    17.             char ch = s.charAt(i);
    18.             count[ch-'a']++;
    19.         }
    20.         for (int i = 0; i < s.length(); i++) {
    21.             char ch = s.charAt(i);
    22.             if (count[ch-'a'] == 1){
    23.                 return i;
    24.             }
    25.         }
    26.         return 1;
    27.  
    28.     }
    29.     public static void main1(String[] args) {
    30.         Scanner scanner = new Scanner(System.in);
    31.         String input = scanner.nextLine();
    32.         System.out.println(firstUniqChar(input));
    33.  
    34.     }
    35.  
    36.     //计算字符串最后一个单词的长度，单词以空格隔开
    37.     public static void main2(String[] args) {
    38.         Scanner scanner = new Scanner(System.in);
    39.         while (scanner.hasNext()){
    40.             String s = scanner.nextLine();
    41.             String[] str = s.split(" ");
    42.             //int index = s.lastIndexOf(' ');
    43.             //String str = s.substring(index+1);
    44.             //int s1 = str[str.length-1].length();
    45.             System.out.println(str[str.length-1].length());
    46.         }
    47.     }
    48.  
    49.  
    50.     //如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。
    51.     //字母和数字都属于字母数字字符
    52.     public  boolean isNumOrCharacter(char ch){
    53.         if (ch >= '0' && ch <= '9' || ch >= 'a' && ch <= 'z'){
    54.             return true;
    55.         }
    56.         return false;
    57.     }
    58.  
    59.     public boolean isPalindrome(String s){
    60.         s = s.toLowerCase();
    61.         //1. 定义i 和 j
    62.         int i = 0;
    63.         int j = s.length()-1;
    64.         //2.  如果i != j
    65.         while (i 
    66.             char ch = s.charAt(i);
    67.             //3. i要一直走到一个合法的字符哪里，有可能i要走很多步
    68.             while (i < j && !isNumOrCharacter(s.charAt(i))){
    69.                 i++;
    70.             }
    71.             //4. j要一直走到一个合法的字符哪里，有可能i要走很多步
    72.             while (i < j && !isNumOrCharacter(s.charAt(j))){
    73.                 j--;
    74.             }
    75.             //5. 对应下标字符一样
    76.             if (s.charAt(i) == s.charAt(j)){
    77.                 i++;
    78.                 j--;
    79.             } else {
    80.                 //6. 对应下标字符不一样
    81.                 return  false;
    82.             }
    83.  
    84.         }
    85.         return true;
    86.     }
    87.     
    88. }

  • 相关阅读:
    C#进阶09——值类型和引用类型2
    当代工业设计体系里的思维导图
    三分钟快速了解什么是MES系统
    11月9日星期四今日早报简报微语报早读
    0079 单链表
    嵌入式设备文件系统构建——增加用户登录功能
    影视广告创意与制作（三）
    快速实现一个企业级域名 SSL 证书有效期监控巡检系统
    python数据容器
    【英语：基础进阶_原著扩展阅读】J1.英文原著的选择和有效阅读方法
  • 原文地址：https://blog.csdn.net/qq_61658398/article/details/134527578