String（重要）

String

创建字符串

常见的构造String的方式

public class TestDemo {
    public static void main(String[] args) {//常见的String的构造方式有以下三种，在这三种里面最常见的是第一种
        //方式一：
        String str = "abcdef";
        System.out.println(str);
        //方式二：
        String str2 = new String("abcdef");
        System.out.println(str2);
        //方式三：
        char[] val = {'a','b','c','d','e','f'};
        String str3 = new String(val);
        System.out.println(str3);
    }
}

输出为：

在官方文档上，我们可以看到String还支持很多其他的构造方式，但是常用的构造方式是以上这三种，在以上这三种里最常用的是方式一，String 是引用类型。

字符串常量池特性：

1. 从JDK1.7开始，字符串常量池被挪到堆里面了
2. 字符串常量池里的数据是不重复的
   代码示例1:

public class TestDemo {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = new String("hello");
        System.out.println(str1 == str2);//输出为false
        String str3 = "hello";
        System.out.println(str1 == str3);//输出为true
    }
}

以下图示可解释上述代码的输出结果：

代码示例2：

public class TestDemo {
    public static void main(String[] args) {//只要是双引号引起来的肯定在常量池当中
        String str1 = "hello";
        String str2 = "hel"+"lo";//编译时期已经被处理为hello了，常量在编译的时候就已经确定了。
        System.out.println(str1 == str2);//true
        String str3 = new String("hel") + "lo";
        System.out.println(str3 == str1);//false
    }
}

以下图示可解释上述代码的输出结果：

代码示例3：

public class TestDemo {
    public static void main(String[] args) {//只要是双引号引起来的肯定在常量池当中
      String str1 = "hello";
      String str2 = str1;
      System.out.println(str1);//输出为"hello"
        System.out.println(str2);//输出为"hello"
        str1 = "abc";
        System.out.println(str1);//输出为"abc"
        System.out.println(str2);//输出为"hello",不要以为传引用就会修改值的内容。
    }
}

代码示例4：

import java.util.Arrays;
public class TestDemo {
    public static void func(String str,char[] array){
        str = "abcdef";
        array[0] = 'g';
    }
    public static void main(String[] args) {//只要是双引号引起来的肯定在常量池当中
     String str1 = "hello";
     char[] val = {'a'};
        System.out.println(str1);
        System.out.println(Arrays.toString(val));
        func(str1,val);
        System.out.println(str1);
        System.out.println(Arrays.toString(val));
    }
}

输出为：

以下图示可解释上述代码的输出结果：

提醒：在真正的笔试面试过程当中，字符串和数组和单链表的题型是非常多的，应该多去练习这些题型的代码题。

public class TestDemo {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = new String("hello");
        System.out.println(str1 == str2);//比较的是字符串的引用
        System.out.println(str1.equals(str2));//比较的是字符串的内容
        String str3 = "hello";
        System.out.println(str1 == str3);//比较的是字符串的引用
        System.out.println(str1.equals(str3));//比较的是字符串的内容
    }
}

输出为：

equals使用注意事项：

public class TestDemo {
    public static void main(String[] args) {
        String str1 = new String("hello");
        System.out.println("hello".equals(str1));//推荐这一种写法
        System.out.println(str1.equals("hello"));//这一种写法不推荐，因为一旦str1为null的话会发生空指针异常
    }
}

这两种写法更推荐上面的那一种写法，因为下面方式的写法一旦str1为null,会发生空指针异常

public class TestDemo {
    public static void main(String[] args) {
        String str2 = new String("hello").intern();
        String str1 = "hello";
        System.out.println(str1 == str2);
    }
}

输出为：true

public class TestDemo {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = new String("hello").intern();
        System.out.println(str1 == str2);
    }
}

输出为：true
intern()手动入池，从现象上来看，当前的这个字符串在常量池当中是否存在？如果存在，把常量池当中的引用赋值给当前的引用类型变量。
字符串通过反射修改私有的东西：

public class TestDemo {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        String str = "Hello";
       //利用反射=》自省的过程
        Class cl = String.class;
        Field field = cl.getDeclaredField("value");
        field.setAccessible(true);
        char[] val = (char[])field.get(str);
        val[0] = 'g';
        System.out.println(str);
    }
}

输出为：

字符串的使用

字符与字符串的转化：

