Java高级应用——常用类（String类）和（Comparator排序）

常用类（String类）和（Comparator排序）

String类

介绍

String类型本身是使用final关键字声明的，这意味着我们无法继承String类。

String对象的字符内容存储在一个字符数组value[]中。例如，"abc" 等效于 char[] data={'h','e','l','l','o'}。需要注意的是，由于私有访问修饰符的限制，外部无法直接获取字符数组，并且String类没有提供获取和设置value数组的方法。

由于final关键字的存在，字符数组的引用不可改变，同时String类也没有提供方法来修改value数组中的某个元素值。这意味着String代表着不可变的字符序列。换句话说，一旦对字符串进行修改，就会生成一个新的对象。

用法以及常用API

1. 创建字符串对象：
   • 使用字面量创建：String str = "Hello";
   • 使用构造函数创建：String str = new String("Hello");
2. 字符串长度：
   • int length(): 返回字符串的字符个数。
3. 字符串比较：
   • boolean equals(Object obj): 比较字符串与指定对象是否相等。
   • boolean equalsIgnoreCase(String anotherString): 忽略大小写比较字符串是否相等。
   • int compareTo(String anotherString): 按字典顺序比较字符串。
   • int compareToIgnoreCase(String str): 忽略大小写按字典顺序比较字符串。
4. 字符串连接：
   • String concat(String str): 将指定字符串连接到原字符串的末尾。
5. 字符串提取：
   • char charAt(int index): 返回字符串中指定位置的字符。
   • String substring(int beginIndex): 返回从指定索引开始到字符串末尾的子字符串。
   • String substring(int beginIndex, int endIndex): 返回从指定索引开始到指定索引结束的子字符串。
6. 字符串搜索：
   • boolean contains(CharSequence sequence): 判断字符串是否包含指定的字符序列。
   • int indexOf(int ch): 返回指定字符在字符串中第一次出现的位置。
   • int indexOf(String str): 返回指定字符串在字符串中第一次出现的位置。
   • int lastIndexOf(int ch): 返回指定字符在字符串中最后一次出现的位置。
   • int lastIndexOf(String str): 返回指定字符串在字符串中最后一次出现的位置。
7. 字符串替换：
   • String replace(char oldChar, char newChar): 将字符串中的指定字符替换为新字符。
   • String replace(CharSequence target, CharSequence replacement): 将字符串中的指定字符序列替换为新的字符序列。
8. 字符串分割：
   • String[] split(String regex): 根据指定的正则表达式将字符串拆分为子字符串数组。
9. 字符串转换：
   • char[] toCharArray(): 将字符串转换为字符数组。
   • String toLowerCase(): 将字符串转换为小写形式。
   • String toUpperCase(): 将字符串转换为大写形式。
   • String trim(): 去除字符串两端的空格。
10. 字符串格式化：
    • static String format(String format, Object... args): 使用指定的格式字符串和参数创建格式化字符串。
11. 字符串检查：
    • boolean isEmpty(): 判断字符串是否为空（长度为0）。
    • boolean startsWith(String prefix): 判断字符串是否以指定前缀开头。
    • boolean endsWith(String suffix): 判断字符串是否以指定后缀结尾。
12. 字符串拼接：
    • static String join(CharSequence delimiter, CharSequence... elements): 使用指定的分隔符将多个字符序列连接为一个字符串。

StringBuffer和StringBuilder

StringBuffer和StringBuilder是Java中用于处理可变字符串的类，它们提供了一系列方法来进行字符串的增删改操作。

1. StringBuffer和StringBuilder的相同点：
   • 两者都是可变的字符串类，用于处理需要频繁修改的字符串。
   • 它们都位于java.lang包中。
2. StringBuffer和StringBuilder的区别：
   • StringBuffer是线程安全的，适用于多线程环境下的字符串操作，而StringBuilder没有实现线程安全，适用于单线程环境下的字符串操作。
   • StringBuffer的方法使用了synchronized关键字进行同步，保证了线程安全，但在性能上略低于StringBuilder。
   • StringBuilder的方法没有进行同步，因此在单线程环境下性能更高。
3. 创建字符串缓冲区对象：
   • 使用构造函数创建：StringBuffer sb = new StringBuffer(); 或 StringBuilder sb = new StringBuilder();
   • 可以指定初始容量：StringBuffer sb = new StringBuffer(int capacity); 或 StringBuilder sb = new StringBuilder(int capacity);
