认识String类

1.字符串构造 

public static void main(String[] args) {
String s1 = "hello bit";        // 使用常量串构造
System.out.println(s1);
String s2 = new String("hello bit");   // 直接newString对象
System.out.println(s1);
char[] array = {'h','e','l','l','o','b','i','t'};  // 使用字符数组进行构造
String s3 = new String(array);
System.out.println(s1);
}

2.在Java中“”引起来的也是String类型对象

String str4 = ""

System.out.println("输出："+str4);  //输出“输出：”
System.out.println(str4.length()); //输出0
System.out.println(str4.isEmpty()); //输出true
System.out.println("hello".length()); // 打印"hello"字符串(String对象)长度，5

String str5 = null; //不指向任何对象
System.out.println(str5.isEmpty()); //空指针异常

3.String的比较

1）==比较是否引用同一个对象
   对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。

int a = 10;
int b = 20;
int c = 10;
// 对于基本类型变量，==比较两个变量中存储的值是否相同
System.out.println(a == b); // false
System.out.println(a == c); // true
// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
String s4 = s1;
System.out.println(s1 == s2); // false，地址不同
System.out.println(s2 == s3); // false
System.out.println(s1 == s4); // true 
}

2）String类重写了父类Object中equals方法，返回Boolean类型

Object中equals默认按照==比较，比如s1.equals(s2)

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);   // false，地址不同
System.out.println(s1.equals(s2)); //被String重写了，比较的是字符串是否相同
                                   //输出true

ps:若是直接赋值，那么它直接被放入字符串常量池

String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2);     // true
System.out.println(s1.equals(s2));  //true

3)判断字符串的大小：compareTo方法，对应字符进行比较，返回int类型

  对应字符不一样，比较对应字符ASCII值，

  对应字符长度不一样，长的大

  若s1>s2，返回大于0的数字；si1<s2返回小于0的数字，返回值即为ASCII的差值

String s1 = new String("hello");
String s2 = new String("aello");
System.out.println(s1.compareTo(s2)); //输出7
                                      //h的ASCII大于a，返回大于0的数

4）忽略大小写进行比较：IgnoreCase

String s1 = new String("hello");
String s2 = new String("Hello");
System.out.println(s1.equals(s2));   //false
System.out.println(s1.equalsIgnoreCase(s2));  //true


String s1 = new String("hello");
String s2 = new String("aello");
System.out.println(s1.compareTo(s2)); //输出32
System.out.println(s1.compareToIgnoreCase(s2)); //输出0

4.字符串查找

char charAt(int index) //返回字符串对应下标的字符，index为负数或者越界，报错

int indexOf(int ch) //返回ch第一次出现的位置，没有返回-1

int indexOf(int ch, intfromIndex) //从fromIndex位置开始找ch第一次出现的位置，没有返回-1

int indexOf(String str) 返回str第一次出现的位置，没有返回-1

int indexOf(String str, intfromIndex) //从fromIndex位置开始找str第一次出现的位置，没有返回-1

int lastIndexOf(int ch) 从后往前找，返回ch第一次出现的位置，没有返回-1

int lastIndexOf(int ch, intfromIndex)从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1

int lastIndexOf(String str) 从后往前找，返回str第一次出现的位置，没有返回-1

int lastIndexOf(String str, intfromIndex)从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1

5.转化，字符串的转化都产生了新的对象

1）序列化：对象->字符串，反序列化：字符串->对象

String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
String s3 = String.valueOf(true);
String s4 = String.valueOf(new Student("Hanmeimei", 18));

2）

// 字符串转数字
// Integer、Double等是Java中的包装类型
int data1 = Integer.parseInt("1234");
double data2 = Double.parseDouble("12.34");
System.out.println(data1);
System.out.println(data2);

3）大小写转化

public static void main(String[] args) {
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.toUpperCase());  // 小写转大写，产生了新的对象
System.out.println(s2.toLowerCase());  // 大写转小写
}

4）字符串转数组

public static void main(String[] args) {
String s = "hello";
char[] ch = s.toCharArray();  // 字符串转数组
for (int i = 0; i < ch.length; i++) {
System.out.print(ch[i]);
} 
System.out.println();
String s2 = new String(ch);  // 数组转字符串
System.out.println(s2);
}

5）格式化

public static void main(String[] args) {
String s = String.format("%d-%d-%d", 2019, 9,14);
System.out.println(s);
}
  //输出2019-9-14

6.字符串替换

String replaceAll(String regex, String replacement) //替换所有的指定内容
String replaceFirst(String regex, String replacement) //替换收个内容

7.字符串拆分

String[] split(String regex) //将字符串全部拆分
String[] split(String regex, int limit) //将字符串以指定的格式，拆分为limit组

1）部分拆分

String str = "zhangsan&name" ;
String[] result = str.split("&") ; // 按照&拆分
for(String s: result) {
System.out.println(s);
}    //输出张三 name

2）全部拆分

S
tring str = "hello world yep " ;
String[] result = str.split(" ",2) ; 
 //如果分割次数太多，不能分割那么多次，只能保证够分割的
String[] result = str.split(" ",42) ;  

for(String s: result) {
System.out.println(s);
}  //输出hello                   //输出为hello
         world yep                      world
                                        yep

3）拆分IP地址

String str = "192.168.1.1" ;
String[] result = str.split("\\.") ; //根据点号分割
for(String s: result) {
System.out.println(s);
}

ps：a.字符"|","*","+"都得加上转义字符，前面加上 "\\" .
       b. 而如果是 "\" ，那么就得写成 "\\\\" .
       c. 如果一个字符串中有多个分隔符，可以用"|"作为连字符

4）多次分割

String str = "name=zhangsan&age=18" ;
String[] result = str.split("&") ; //[o]=name=zhangsan,[1]=age=18
for (int i = 0; i < result.length; i++) {
String[] temp = result[i].split("=") ;   //再以=分割
System.out.println(temp[0]+" = "+temp[1]);
}                
//输出：name
       zhangsan
        age
        18

8.字符串截取

String substring(int beginIndex) 从指定索引截取到结尾
String substring(int beginIndex, int endIndex) 截取部分内容，一般为【）

9.

String trim() //去掉字符串中的左右空格,保留中间空格


String str = " hello world " ;
System.out.println("["+str+"]");
System.out.println("["+str.trim()+"]");

10.String不可变性

1）String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改

2）String类中的字符实际保存在内部维护的value字符数组中

    a. String类被final修饰，表明该类不能被继承
    b. value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。

3）所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象

9. StringBuilder和StringBuffer

String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可
以修改。频繁修改字符串的情况考虑使用StringBuilder
 

1.append拼接

StringBuff append(String str） //在尾部追加，相当于String的+=

public static void main(String[] args) {
 StringBuilder sb1 = new StringBuilder("hello");
 StringBuilder sb2 = sb1;
 sb1.append(' '); // hello
 sb1.append("world"); // hello world
 sb1.append(123); // hello world123
 System.out.println(sb1); // hello world123
}

2.String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:
           1）String变为StringBuilder: 利用StringBuilder的构造方法或append()方法

           2）StringBuilder变为String: 调用toString()方法

3.String、StringBuffer、StringBuilder的区别
  1）String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
  2）StringBuffer与StringBuilder大部分功能是相似的
  3）StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作