Java基础知识_3_Java核心类

No.1

字符串和编码

　　String：

　　　　简介：

　　　　　　在Java中，String是一个引用类型，它本身也是一个class。

　　　　　　但是，Java编译器对String有特殊处理，即可以直接用"..."来表示一个字符串：

　　　　　　　　String s1 = "Hello!";：‘

　　　　　　字符串在String内部是通过一个char[]数组表示的，因此，按下面的写法也是可以的：

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

　　　　　　不可变性：

　　　　　　　　Java字符串的一个重要特点就是字符串不可变。

　　　　　　　　这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。

　　　　字符串比较：

　　　　　　两个字符串比较，必须总是使用equals()方法。

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

　　　　搜索子串：

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

　　　　　　　　// 是否包含子串:
　　　　　　　　"Hello".contains("ll"); // true
　　　　　　　　注意到contains()方法的参数是CharSequence而不是String，因为CharSequence是String的父类。
　　　　　　　　CharSequence不可以直接使用new的方式创建对象，但是可以直接给它赋值；

　　　　　　搜索子串的更多的例子：
　　　　　　　　"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"

　　　　移除空白：

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

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

　　　　　　strip()：另一个strip()方法也可以移除字符串首尾空白字符。

　　　　　　　　它和trim()不同的是，类似中文的空格字符\u3000也会被移除：

　　　　　　　　"\u3000Hello\u3000".strip(); // "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", "~~"); // "he~~o"，
　　　　　　　　//所有子串"ll"被替换为"~~"

　　　　　　另一种是通过正则表达式替换：
　　　　　　　　String s = "A,,B;C ,D";
　　　　　　　　s.replaceAll("[\\,\\;\\s]+", ","); // "A,B,C,D"
　　　　　　　　//通过解析正则表达式，把符合条件的子串统一替换为","。其中\\s表示空白字符，+表示复数

　　　　分割字符串：

　　　　　　要分割字符串，使用split()方法，并且传入的也是正则表达式：
　　　　　　　　String s = "A,B,C,D";
　　　　　　　　String[] ss = s.split("\\,"); // {"A", "B", "C", "D"}

　　　　拼接字符串：

　　　　　　拼接字符串使用静态方法join()，它用指定的字符串连接字符串数组：
　　　　　　　　String[] arr = {"A", "B", "C"};
　　　　　　　　String s1 = String.join("***", arr); 　　// "A***B***C"
　　　　　　　　String s2 = String.join("***", "A", "B", "C");　　//s2 == s1

　　　　格式化字符串：

　　　　　　字符串提供了formatted()方法和format()静态方法，用于格式化输出字符串。

　　　　　　可以传入其他参数，替换占位符，生成新的字符串：
　　　　　　　　String s = "Hi %s, your score is %d!";

　　　　　　　　//formatted
　　　　　　　　System.out.println( s.formatted("Alice", 80) );
　　　　　　　　　　//输出：Hi Alice, your score is 80!

　　　　　　　　//format
　　　　　　　　System.out.println( String.format("Hi %s, your score is %.2f!", "Bob", 59.5) );
　　　　　　　　　　//输出：Hi Bob, your score is 59.50!

　　　　　　补充：

　　　　　　　　有几个占位符，后面就要传入几个参数。

　　　　　　　　参数类型要和占位符一致。

　　　　　　　　常用的占位符有：

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

　　　　　　　　占位符还可以带格式，例如%.2f表示显示两位小数。

　　　　　　　　如果不确定用啥占位符，那就始终用%s，因为%s可以显示任何数据类型。

　　　　类型转换：

　　　　　　转换为字符串：

　　　　　　　　要把任意基本类型或引用类型转换为字符串，可以使用静态方法valueOf()。

　　　　　　　　这是一个重载方法，编译器会根据参数自动选择合适的方法：

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

　　　　　　转换为char[]

　　　　　　　　String和char[]类型可以互相转换，方法是：

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

　　　　　　　　如果修改char[]数组，String并不会改变，因为这样的方式会复制一份数据，而不是直接引用。  

 

字符编码

为了统一全球所有语言的编码，全球统一码联盟发布了Unicode编码，它把世界上主要语言都纳入同一个编码，这样，中文、日文、韩文和其他语言就不会冲突。

Unicode编码需要两个或者更多字节表示

UTF-8是一种变长编码，用来把固定长度的Unicode编码变成1～4字节的变长编码。

通过UTF-8编码，英文字符'A'的UTF-8编码变为0x41，正好和ASCII码一致，而中文'中'的UTF-8编码为3字节0xe4b8ad。