4. 字符串追加：
   • append(参数): 将参数追加到字符串缓冲区的末尾。
5. 字符串插入：
   • insert(int offset, 参数): 在指定位置插入参数值到字符串缓冲区。
6. 字符串删除：
   • delete(int start, int end): 删除指定范围内的字符。
   • deleteCharAt(int index): 删除指定位置的字符。
7. 字符串替换：
   • replace(int start, int end, String str): 用指定字符串替换指定范围内的字符。
8. 字符串反转：
   • reverse(): 反转字符串缓冲区中的字符顺序。
9. 获取字符串长度：
   • length(): 返回字符串缓冲区的长度（字符个数）。
10. 获取字符串容量：
    • capacity(): 返回字符串缓冲区的当前容量。
11. 设置字符串缓冲区容量：
    • ensureCapacity(int minimumCapacity): 设置字符串缓冲区的最小容量。
12. 转换为字符串：
    • toString(): 将字符串缓冲区对象转换为String类型。

比较器（Comparator）

在Java中，比较器（Comparator）是一种用于定义对象之间顺序关系的接口。它提供了一种机制，允许开发人员根据自定义的规则对对象进行排序。Java中的比较器通常用于集合（如列表、树、堆等）的排序操作，以及实现自定义的排序算法。

比较器接口（Comparator Interface）定义了以下方法：

1. int compare(T obj1, T obj2)： 这是比较器最重要的方法，用于比较两个对象的顺序。它接受两个参数obj1和obj2，表示要比较的对象，返回一个整数值用于表示两个对象的相对顺序关系。具体规则如下：

   • 返回负整数：如果obj1小于obj2。
   • 返回零：如果obj1等于obj2。
   • 返回正整数：如果obj1大于obj2。

2. boolean equals(Object obj)：比较器还可以重写equals()方法，用于判断两个比较器是否相等。

在Java中，比较器可以通过两种方式来使用：

1. 实现Comparator接口：开发人员可以创建一个实现Comparator接口的自定义比较器类。这个类必须实现compare()方法，并根据自定义规则来比较对象。比较器可以用于集合的排序操作，或者在特定的算法中使用。

   例如，下面是一个自定义的比较器类，用于按照字符串长度进行排序：

   import java.util.Comparator;
   
   public class StringLengthComparator implements Comparator<String> {
       @Override
       public int compare(String s1, String s2) {
           return s1.length() - s2.length();
       }
   }
   ```
   
   然后，可以使用这个比较器对字符串列表进行排序：
   
   ````java
   import java.util.Arrays;
   import java.util.Collections;
   import java.util.List;
   
   public class Main {
       public static void main(String[] args) {
           List<String> strings = Arrays.asList("apple", "banana", "orange", "kiwi");
           Collections.sort(strings, new StringLengthComparator());
           System.out.println(strings);
       }
   }
   ```
   
   输出结果为：[kiwi, apple, banana, orange]
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27

2. 使用匿名内部类或Lambda表达式：如果只需要在特定的地方使用比较器，可以使用匿名内部类或Lambda表达式来创建一个临时的比较器对象。

   使用匿名内部类的示例：

   import java.util.Arrays;
   import java.util.Collections;
   import java.util.List;
   
   public class Main {
       public static void main(String[] args) {
           List<String> strings = Arrays.asList("apple", "banana", "orange", "kiwi");
           Collections.sort(strings, new Comparator<String>() {
               @Override
               public int compare(String s1, String s2) {
                   return s1.length() - s2.length();
               }
           });
           System.out.println(strings);
       }
   }
   ```
   
   使用Lambda表达式的示例：
   
   ````java
   import java.util.Arrays;
   import java.util.Collections;
   import java.util.List;
   
   public class Main {
       public static void main(String[] args) {
           List<String> strings = Arrays.asList("apple", "banana", "orange", "kiwi");
           Collections.sort(strings, (s1, s2) -> s1.length() - s2.length());
           System.out.println(strings);
       }
   }
   ```
   
   无论使用哪种方式，比较器都提供了一种灵活的机制，允许开发人员根据自定义规则对对象进行排序。比较器在Java中广泛应用于各种数据结构和算法中。
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35