public class TestDemo {
    public static void main(String[] args) {
        char[] val = {'a','b','c','d','e'};
        String str = new String(val,1,3);//将字符数组转化为字符串
        System.out.println(str);
        String str2 = "hello";
        char ch = str2.charAt(4);//将字符串转化为指定位置字符
        System.out.println(ch);
        char[] val2 = str2.toCharArray();
        System.out.println(Arrays.toString(val2));//将字符串转化为字符数组
    }
}

输出为：

判断字符串中是否全为0~9的字符：

public class TestDemo {
    public static boolean func(String str){
        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);//将字符串转化为对应的字符
            if (ch < '0'|| ch > '9'){
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) {
        String str = "123456";
        boolean flag = func(str);
        System.out.println(flag);
    }
}

将字节数组转化为字符串：

public class TestDemo {
    public static void main(String[] args) {
        byte[] bytes = {97,98,99,100};
        String str = new String(bytes);//将字节数组转化为字符串
        System.out.println(str);
        String str2 = "abcdef";
        byte[] bytes1 = str2.getBytes();//将字符串转化为对应的字符数组
        System.out.println(Arrays.toString(bytes1));
    }
}

输出为：

字符串忽略到大小写：

public class TestDemo {
    public static void main(String[] args) {
        String str1 = "ABCDef";
        String str2 = "abcdef";
        System.out.println(str1.equals(str2));
        System.out.println(str1.equalsIgnoreCase(str2));//忽略到大小写进行比较
    }
}

输出为：

字符串比较大小：

public class TestDemo {
    public static void main(String[] args) {
        String str1 = "Abe";
        String str2 = "abe";
        System.out.println(str1.compareTo(str2));//字符串比较大小写，考虑大小写
        System.out.println(str1.compareToIgnoreCase(str2));//字符串比较大小，不考虑大小写
    }
}

输出为：

String中的replace方法：

示例1：

public class TestDemo {
    public static void main(String[] args) {
       String str1 = "ababcabcd";
        String str2 = str1.replace('a', 'g');
        System.out.println(str2);
    }
}

输出为：
示例2：

public class TestDemo {
    public static void main(String[] args) {
       String str1 = "ababcabcd";
        String str2 = str1.replace("ab", "pp");
        System.out.println(str2);
    }
}

输出为：
示例3：

public class TestDemo {
    public static void main(String[] args) {
       String str1 = "ababcabcd";
        String str2 = str1.replaceFirst("ab", "pp");
        System.out.println(str2);
    }
}

输出为：

String中的substring方法：

代码示例1：

public class TestDemo {
    public static void main(String[] args) {
       String str1 = "ababcabcd";
        String str2 = str1.substring(2);//下标从2号位置开始截取，包含2（这里截取的话，头号下标从0开始而不是从1开始）
        System.out.println(str2);
       String ret = str1.substring(1,4);//这个地方是左闭右开[1,4)
        System.out.println(ret);
    }
}

输出为：
代码示例2：

public class TestDemo {
    public static void main(String[] args) {
       String str1 = "  abab  cabcd   ";
      String ret =  str1.trim();//去掉字符串左右两边的空格
        System.out.println(ret);
    }
}

输出为：

字符串查找

代码示例1：contains

public class TestDemo {
    public static void main(String[] args) {
    String str = "ababcabcdabcde";
   Boolean flag = str.contains("abc");
        System.out.println(flag);//输出为true,查找字符串中是否含有要找的子串
    }
}

代码示例2：

public class TestDemo {
    public static void main(String[] args) {
    String str = "ababcabcdabcde";
        int index1 = str.indexOf("abc1");//从头开始查找指定字符串的位置，查到了返回位置的开始索引，如果查不到返回-1
        System.out.println(index1);
        int index2 = str.indexOf("abc");
        System.out.println(index2);
        int index3 = str.indexOf("abc",3);//从指定位置开始查找子字符串的位置
        System.out.println(index3);
    }
}

输出为：
代码示例3：

public class TestDemo {
    public static void main(String[] args) {
    String str = "ababcabcdabcde";
        int index1= str.lastIndexOf("abc");
        System.out.println(index1);//由后向前查找子字符串的位置，输出为9
        int index2 = str.lastIndexOf("abc", 3);
        System.out.println(index2);//从指定位置由后向前查找，输出为2
        boolean flag = str.startsWith("ab");//判断是否以指定字符串开头
        System.out.println(flag);
        boolean flag1 = str.startsWith("ab",2);//从指定位置开始判断是否以指定字符串开头
        System.out.println(flag1);
        boolean flag2 = str.endsWith("cde");
        System.out.println(flag2);//判断是否是以指定字符串结尾
    }
}

