Java外围类

字符串和编码

String

在Java中，String是一个援用类型，它自身也是一个class。然而，Java编译器对String有非凡解决，即能够间接用"..."来示意一个字符串：

String s1 = "Hello!";

实际上字符串在String外部是通过一个char[]数组示意的，因而，按上面的写法也是能够的：

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

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

Java字符串的一个重要特点就是字符串_不可变_。这种不可变性是通过外部的private final char[]字段，以及没有任何批改char[]的办法实现的。

字符串比拟

当咱们想要比拟两个字符串是否雷同时，要特地留神，咱们实际上是想比拟字符串的内容是否雷同。必须应用equals()办法而不能用==。
从外表上看，两个字符串用==和equals()比拟都为true，但实际上那只是Java编译器在编译期，会主动把所有雷同的字符串当作一个对象放入常量池，天然s1和s2的援用就是雷同的。

所以，这种==比拟返回true纯属巧合。换一种写法，==比拟就会失败
论断：两个字符串比拟，必须总是应用equals()办法。

要疏忽大小写比拟，应用equalsIgnoreCase()办法。

String类还提供了多种办法来搜寻子串、提取子串。罕用的办法有：

// 是否蕴含子串:"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也会被移除。
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", "~~"); // "he~~o"，所有子串"ll"被替换为"~~"

另一种是通过正则表达式替换：

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()静态方法，能够传入其余参数，替换占位符，而后生成新的字符串

    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));

类型转换

要把任意根本类型或援用类型转换为字符串，能够应用静态方法valueOf()。这是一个重载办法，编译器会依据参数主动抉择适合的办法：

String.valueOf(123); // "123"String.valueOf(45.67); // "45.67"String.valueOf(true); // "true"String.valueOf(new Object()); // 相似java.lang.Object@636be97c

要把字符串转换为其余类型，就须要依据状况。例如，把字符串转换为int类型：

int n1 = Integer.parseInt("123"); // 123int n2 = Integer.parseInt("ff", 16); // 按十六进制转换，255

把字符串转换为boolean类型：

boolean b1 = Boolean.parseBoolean("true"); // trueboolean b2 = Boolean.parseBoolean("FALSE"); // false

要特地留神，Integer有个getInteger(String)办法，它不是将字符串转换为int，而是把该字符串对应的零碎变量转换为Integer：

Integer.getInteger("java.version"); // 版本号，11

转换为char[]

String和char[]类型能够相互转换，办法是：

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

字符编码

在晚期的计算机系统中，为了给字符编码，美国国家标准学会制订了一套英文字母、数字和罕用符号的编码，它占用一个字节，编码范畴从0到127，最高位始终为0，称为ASCII编码。例如，字符'A'的编码是0x41，字符'1'的编码是0x31。

如果要把汉字也纳入计算机编码，很显然一个字节是不够的。GB2312规范应用两个字节示意一个汉字，其中第一个字节的最高位始终为1，以便和ASCII编码辨别开。例如，汉字'中'的GB2312编码是0xd6d0。

相似的，日文有Shift_JIS编码，韩文有EUC-KR编码，这些编码因为规范不对立，同时应用，就会产生抵触。

为了对立寰球所有语言的编码，寰球对立码联盟公布了Unicode编码，它把世界上次要语言都纳入同一个编码，这样，中文、日文、韩文和其余语言就不会抵触。

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还能够进行链式操作：

    var sb = new StringBuilder(1024);    sb.append("Mr ")      .append("Bob")      .append("!")      .insert(0, "Hello, ");    System.out.println(sb.toString());

如果咱们查看StringBuilder的源码，能够发现，进行链式操作的要害是，定义的append()办法会返回this，这样，就能够一直调用本身的其余办法。

仿照StringBuilder，咱们也能够设计反对链式操作的类。例如，一个能够一直减少的计数器：

public class Main {    public static void main(String[] args) {        Adder adder = new Adder();        adder.add(3)             .add(5)             .inc()             .add(10);        System.out.println(adder.value());    }}class Adder {    private int sum = 0;    public Adder add(int n) {        sum += n;        return this;    }    public Adder inc() {        sum ++;        return this;    }    public int value() {        return sum;    }}

留神：对于一般的字符串+操作，并不需要咱们将其改写为StringBuilder，因为Java编译器在编译时就主动把多个间断的+操作编码为StringConcatFactory的操作。在运行期，StringConcatFactory会主动把字符串连贯操作优化为数组复制或者StringBuilder操作。

你可能还据说过StringBuffer，这是Java晚期的一个StringBuilder的线程平安版本，它通过同步来保障多个线程操作StringBuffer也是平安的，然而同步会带来执行速度的降落。

StringBuilder和StringBuffer接口完全相同，当初齐全没有必要应用StringBuffer。

StringJoiner

相似用分隔符拼接数组的需要很常见，所以Java规范库还提供了一个StringJoiner来干这个事：

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

包装类型

咱们曾经晓得，Java的数据类型分两种：

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

援用类型能够赋值为null，示意空，但根本类型不能赋值为null：

String s = null;int n = null; // compile error!

那么，如何把一个根本类型视为对象（援用类型）？

比方，想要把int根本类型变成一个援用类型，咱们能够定义一个Integer类，它只蕴含一个实例字段int，这样，Integer类就能够视为int的包装类（Wrapper Class）：

public class Integer {    private int value;    public Integer(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外围库为每种根本类型都提供了对应的包装类型：

根本类型

对应的援用类型

boolean -- java.lang.Boolean

byte -- java.lang.Byte

    int i = 100;    // 通过new操作符创立Integer实例(不举荐应用,会有编译正告):    Integer n1 = new Integer(i);    // 通过静态方法valueOf(int)创立Integer实例:    Integer n2 = Integer.valueOf(i);    // 通过静态方法valueOf(String)创立Integer实例:    Integer n3 = Integer.valueOf("100");    System.out.println(n3.intValue());

Auto Boxing

因为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实例进行比拟要特地留神：相对不能用==比拟，因为Integer是援用类型，必须应用equals()比拟

    Integer x = 127;    Integer y = 127;    Integer m = 99999;    Integer n = 99999;    System.out.println("x == y: " + (x==y)); // true    System.out.println("m == n: " + (m==n)); // false    System.out.println("x.equals(y): " + x.equals(y)); // true    System.out.println("m.equals(n): " + m.equals(n)); // true