面向对象编程---02核心类

在Java中，String它本身也是一种引用类型class。但是，java编译器对String有特殊处理，可直接使用"..."表示字符串：

String str = "Hello!"; 

实际上字符串在String内部通过一个char[]数组表示，所以下面的写法也可以:

String s2 = new String(new char[] { 
        'H', 'e', 'l', 'l', 'o', '!'}); 

因为String太常用了，所以Java提供了"..."这种字符串字面量表示方法。

Java字符串的一个重要特征是字符串不可变。这种不可变性是通过内部的private final char[]没有任何修改的字段和字段char[]实现的方法。

当我们想比较两个字符串是否相同时，我们应该特别注意我们实际上想比较字符串的内容是否相同。必须使用equals()但不能使用方法==

public class Main{ 
             public static void main(String[] args) { 
                 String s1 = "hello";         String s2 = "hello";         System.out.println(s1 == s2);         System.out.println(s1.equals(s2));     } } 

尽管结果都是true，但这是因为Java在编译期间，编译器会自动将所有相同的字符串作为对象放入常量池，自然s1和s2引用是一样的。

另一种写法可以看出两种区别：

public class Main{ 
             public static void main(String[] args) { 
        
        String s1 = "hello";
        String s2 = "HELLO".toLowerCase();
        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}

结论：两个字符串比较，必须使用equals()方法

要忽略大小写比较，使用equalsIgnoreCase()方法。

String类还提供了多种方法来搜索、提取子串。常用的方法有：

• str.contains('xx')判断是否包含

// 是否包含子串
"hello".contains("ll");		//true

注意：contains方法的参数是CharSequence而不是String，因为CharSequence是String的父类。

• 搜索子串

"Hello".indexOf("l"); // 2
"Hello".lastIndexOf("l"); // 3
"Hello".startsWith("He"); // true
"Hello".endsWith("lo"); // true

• 提取子串

"Hello".substring(2); // "llo"
"Hello".substring(2, 4); "ll"

注意索引号是从0开始的

使用trim()方法可以移除字符串首尾空白字符。空白字符包括空格、\t、\r、\n：

" \tHello\r\n ".trim(); // "Hello"

trim()并没有改变字符串的内容，而是放回了一个新字符串

另一个strip()方法可以移除字符串首尾空白字符。他和trim()不同的是，类似中午空格字符\u3000也会被移除：

"\u3000Hello\u3000".strip(); // "Hello"
" Hello ".stripLeading(); // "Hello "
" Hello ".stripTrailing(); // " Hello"

String提供isEmpty()和isBlank()来判断字符串是否为空白字符串：

"".isEmpty(); // true，因为字符串长度为0
" ".isEmpty(); // false，因为字符串长度不为0
" \n".isBlank(); // true，因为只包含空白字符
" Hello ".isBlank(); // false，因为包含非空白字符

要在字符串中替换子串，有两种方法。

• 根据字符或字符串替换:

String s = "hello";
s.replace('l','w'); //"hewwo"，所有字符'l'被替换为'w'
s.replace('ll','aa');	// "heaao"，所有子串"ll"被替换为"aa"

• 通过正则表达式替换：

String s = "A,,B;C ,D";
s.replaceAll("[\\,\\;\\s]+", ","); // "A,B,C,D"

上面的代码通过正则表达式，把匹配的子串统一替换为","。

使用split() 方法，并且传入的也是正则表达式：

String s = "A,B,C,D";
String[] ss = s.split("\\,"); // {"A", "B", "C", "D"}

使用静态方法join()，它用指定的字符串连接字符串数组：

String[] arr = { 
        "A", "B", "C"};
String s = String.join("***", arr); // "A***B***C"

字符串提供了formatted()方法和format()静态方法，可以传入其他参数，替换占位符%?，然后生成新的字符串：

public class Main{ 
        
    public static void main(String[] args) { 
        
        String s = "Hi %s, your score is %d!";
        System.out.println(s.formatted("Alice", 80));
        System.out.println(String.format("Hi %s, your score is %.2f!", "Bob", 59.5));
    }
}

有几个占位符，后面就传入几个参数。参数类型要和占位符一致。我们经常用这个方法来格式化信息。常用的占位符有：

• %s：显示字符串；
• %d：显示整数；
• %x：显示十六进制整数；
• %f：显示浮点数。

占位符还可以带格式，例如%.2f表示显示两位小数。如果你不确定用啥占位符，那就始终用%s，因为%s可以显示任何数据类型。要查看完整的格式化语法，请参考JDK文档。

String和char[]类型可以相互转换

char[] cs = "Hello".toCharArray();	//String -> char[]
String s = new String(cs);			//char[] -> String

如果修改了char[]，String并不会改变：

public class Main { 
        
