Java - 工具类4（String常用方法一） July 12，2019

String类

java.lang.Object

　　java.lang.String

 1.String类实现三个接口Serializable, CharSequence, Comparable<String>；
 2.所属的包是java.lang包  不用导入；

 3.如何构建方法
 

public class TestString {
    public static void main(String [] args){
        char [] value3 = new char[]{'a','b','c'};
        byte [] value4 = new byte[]{97,98,99};
        String str0 = "abc";
        String str1 = new String();   //相当于创建了空的对象 ""
        String str2 = new String("abc");
        String str3 = new String(value3);//将数组中的每一个char元素拼接成String
        System.out.println(str3);
        String str4 = new String(value4);//将数组中的每一个元素转化成对应的char，然后组合成String
        System.out.println(str4);
    }
}
输出结果：
abc
abc

 

4.常见的String笔试题

　　（1）==  与 equals 的区别:

 

public class TestString {
    public static void main(String [] args){
        String s1 = "abc";
        String s2 = "abc";
        String s3 = new String("abc");
        String s4 = new String("abc");
        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//false
        System.out.println(s3==s4);//false
        System.out.println(s1.equals(s2));//true   String类将继承自Object中的equals方法重写啦
        System.out.println(s1.equals(s3));//true   将原有比较==的方式改为比较字符值
        System.out.println(s3.equals(s4));//true
    }
}
输出结果：
true
false
false
true
true
true

　　(2)String的不可变特性(长度与内容)

　　(3)String与StringBuffer区别

　　(4)StringBuffer与StringBuilder区别

　　(5)String对象的存储

　　　　"abc"---->存储在字符串常量池
   　　 　new String("abc")--->存储在堆内存
    　　   "a"+"b"+"c"+"d"  产生几个对象

　　(6)String中常用的方法

 

 5.String类的不可变性（长度和内容）

　　　String类中包含一个   private final char value[];

 　　　长度　　final修饰的数组，因为数组本身的长度是不可改变的，同时final修饰后 数组的地址也不可改变。

　　　 内容　　private修饰的属性，不能在类的外部访问，所以内容不可改变。

 

6.常用方法：

　　总括　　

　　　　　　  第一梯队(重写)
   　　　　　　　　　　equals  hashCode  compareTo  toString
　　　　　     第二梯队(常用)
   　　　　　　　　　　charAt()  codePointAt()
   　　　　　　　　　　indexOf()  lastIndexOf()
　　　　　　　　　　   substring()  split()  replace()
 　　　　　　　　　　  length()  concat()  contains();  trim();
　　　　　　　　　　   getBytes()   toCharArray()  matches()
　　　　　   第三梯队(一般)　
　　　　　　　　　　   toUpperCase()  toLowerCase()
   　　　　　　　　　　startsWith()  endsWith();
　　　　　　　　　　   isEmpty();

 

　　　(1)boolean a = equals(Object obj);　　//继承自Object，在String类中重写啦，用来比较两个字串中的字面值是否相等

　　　　　　　　如果想修改其比较规则，可以重写equals()方法，通常重写equals()时会伴随重写hashCode()方法

public class TestString {
    public static void main(String [] args){
         String a = "abc";
         String b = "abc";
         String c = "A";
         String d = new String("abc");
         boolean value1 = a.equals(b);
         boolean value2 = a.equals(c);
         boolean value3 = a.equals(d);
         boolean value4 = b.equals(d);
        System.out.println(value1+"--"+value2+"--"+value3+"--"+value4);
    }
}
输出结果：
true--false--true--true

 

　　　(2)　int a  = compareTo(String str);　　 //实现自Comparable接口，按照字典(Unicode编码)索引的顺序比较

 

public class TestString {
    public static void main(String [] args){
        //按照两个字符串长度较短的那个作为比较循环的次数
        //挨个比较元素   str1[i]-str2[i]    循环内如果有结果
        //如果循环过后发现所有的字符都一样 咋比较长度len1-len2
        //返回0表示两个字符相等
            String str1 = "abc";
            String str2 = "abc";
            String str3 = "abb";
            String str4 = "abd";
            String str5 = "ab";
        System.out.println(str1.compareTo(str2));
        System.out.println(str1.compareTo(str3));
        System.out.println(str1.compareTo(str4));
        System.out.println(str1.compareTo(str5));

    }
}
输出结果：
0
1
-1
1

 

　　　(3)  char = charAt(int index);       //"abc"   0-->a　　　　回给定index对应位置的那个char值

 　　　     int = codePointAt(int index);    //"abc"   0-->97　  返回给定index对应位置的那个char所对应的code码

　　　　 length()            // 获取String的长度

public class TestString {
    public static void main(String [] args){
        String str = "abc";
        //注意String中 length是个方法 ， 而在数组中length是个属性
        for(int i=0;i<str.length();i++){
            char a = str.charAt(i);
            int b =  str.codePointAt(i);
            System.out.println(a + "--" + b);
        }
    }
}
输出结果：
a--97
b--98
c--99

 

　　　(4)String a = concat（）//将给定的字符串拼接在当前字符串之后

　　　　

public class TestString {
    public static void main(String [] args){
        /*
        String str = "abcdef";
        //String对象 (字符串常量池) value属性char[]
        //长度不能改变 数组地址不让改变 数组属性私有的我们操作不了
        str.concat("g");
        //创建一个新的String对象  (字符串常量池)  里面有value属性  7个
        //刚才那个String对象中的value值依次取出来  存入新对象的value属性 g放在后面
        System.out.println(str);//输出的是abcdef
        //这体现了String的不可变特性
        */
        
        //正确的操作：
        String str = "abcdef";
        str = str.concat("g");
        System.out.println(str);
输出结果：
abcdefg

public class TestString {
    public static void main(String [] args){
        //也可以通过使用+号来进行拼接
        String str = "a"+"b"+"c"+"d";//数学计算  拼接符号
        System.out.println(str);//过程中产生了7个String对象,字符串常量池7个


        //concat的拼接效率  >>   +
        //+
        String string1 = "a";
        long time1 = System.currentTimeMillis();
        for(int i=0;i<90000;i++){
            string1 = string1 + "a";
        }
        long time2 = System.currentTimeMillis();
        System.out.println(time2 - time1);
        
        //concat
        String string2 = "b";
        long time3 = System.currentTimeMillis();
        for(int i=0;i<90000;i++){
            string2 = string2.concat("b");
        }
        long time4 = System.currentTimeMillis();
        System.out.println(time4 - time3);
    }
}
输出结果：
abcd
5282
1320