UTF-8编码的另一个好处是容错能力强，如果传输过程中某些字符出错，不会影响后续字符，因为UTF-8编码依靠高字节位来确定一个字符究竟是几个字节。

在Java中，char类型实际上就是两个字节的Unicode编码。较新的JDK版本的String则以byte[]存储。如果String仅包含ASCII字符，则每个byte存储一个字符，否则，每两个byte存储一个字符。

 

 

如果String仅包含ASCII字符，则每个byte存储一个字符，否则，每两个byte存储一个字符

StringBuilder
在循环中，每次循环都会创建新的字符串对象
为了能高效拼接字符串，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还可以进行链式操作：
sb.append("Mr ")
.append("Bob")
.append("!")
.insert(0, "Hello, ");
append()方法会返回this，这样，就可以不断调用自身的其他方法。

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

StringJoiner
要高效拼接字符串，应该使用StringBuilder。
String[] names = {"Bob", "Alice", "Grace"};
var sj = new StringJoiner(", ");
for (String name : names) {
sj.add(name);
}
//Bob, Alice, Grace

StringBuilder可以指定开头和结尾。
String[] names = {"Bob", "Alice", "Grace"};
var sj = new StringJoiner(", ", "Hello ", "!");
for (String name : names) {
sj.add(name);
}
//Hello Bob, Alice, Grace!

String.join()
String提供了一个静态方法join()，这个方法在内部使用了StringJoiner来拼接字符串。
String[] names = {"Bob", "Alice", "Grace"};
String s = String.join(", ", names);
//Bob, Alice, Grace

包装类型
想要把基本类型int变成一个引用类型，我们可以定义一个Integer类，它只包含一个实例字段int，
这样，Integer类就可以视为int的包装类
Java核心库为每种基本类型都提供了对应的包装类型

Auto Boxing Auto Unboxing
Java编译器可以帮助我们自动在int和Integer之间转型
Integer n = 100; // 编译器自动使用Integer.valueOf(int)
int x = n; // 编译器自动使用Integer.intValue()
自动装箱和自动拆箱只发生在编译阶段，目的是为了少写代码。
自动拆箱执行时可能会报NullPointerExceptio

不变类
所有的包装类型都是不变类。我们查看Integer的源码可知，它的核心代码如下：
public final class Integer {
private final int value;
}
因此，一旦创建了Integer对象，该对象就是不变的。

不能用==比较为包装类
Integer x = 127; Integer y = 127;
Integer m = 99999; Integer n = 99999;
"x == y: " + (x==y)); // true
"m == n: " + (m==n)); // false
"x.equals(y): " + x.equals(y)); // true
"m.equals(n): " + m.equals(n)); // true
由于缓存优化，Integer.valueOf()对于较小的数，始终返回相同的实例，因此，==比较“恰好”为true

创建Integer
创建Integer的时候，以下两种方法：
方法1：Integer n = new Integer(100);
方法2：Integer n = Integer.valueOf(100);
方法2更好，因为方法1总是创建新的Integer实例，方法2把内部优化留给Integer代码的实现者去做。
我们把能创建“新”对象的静态方法称为静态工厂方法。Integer.valueOf()就是静态工厂方法，它尽可能地返回缓存的实例以节省内存。
Byte.valueOf()返回的Byte实例全部是缓存实例

进制转换
Integer类本身还提供了大量方法，例如，最常用的静态方法parseInt()可以把字符串解析成一个整数：
int x1 = Integer.parseInt("100"); // 100
int x2 = Integer.parseInt("100", 16); // 256,因为按16进制解析

Integer.toString(100)) // "100",表示为10进制
Integer.toString(100, 36) // "2s",表示为36进制
Integer.toHexString(100) // "64",表示为16进制
Integer.toOctalString(100) // "144",表示为8进制
Integer.toBinaryString(100) // "1100100",表示为2进制

上述方法的输出都是String，在计算机内存中，只用二进制表示

所有的整数和浮点数的包装类型都继承自Number，因此，可以非常方便地直接通过包装类型获取各种基本类型：
// 向上转型为Number:
Number num = new Integer(999);
// 获取byte, int, long, float, double:
byte b = num.byteValue();
int n = num.intValue();
long ln = num.longValue();
float f = num.floatValue();
double d = num.doubleValue();

无符号数

因为byte的-1的二进制表示是11111111，以无符号整型转换后的int就是255。
类似的，可以把一个short按unsigned转换为int，把一个int按unsigned转换为long。
byte x = -1;
byte y = 127;
System.out.println(Byte.toUnsignedInt(x)); // 255
System.out.println(Byte.toUnsignedInt(y)); // 127