    public static void main(String[] args) { 
        
        char[] cs = "Hello".toCharArray();
        String s = new String(cs);
        System.out.println(s);
        cs[0] = 'X';
        System.out.println(s);
    }
}

这是因为通过new String(char[])创建新的String实例时，它并不会直接引用传入的char[]数组，而是会复制一份，所以，修改外部的char[]数组不会影响String实例内部的char[]数组，因为这是两个不同的数组。

从String的不变性设计可以看出，如果传入的对象有可能改变，我们需要复制而不是直接引用。使用Arrays.copyOf(数组,复制长度)进行复制。

public class Main { 
        
    public static void main(String[] args) { 
        
        int[] scores = new int[] { 
         88, 77, 51, 66 };
        Score s = new Score(scores);
        s.printScores();
        scores[2] = 99;
        s.printScores();
    }
}

class Score { 
        
    private int[] scores;
    public Score(int[] scores) { 
        
       // this.scores = scores; //这样是直接引用的scores地址，scores改变实例变量也会改变
        this.scores = Arrays.copyOf(scores,scores.length);	//进行复制，为实例变量分配新地址
    }

    public void printScores() { 
        
        System.out.println(Arrays.toString(scores));
    }
}

编码介绍：字符串和编码 - 廖雪峰的官方网站 (liaoxuefeng.com)

在Java中，char类型实际上就是两个字节的Unicode编码。可以手动将字符串转换成其他编码：

byte[] b1 = "hello".getBytes();			// 按系统默认编码转换，不推荐
byte[] b2 = "hello".getBytes("UTF-8");	// 按UTF-8编码转换
byte[] b2 = "Hello".getBytes("GBK"); 	// 按GBK编码转换
byte[] b3 = "Hello".getBytes(StandardCharsets.UTF_8); // 按UTF-8编码转换

注意：转换编码后，就不再是char类型，而是byte类型表示的数组

也可以将已知编码的byte[]转换为String：

byte[] b = ...
String s1 = new String(b, "GBK"); 					// 按GBK转换
String s2 = new String(b, StandardCharsets.UTF_8); // 按UTF-8转换

对于不同版本的JDK，String类在内存中有不同的优化方式。具体来说，早期JDK版本的String总是以char[]存储，它的定义如下：

public final class String {
    private final char[] value;
    private final int offset;
    private final int count;
}

而较新的JDK版本的String则以byte[]存储：如果String仅包含ASCII字符，则每个byte存储一个字符，否则，每两个byte存储一个字符，这样做的目的是为了节省内存，因为大量的长度较短的String通常仅包含ASCII字符：

public final class String {
    private final byte[] value;
    private final byte coder; // 0 = LATIN1, 1 = UTF16

对于使用者来说，String内部的优化不影响任何已有代码，因为它的public方法签名是不变的。

使用StringBuilder，在对字符串循环新增字符时，可以预分配缓冲区，不会创建新的临时对象

Java编译器对String做了特殊处理，使得我们可以直接用+拼接字符串。

考察下面的循环代码：

String s = "";
for (int i = 0; i < 1000; i++) {
    s = s + "," + i;
}

虽然可以直接拼接字符串，但是，在循环中，每次循环都会创建新的字符串对象，然后扔掉旧的字符串。这样，绝大部分字符串都是临时对象，不但浪费内存，还会影响GC效率。

为了能高效拼接字符串，Java标准库提供了StringBuilder，它是一个可变对象，可以预分配缓冲区，这样，往StringBuilder中新增字符时，不会创建新的临时对象：

StringBuilder sb = new StringBuilder(1024);
for (int i = 0; i < 1000; i++) {
    sb.append(',');
    sb.append(i);
}
String s = sb.toString();

StringBuilder还可以进行链式操作：

public class Main { 
        