输出为：

字符串拆分

代码示例1：

public class TestDemo {
    public static void main(String[] args) {
        String str = "abc de f";
        String[] strings = str.split(" ");//将字符串按照regex里的东西全部拆分
        for (String str1:strings) {
            System.out.println(str1);
        }
    }
}

输出为：
代码示例2：

public class TestDemo {
    public static void main(String[] args) {
        String str = "abc de f";
        String[] strings = str.split(" ",2);//将字符串按照regex里的东西部分拆分，数组长度即使limit的值
        for (String str1:strings) {
            System.out.println(str1);
        }
    }
}

输出为：
拆分是特别常用的操作，一定要重点掌握，另外有些特殊字符作为分隔符可能无法正确拆分，需要加上转义。
代码示例：拆分ip地址：

public class TestDemo {
    public static void main(String[] args) {
      String str = "192.168.1.1";
      String[] strings = str.split("\\.");
        for (String str1:strings) {
            System.out.println(str1);
        }
    }
}

输出为：

如果一个字符串中有多个分隔符，可以用“|”作为连字符：
代码示例：

public class TestDemo {
    public static void main(String[] args) {
      String str = "Java-split#bit";
      String[] strings = str.split(" |-|#");
        for (String str1:strings) {
            System.out.println(str1);
        }
    }
}

输出为：
多次分割：

public class TestDemo {
    public static void main(String[] args) {
        //分割多次
        String str = "name=zhangsan&age=18";
       /* String[] strings = str.split(" |=|&|=");//可以这样分割
        for (String str1:strings) {
            System.out.println(str1);
        }*/
       String[] strings1 = str.split("&");
       //[name=zhangsan] [age=18]
        //0                1
        for (String s1:strings1) {
            String[] strings2 = s1.split("=");
            for (String s2:strings2) {
                System.out.println(s2);
            }
        }
    }
}

输出为：

其他操作方法

toUpperCase

代码示例：

public class TestDemo {
    public static void main(String[] args) {
    String str = "abcdefABF高";
    String ret = str.toUpperCase();//将字符串中的字母全变为大写，但对汉字无效,只对字母有效
        System.out.println(ret);
    }
}

输出为：

toLowerCase

代码示例：

public class TestDemo {
    public static void main(String[] args) {
    String str = "abcdefABF高";
    String ret = str.toLowerCase();//将字符串中的字母全变为小写，但对汉字无效,只对字母有效
        System.out.println(ret);
    }
}

输出为：

数组的长度以及字符串的长度的区别和空串与空对象的区别

代码示例：

public class TestDemo {
    public static void main(String[] args) {
    String str = "abcdefABF高";
    String ret = str.toLowerCase();//将字符串中的字母全变为小写，但对汉字无效,只对字母有效
        System.out.println(ret.length());
        int[] array = {1,2,3,4,5};
        System.out.println(array.length);
        String string = "";//空串，empty测试的是它
        String string2 = null;//空对象
    }
}

输出为：

StringBuffer和StringBuilder

以下拼接方式会产生大量的临时变量：

public class TestDemo {
    public static void main(String[] args) {//这种拼接方式会产生大量的临时变量
        String str = "";
        for (int i = 0; i < 10; i++) {
            str += 'a';
        }
        System.out.println(str);
    }
}

但是StringBuffer和StringBuilder并不会

public class TestDemo {
    public static void main(String[] args) {//这种拼接方式会产生大量的临时变量
        StringBuffer stringBuffer = new StringBuffer();
        StringBuilder stringBuilder = new StringBuilder();
        stringBuffer.append("fygdy");//字符串拼接
        stringBuffer.append("efg").append("ghdfg").append("fghi");
        System.out.println(stringBuffer);
    }
}

输出为：

String和StringBuilder以及StringBuffer的区别：

1. String的拼接会产生大量的临时变量，StringBuilder以及StringBuffer不会
2. String拼接会被优化为StringBuilder的append();
3. 后两者当中有一些方法是String不具备的，比如逆置方法
   

StringBuilder 和StringBuffer的区别

StringBuilder 和String一般用于单线程情况下，StringBuffer一般用于多线程情况下。

面试的时候要注意以下区别

1. this 和super
2. 抽象类和接口的区别
3. 重写和重载区别
4. String ,StringBuffer,StringBuilder的区别
5. 数组和链表的区别