String实际应用中的小结

String类的使用

我们都知道String是不可变的，面试HR可能回问为什么，这些已经难不住我们，上源码！

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {}

可以看出来了，final修饰的类，不可变咯。那么，它线程安不安全？【都已经不可变了，肯定是线程安全的】

String的字符串比较

        String str1 = "son";
        String str2 = "son";
        String str3 = "s"+"on";
        String str4  = new String("son");
        String str5 = "s"+ new String("on");
        String str6 = str2;
        String str7 = str3;
        String str8 = str4;
        String str9 = str5;

花点时间来看看，这9个字符串之间的==比较，会得到什么：

1. str1、str2、str3、str4、str5、str6 ，他们之间的比较分别会得到什么；

        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str1 == str4);
        System.out.println(str1 == str5);
        System.out.println(str1 == str6);

		// true
		// true
		// false
		// false
		// true

1、str1与str2比较为true,
str1定义的对象，在常量池中，只创建了一个对象，str1则作为引用指向了这个常量对象。

而str2，因为常量池中有这个对象，所以str2不需要创建（0创建），直接指向这个常量对象。

str3虽然中间用了一个“+”号，相当于字符串拼接，也是相当于“son”，也不需要创建对象，作为引用指向常量“son”. 所以str1、str2、str3都是作为引用指向同一个常量对象，所以==自然就是true了

再看str4，使用了new String(),这明显就是创建对象了，由于"son"已经在常量池了，所以常量池就不需要了，只需要在堆中创建一个对象，而str4则是作为引用指向了这个堆对象，所以跟上面的str1它们不等。

str5，那就更不用说了，有new String，跟str1它们指定返回false了。
那str4、跟str5呢，有没有可能相等呢，看一下，

        System.out.println(str4 == str5);
        System.out.println(str4 == str8);
        System.out.println(str5 == str9);
       //  false
		// true
		// true

str4、str5指向堆对象的引用是不同的，换句话说，str4在堆中创建的对象，跟str5在堆中创建的对象，不是同一个，所指向的引用，就不相等咯。

后面的为什么相等，str1与str6、str4与str8、str5与str9返回的是true,那是因为，String str6 = str2；str2所引用的指向，给了str6,它们两个的引用指向相同，自然就是true了，剩下的两组解释跟这两组一样。

2. String的equals方法比较；

        System.out.println(str1.equals(str3));
        System.out.println(str1.equals(str4));
        System.out.println(str1.equals(str5));
       // true
		// true
		// true

String重写了Object的equals方法，大多数情况下都是用于字符串的内容比较，

    public boolean equals(Object obj) {
        return (this == obj);
    }

Object中的equals方法是直接判断this和obj本身的值是否相等，即用来判断调用equals的对象和形参obj所引用的对象是否是同一对象，所谓同一对象就是指内存中同一块存储单元，
如果是同一块内存，则object中的equals方法返回true,如果是不同的内存，则返回false
如果希望不同内存但相同内容的两个对象equals时返回true,则我们需要重写父类的equal方法
String类已经重写了object中的equals方法

3. 再讲一下 “== ”跟“equals”的区别
   “” 当用于基本数据类型【byte（1字节、8（比特）位）、char（2字节、16（比特）位）、short（2字节、16（比特）位）、int（4字节、32（比特）位）、float（4字节、32（比特）位）、long（8字节、64（比特）位）、double（8字节、64（比特）位）、boolean（1字节、8（比特）位）】比较的时候，比较的是大小。
   当用于Object或者其他引用数据类型的时候，比较的是引用的地址。由Object的源码可知，Object的equals方法最后还是用的方法，只不过equals方法可以由Object的派生类（子类）去重写。

equals平时用的最多的，还是字符串内容的比较，用来比较对象，也行。