    public static void main(String[] args) { 
        
        var sb = new StringBuilder(1024);
        sb.append("Mr ")
          .append("Bob")
          .append("!")
          .insert(0, "Hello, ");
        System.out.println(sb.toString());
    }
}

这是因为append()方法会返回this，这一样就可以不断调用自身其他方法。

注意：对于普通的字符串+操作，并不需要我们将其改写为StringBuilder，因为Java编译器在编译时就自动把多个连续的+操作编码为StringConcatFactory的操作。在运行期，StringConcatFactory会自动把字符串连接操作优化为数组复制或者StringBuilder操作。

你可能还听说过StringBuffer，这是Java早期的一个StringBuilder的线程安全版本，它通过同步来保证多个线程操作StringBuffer也是安全的，但是同步会带来执行速度的下降。

StringBuilder和StringBuffer接口完全相同，现在完全没有必要使用StringBuffer

要高效拼接字符串，应该使用StringBuilder。

若要按照某种固定分隔符进行拼接，Java标准库还提供了一个StringJoiner来干这个事：

public class Main { 
        
    public static void main(String[] args) { 
        
        String[] names = { 
        "Bob", "Alice", "Grace"};
        var sj = new StringJoiner(", ");
        for (String name : names) { 
        
            sj.add(name);
        }
        System.out.println(sj.toString());
    }
}

可以指定开头和结尾的字符串

public class Main { 
        
    public static void main(String[] args) { 
        
        String[] names = { 
        "Bob", "Alice", "Grace"};
        var sj = new StringJoiner(", ", "Hello ", "!");
        for (String name : names) { 
        
            sj.add(name);
        }
        System.out.println(sj.toString());
    }
}

String还提供了一个静态方法join()，这个方法在内部使用了StringJoiner来拼接字符串，在不需要指定“开头”和“结尾”的时候，用String.join()更方便：

String[] names = { 
        "Bob", "Alice", "Grace"};
var s = String.join(", ", names);

Java的数据类型分为两种

• 基本类型：byte，short，int，long，boolean，float，double，char
• 引用类型：所有class和interface类型

引用类型可以赋值为null，表示空，但基本类型不能赋值为null：

String str = null;
int n = null;	// 编译报错

如何把一个基本类型视为对象（引用类型）

如把int基本类型变成一个引用类型，可以定义一个Integer类。它只包含一个是实例字段int，这样Integer类就可以视为int的包装类（Wrapper Class）：

public class Integer{ 
        
    private int value;
    
    public Interger(int value){ 
        
        this.value = value;
    }
    
    public int intValue(){ 
        
        return this.value;
    }
}

定义好了Integer类，就可以把int和Integer相互转换：

Integer n = null;
Integer n2 = new Integer(99);
int n3 = n2.intValue();

因为包装类很有用，Java核心库为每种基本类型都提供了对应的包装类型：

可以直接使用，不需要和上面一样去自己定义：

public class WrapperClass { 
        
    public static void main(String[] args){ 
        
        int i = 100;

// 通过new操作符创建Integer实例（不推荐，会警告
// Integer n1 = new Integer(i);

// 通过静态方法valueOf(int)创建Integer实例
        Integer n2 = Integer.valueOf(i);
        System.out.println(n2.intValue());

// 通过静态方法valueOf(String)创建Integer实例
        Integer n3 = Integer.valueOf("100");

        System.out.println(n3.intValue());
    }
}

因为int和Integer可以相互转换：

int i = 100;
Integer n = Integer.valueOf(i);
int x = n.intValue();

所以，Java编译器可以自动在int和Integer之间转型：

Integer n = 100;	 // 编译器自动使用Integer.valueOf(int)
int x = n;			// 编译器自动使用Integer.intValue()

这种直接把int变为Integer的赋值写法，被称为自动装箱（Auto Boxing），反过来，把Integer变为int的赋值写法。被称为自动拆箱（Auto Unboxing）

注意：自动装箱和自动拆箱只发生在编译阶段，目的是为了少写代码。

装箱和拆箱会影响代码的执行效率，因为编译后的class代码是严格区分基本类型和引用类型。并且自动拆箱执行时可能会报NullPointerException

所有的包装类型都是不变类，查看Integer的源码可知，它的核心代码如下：

public final class Integer { 
        
    private final int value;
}

因此，一旦创建了Integer对象，该对象就是不变的。

对两个Integer实例进行比较要特别注意：

引用类型做对比，必须使用equals()