javaSE(从0开始）day12-优快云博客

public class Main {
    public static void main(String[] args) {
        String s = "Hello";
        System.out.println(s);
        
        // s未指向新的字符串
        s.toUpperCase();
        System.out.println(s);
        
        // s重新指向新的字符串
        s = s.toUpperCase();
        System.out.println(s);
    }
}

2、字符串的定义：

（1）直接定义字符串：String s0="我爱中国";

（2）使用无参构造创建对象： String s1=new String();

（3）使用有参构造创建对象：String s2=new String("我本将心向明月");

（4）使用char类型的数组：String s3=new String(new char[]{'我','爱','中','国'});

(5) 使用byte类型的数组创建: String s4=new String(new byte[]{65,66,67,68});

3、字符串的比较：当我们想要比较两个字符串是否相同时，要特别注意，我们实际上是想比较字符串的内容是否相同。必须使用`equals()`方法而不能用 `==` 关系运算符。字符串不可变性，存在常量池，会优先在常量池中寻找，改变变量的指向地址。

两个字符串用==和equals()比较都为true，但实际上那只是Java编译器在编译期，会自动把所有相同的字符串当作一个对象放入常量池，s1和s2的引用地址就是相同的，结果为true。所以，这种==比较返回true纯属巧合。换一种写法，==比较就会失败，

//处在字符串常量池
String s1 ="hello";
String s2="hello";
System.out.println(s1==s2);
//new 开辟空间  存在堆内
String s3 =new String("hello");
String s4=new String("hello");
System.out.println(s3==s4);
System.out.println(s3.equals(s4));  //比较内容

4、字符串的搜索：

（1）indexOf()：从字符串的首部进行搜索，当前字符串中指定子字符串的下标位置，返回值为`int`类型。如果存在，则返回该子字符串的下标位置。如果不存在，则返回`-1`；

(2)indexOf( int index)：从字符串的index效标位置进行搜索，当前字符串中指定子字符串的下标位置，返回值为`int`类型。如果存在，则返回该子字符串的下标位置。如果不存在，则返回`-1`；

（3）`lastIndexOf()`方法是从字符串的尾部进行搜索，返回值与`indexOf()`方法一致；

（4）`startsWith()`和`endsWith()`方法是用于判断字符串是否以指定字符串开头或结尾，返回值为`boolean`类型；

（5）`startsWith(int )`用于判断字符串从index 下标开始是否以指定字符串开头

（6）c`ontains()`方法用于查找当前字符串中是否存在指定子字符串，返回值为`boolean`类型。

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

5、截取字符串：

`（1）substring(int )`方法可以从当前字符串中，截取从下标0开始到下标 int 的子字符串。

`（2）substring(int int)`方法可以从当前字符串中，截取指定下标区间的子字符串。

"大漠孤烟直".substring(2); // 孤烟直
"大漠孤烟直".substring(0,2); // 大漠

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

//去除首尾空格   包含\n\t\r
String s1 ="\t   ajsdc  sdvdf\n";
System.out.println(s1.trim()+"abc");   //产生新的字符串对象 s1不发生改变
System.out.println(s1);  //不发生改变

`7、String`还提供了`isEmpty()`判断字符串是否为空字符串：

"".isEmpty(); // true，因为字符串长度为0
" ".isEmpty(); // false，因为字符串长度不为0

8、替换字符串：字符串中替换子串，有两种方法。

（1）根据字符或字符串替换。replace（）

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

（2）通过正则表达式替换。replaceAll()

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

9、分割字符串：使用`split()`方法，并且传入的也是正则表达式：

String str1 = "北京#上海#大连#连云港#南京#杭州#深圳#齐齐哈尔#乌鲁木齐";
String[] ret1 = str1.split("#"); // 按照普通字符内容切割
System.out.println(Arrays.toString(ret1));

String str2 = "北京.上海.大连.连云港.南京.杭州.深圳.齐齐哈尔.乌鲁木齐";
String[] ret2 = str2.split("\\."); // "."是正则表达式中符号，所以需要转义
System.out.println(Arrays.toString(ret2));

String str3 = "北京0上海1大连2连云港3南京4杭州5深圳6齐齐哈尔7乌鲁木齐";
String[] ret3 = str3.split("[0-9]"); // 按照正则表达式切割字符串
System.out.println(Arrays.toString(ret3));

10、拼接字符串：

（1）`format()`静态方法格式化字符串，可以传入其他参数，替换占位符，然后生成新的字符串。

String s = "Hi %s, your score is %d!";
System.out.println(s.format("Alice", 80)); // 字符串对象调用
System.out.println(String.format("Hi %s, your score is %.2f!", "Bob", 59.5)); // 字符串类调用

（2）静态方法join()，用指定的字符串连接字符串数组

String[] strs={"北京","上海","大连","连云港"};

String str=String.join("_",strs);//拼接结果为字符串

11、类型转换：把任意基本类型或引用类型转换为字符串，可以使用静态方法`valueOf()`。这是一个重载方法，编译器会根据参数自动选择合适的方法：

（1）基本类型转字符串：

int number=23;
String str1=""+number;
System.out.println(str1);
String str2=String.valueOf(number);
System.out.println(str2);

（2）引用数据类型转字符串：

Random r1=new Random();

System.out.println(r1.toString());

String str3=String.valueOf(r1);

System.out.println(str3);

（3）数组转字符串：

char[] ch={'我','爱','中','国'};

System.out.println(new String (ch));//方式一、字符串底层传入的是字符数组 System.out.println(String.valueOf(ch));//方式二

12、字符编码：getBytes()获取当前字符串的字节信息，如果不出传入参数使用默认的编码格式进行转换：

String str = "中国人abc";
char[] chars = str.toCharArray();
System.out.println(Arrays.toString(chars));

//getBytes()获取当前字符串的字节信息，如果不出传入参数使用默认的编码格式进行转换
//getBytes("GBK");
//UTF-8 (3字节) GBK(2字节)
//获取当前的字符串的字节数组 --UTF-8
byte[] bytes = str.getBytes("GBK");
System.out.println(Arrays.toString(bytes));

//以gbk编码格式对gbk编码格式获取的字节数组进行转字符串
System.out.println(new String(bytes, "GBK"));

二、StringBuilder ：往`StringBuilder`中新增字符时，不会创建新的临时对象

1、使用无参构造创建：StringBuilder sb = new StringBuilder();

2、使用有参创建，每次一指定长度作为数组初始化容量：StringBuilder sb1 = new StringBuilder(10000);

3、以指定字符串进行初始化：StringBuilder sb2 = new StringBuilder("hello");

4 、方法

（1）追加append(String):往末尾插入指定元素

(2) 删除 deleteCharAt(int):删除指定下标的字符 delete(begin,end)删除指定下标到指定位置的字符

（3）插入元素：insert(0,"hello");往指定位置插入指定字符串。

（4）反转：reverse()：反转字符串

（5）查看字符串的长度：length()

（6）比较：

StringBuilder sb1 = new StringBuilder("hello");
StringBuilder sb2 = new StringBuilder("hello");

System.out.println("地址相等" + (sb1 == sb2));  //false

System.out.println("内容相等" + sb1.equals(sb2));  //fasle 比较地址

System.out.println("内容相等" + sb1.toString().equals(sb2.toString()));  //true 使用字符串的equals

5、高效拼接字符串

（1）StringJoiner：

 String[] names={"Bob","Alice","Grace"};
 //但参构造：参数为拼接符
 //如果拼接结果前需要前面的“hello”和结尾的“！”,需要给StringJoiner指定的开头和结尾
 StringJoiner sj =new StringJoiner(",","hello","!");
 for (String str:names) {
     sj.add(",");
 }
 System.out.println(sj);

（2）：`String.join()`

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

6、小结：

StringBuilder是可变对象，用来高效拼接字符串。
StringBuilder可以支持链式操作，实现链式操作的关键是返回实例本身。
StringBuffer线程安全（现在很少使用），性能较差；StringBuilder线程不安全，但性能较好。

三、包装类型：

在Java中，数据类型被分两种：基本类型和引用类型。引用类型可以赋值为null，表示空，但基本类型不能赋值为null：

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

如何把一个基本类型转换为对象（引用类型）？比如，想要把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;
}
}