4. String的常用方法
   compareTo
   上源码

    public int compareTo(String anotherString) {
        int len1 = value.length;   //比较的字符串的本身长度
        int len2 = anotherString.value.length;  //被比较的字符串长度
        int lim = Math.min(len1, len2);  //  取两个长度短的长度值
        char v1[] = value;  // 字符串本身就是一个数组
        char v2[] = anotherString.value;

        int k = 0;   // 计数
        //从value的第一个字符开始到最小长度lim处为止，如果字符不相等，返回自身（对象不相等处字符-被比较对象不相等字符）
        while (k < lim) {   
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

        String str1 = "sun";   // u对应的ASCII  117
        String str2 = "son"; // o对应的ASCII  111
        String str3 = "son";
        System.out.println("str1、str2比较之后返回什么：" + str1.compareTo(str2));
        System.out.println("str2、str3比较之后返回什么：" + str2.compareTo(str3));
       // str1、str2比较之后返回什么：6
	   // str2、str3比较之后返回什么：0

substring

    public String substring(int beginIndex, int endIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > value.length) {
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        int subLen = endIndex - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return ((beginIndex == 0) && (endIndex == value.length)) ? this
                : new String(value, beginIndex, subLen);
    }

截取字符串，substring(int beginIndex, int endIndex),开始下标，endIndex即末尾下标(开区间)，截取不到endIndex的位置，只能到endIndex的上一个，因为是开区间。

        String str = "eclipse";

        System.out.println("截取的字符串："+str.substring(3,5));
        //  截取的字符串：ip

再看下面的String常用方法

        String str1 = "eclipse";
        String str2 = "ECLIPSE";
        String str3 = " eclipse  ";
        String str4 = "ec,li,ps,e";
        String str5 = "eclipsep";

        System.out.println("截取的字符串："+str1.substring(3,5));
        System.out.println("转大写：" + str1.toUpperCase());
        System.out.println("转小写：" + str2.toLowerCase());
        System.out.println("去掉前后的空格：" + str3.trim());
        System.out.println("后面拼接字符串：" + str1.concat("123"));
        System.out.println("把l替换成p：" + str1.replace("l","p"));
        System.out.println("切割的数组：" + Arrays.toString(str4.split(",")));  // 即 Arrays.toString(str4.split(","))
        System.out.println("定位p的下标:" + str1.indexOf("p"));
        System.out.println("定位数字4的下标：：" + str1.indexOf(4)); // 找不到则为-1
        System.out.println("定位P的最后一次出现的下标：" + str5.lastIndexOf("p"));
        System.out.println("定位4最后一次出现的下标：" + str1.lastIndexOf(4));
        System.out.println("判断是否为空串：" + str1.isEmpty());
        System.out.println("字符串的长度：" + str1.length());

		//        截取的字符串：ip
		//        转大写：ECLIPSE
		//        转小写：eclipse
		//        去掉前后的空格：eclipse
		//        后面拼接字符串：eclipse123
		//        把l替换成p：ecpipse
		//        切割的数组：[ec, li, ps, e]
		//        定位p的下标:4
		//        定位数字4的下标：：-1
		//        定位P的最后一个下标：7
		//        定位下标值对应的字符：-1
		//        判断是否为空串：false
		//        字符串的长度：7

String 、StringBuffer、StringBulider日常比较

区别	String	StringBuffer	StringBuilder
是否可变	不可变，final修饰，字符串常量	可变，字符串变量	可变，字符串变量
是否线程安全	多线程，线程安全	多线程，线程安全	单线程，线程不安全
执行效率	慢	中	快

当时面试，有个HR问为什么StringBuffer线程安全，StringBuilder不安全，我不晓得，赶紧去查了一下，
发现StringBuffer的写操作，基本上全是synchronized修饰，我们知道synchronized是同步锁，加了锁以后，安全也就不言而喻了。不过这种问题一般问不到，了解一下即可。

插入链接与图片

链接: https://blog.csdn.net/weixin_42684369?spm=1010.2135.3001.5343.

图片: