java中的String类

1、String类的重要性

在C语言中已经涉及到字符串了，但是在C语言中要表示字符串只能使用字符数组或者字符指针，可以使用标准库提供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字符串应用又非常广泛，因此Java语言专门提供了String类。

2、常用方法

2.1字符串的构造

String类的构造方式非常多，常用的有以下三种：

 String str = "fighing";
     String str1 = new String("fighing");
        System.out.println(str);
        System.out.println(str1);

        char[] array = {'a','b','c'};
        String str2 = new String(array);
        System.out.println(str2);

分别是直接赋值，newString对象以及用字符数组进行构造。
注意：String是引用类型，内部并不存储字符串本身。

 String str3 = "";
        System.out.println(str3);
        System.out.println(str3.length());
        System.out.println(str3.isEmpty());

        String str4 = null;
        System.out.println(str4);
        System.out.println(str4.isEmpty());

这里注意isEmpty是指值为空，此时如果将String赋为null，表示这个引用不指向任何对象，所以此时会报空指针异常的错误。

2.2String类型的比较

 public static void main4(String[] args) {
        String s = new String("hello");
        String s1 = new String("Hello");
        System.out.println(s.compareToIgnoreCase(s1));


    }
    public static void main3(String[] args) {
        String s = new String("hello");
        String s1 = new String("bello");
        System.out.println(s.compareTo(s1));
    }
    public static void main2(String[] args) {
        String str = new String("hello");
        String str1 = new String("hello");
        System.out.println(str.equals(str1));

        String s = "hello";
        String s1 = "hello";
        System.out.println(s==s1);//hello被放入了常量池
        System.out.println(s.equals(s1));


    }

第一种==是直接比较两者的地址，因为Sring引用会产生新的对象，所以结果一定为false。
第二种equals比较时，首先对应字符不一样，就看对应的ASCII码值。然后看对应的字符长度。
第三种与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：

1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值
   第四种是忽略大小写进行比较。
   注意：

 String s = "hello";
        String s1 = "hello";
        System.out.println(s==s1);//hello被放入了常量池
        System.out.println(s.equals(s1));

从代码中我们认为结果false和true，但是实际结果都为true，这是因为hello被放入了常量池（后续会进行详细讲解，现在只需要记住这个结论就行），因此当在此将引用赋值为hello时，会去常量池中找，因此结果为true

2.3字符串的查找

public static void main5(String[] args) {
        String s = new String("hello");
        char ch = s.charAt(0);//注意不能越界
        System.out.println(ch);

        int index =s.indexOf("l",3);
        System.out.println(index);

        int index1 =s.indexOf("ll",2);
        System.out.println(index1);
        System.out.println("==========");
        String s1 = new String("hello");
        int index2 = s1.lastIndexOf("l");
        System.out.println(index2);
    }

charAt()返回index位置上的字符，如果index为负数或者越界，抛出indexOutBoundsException异常。
indexOf（）返回字符第一次出现的位置，没有返回-1。同时indexOf中还可以给字符串，以及可以从fromindex位置找。
lastIndexOf是从后往前找，使用方法与indexOf（）相同

2.4转化

public static void main6(String[] args) {
//1.数值和字符串的转化
      String s = String.valueOf(123);
        System.out.println(s);
//2.字符串转数字
//Integer为int的包装类型，在之前我们提过，后续会进行详细讲解
        int a = Integer.parseInt("123");
        System.out.println(a);


        String s1 = "hello";
        String ret = s1.toUpperCase();//小写转大写
        System.out.println(ret);
        String s2 = "HELLO";
        String ret1 = s2.toLowerCase();//大写转小写
        System.out.println(ret1);

//字符串转数组
        String s3 = "hello";
        char[] ch = s3.toCharArray();
        for (char c:ch) {
            System.out.println(c);
        }
        //格式化
        String s4 = String.format("%d-%d-%d",2011,6,9);
        System.out.println(s4);
    }

2.5字符串替换

 public static void main7(String[] args) {
         String s = "ababdhvhab";
       String ret = s.replace('a','g');
        System.out.println(ret);

        String ret1 = s.replace("ab","gggg");
        System.out.println(ret1);
        String ret2 = s.replaceFirst("ab","gggg");
        System.out.println(ret2);
    }

replace是指定一个新的字符串替换掉已有的字符串数据。
replaceFirst是替换首个字符串。

2.6字符串的拆分

//多次拆分
public static void main9(String[] args) {
        String str = "name=zhangsan&age=18" ;
        String[] s = str.split("&");
        for (String x:s) {
           // System.out.println(x);
            String[] ss =x.split("=");
            for (String st:ss ) {
                System.out.println(st);
            }
        }

    }
    public static void main8(String[] args) {
        String s ="hello world hello xx";
        String[] ret = s.split(" ",2);
        for (int i = 0;i < ret.length;i++)
        System.out.println(ret[i]);

        String s1 = "190.153.2.2";
        String[] ret1 = s1.split("\\.");
        for (int i = 0;i < ret1.length;i++)

        System.out.println(ret1);
    }

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。
注意事项：

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

2.7字符串的截取

String str = "helloworld" ;
System.out.println(str.substring(5));
System.out.println(str.substring(0, 5));

注意事项:

1. 索引从0开始
2. 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标

2.8其他操作方法

String s1 = "    agg  dg  gga gg    ";
        String ret2 = s1.trim();
        System.out.println(ret2);

trim方法是去掉字符串的左右空格，保留中间空格。

2.9字符的不可变性

String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：

1. String类在设计时就是不可改变的，String类实现描述中已经说明了
2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象

2.10字符串的修改

注意：尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下。

public static void main(String[] args) {
  String s = "hello";
  s += " world";
  System.out.println(s);  // 输出：hello world
}

但是这种方式不推荐使用，因为其效率非常低，中间创建了好多临时对象

public static void main(String[] args) {
  long start = System.currentTimeMillis();
  String s = "";
  for(int i = 0; i < 10000; ++i){
    s += i;
 }
  long end = System.currentTimeMillis();
  System.out.println(end - start);
 
  start = System.currentTimeMillis();
  StringBuffer sbf = new StringBuffer("");
  for(int i = 0; i < 10000; ++i){
    sbf.append(i);
 }
  end = System.currentTimeMillis();
  System.out.println(end - start);
 
  start = System.currentTimeMillis();
  StringBuilder sbd = new StringBuilder();
  for(int i = 0; i < 10000; ++i){
    sbd.append(i);
 }
  end = System.currentTimeMillis();
  System.out.println(end - start);
}

可以看出在对String类进行修改时，效率是非常慢的，因此：尽量避免对String的直接需要，如果要修改建议尽量使用StringBuffer或者StringBuilder。