实际上，因为包装类型非常有用，Java核心库为每种基本类型都提供了对应的包装类型, 我们可以直接使用，并不需要自己去定义：

1、创建Integer对象：

（1）Integer i1=new Integer(23);

Integer i2= new Integer("23");

（2）Integer i3 =Integer.valueOf(12);

Integer i4 =Integer.valueOf("123");

Integer i5 =Integer.valueOf("12",8); //将对应进制的字符串转换为十进制

（3）Integer包装类有常量缓存池有范围：-128~127

Integer i3=Integer.valueOf(-128);
Integer i4=Integer.valueOf(-128);
System.out.println(i3==i4);    //true
System.out.println(i3.equals(i4)); //true

Integer i5=Integer.valueOf(-129);
Integer i6=Integer.valueOf(-129);
System.out.println(i5==i6);    //false
System.out.println(i5.equals(i6));

2、自动装箱：基本数据类型-->引用数据类型安全装箱和拆箱会影响代码的执行效率

int number = 10;
Integer i1 = number;//Integer.valueOf()
System.out.println(i1);

3、自动拆箱：引用数据类型-->基本数据类型不安全拆箱时可能发生`NullPointerException`

Integer i2=new Integer("99");
int number2=i2;// 默认调用i2.intValue();
System.out.println(number2);

4、进制转换：parseInt()

`I(1)其他进制转十进制：nteger`类本身还提供了大量方法，例如，最常用的静态方法`parseInt()`可以把字符串解析成一个整数：

int x1 = Integer.parseInt("100"); // 100
int x2 = Integer.parseInt("100", 16); // 256,因为按16进制解析

`（2）十进制转其他进制：Integer`还可以把整数格式化为指定进制的字符串：

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

5、Java的包装类型还定义了一些有用的静态变量：

// boolean只有两个值true/false，其包装类型只需要引用Boolean提供的静态字段:
Boolean t = Boolean.TRUE;
Boolean f = Boolean.FALSE;

// int可表示的最大/最小值:
int max = Integer.MAX_VALUE; // 2147483647
int min = Integer.MIN_VALUE; // -2147483648

// long类型占用的bit和byte数量:
int sizeOfLong = Long.SIZE; // 64 (bits)
int bytesOfLong = Long.BYTES; // 8 (bytes)

6、所有的整数和浮点数的包装类型都继承自`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();