[java] 字符串底层剖析与常见面试题

 5.new String的讨论

[讨论一]

 String s = new String("ab");

new String("ab")为什么会创建两个对象?

1. 堆上创建了一个.
2.  字符串常量池中创建了一个,如果之前没有的话.

 public static void test4(){
        String s = new String("a")+new String("b");//创建了几个对象?
        System.out.println(s);
    }

• 对象一:new StringBuilder().
• 对象二:new String("a").
• 对象三:字符串常量池中的"a".
• 对象四:new String("b").
• 对象五:字符串常量池中的"b".
• 对象六:StringBuilder.toString().

StringBuilder.toString().剖析:

该操作相当于把字符串缓冲区中的字符串对象返回,但不会返回到字符串常量池,只会在堆上创建一个对象 new String("ab").

 我们发现没有idc指令,其实就是拼接完没有往常量池中放一份.

[讨论二]

public static void test5(){
        String str1 = new String("1");
        str1.intern();//字符串常量池中已有"1"
        String str2 = "1";
        System.out.println(str1==str2);//false
        
        String str3 = new String("1")+new String("1");
        str3.intern();//字符串常量池中没有"11"
        String str4 = "11";
        System.out.println(str3==str4);//true
    }

        str1在先在堆上创建一个对象,再到字符串常量池中创建一个对象,str1指向的是堆上的对象.因为常量池中已有"1",所以str1.intern();没有任何效果.st1与str2地址不一致.

        str3拼接的对象创建在堆上,且不会在字符串常量池中创建(原理上文已阐述),因此 str3.intern();这项操作会把str3所指对象置于常量池中.str3与str4地址一致.

三.字符串常见操作

1.字符串比较

        字符串比较是比较常见的操作之一,java提供了四种比较方式.

        1)==比较是否引用同一个对象

注意:对于内置类型==比较的是变量中的值,对于引用类型则比较的是地址.

 public static void test7(){
        int a = 10;
        int b = 3;
        int c = 10;
        System.out.println(a==b);//false
        System.out.println(a==c);//true
 
        String s1 = "hello";
        String s2 = new String("hello");
        String s3 = "hello";
        System.out.println(s1==s2);//false
        System.out.println(s2==s3);//true
    }

        2)boolean equals(Object anObject)方法:按字符大小顺序比较.

父类中的equals()方法同样是比较地址,只不过String重写了该方法.

        3)int compareTo(String s)方法:按字典序比较

与equals()不同的是equals返回的是boolean类型的值,compareTo返回的是int类型的值.

• 先按照字典次序比较,如果出现不相等的字符,直接返回两字符大小的差值.
• 如果前k个字符相等(k为最小字符串的长度),返回两字符串长度的差值.

 public static void test8(){
        String s1 = "abc";
        String s2 = "ac";
        String s3 = "abc";
        String s4 = "abcdef";
        System.out.println(s1.compareTo(s2));//字符差值为1
        s1.compareTo(s3);//相同0
        s1.compareTo(s4);//长度差值-3
    }

         4)int compareToIgnoreCase(String s)方法:与compareTo方法相同只是忽略大小写.

public static void test8(){
        String s1 = "abc";
        String s2 = "ac";
        String s3 = "Abc";
        String s4 = "abcdef";
        System.out.println(s1.compareTo(s2));//字符差值为1
        s1.compareTo(s3);//相同0
        s1.compareTo(s4);//长度差值-3
    }

2.字符串查找

public static void test9(){
        String str = "aaabbbcccaabbccdd";
        System.out.println(str.charAt(3));//b
        System.out.println(str.indexOf('b'));//3
        System.out.println(str.indexOf('b',6));//11
        System.out.println(str.indexOf("bbb"));//3
        System.out.println(str.lastIndexOf('c'));//14
        System.out.println(str.lastIndexOf('b',6));//5
    }

注意:上述方法都是实例方法. 

3.转换

        1)数组与字符串转换

public static void test10(){
        String s1 = String.valueOf(123);//整形转字符串
        String s2 = String.valueOf(12.3);//浮点型转字符串
        String s3 = String.valueOf(true);//布尔型转字符串
        String s4 = String.valueOf(new Student("zhangsan",18));
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        System.out.println("============================================");
        //字符串转数组
        int x = Integer.parseInt(s1);
        double y = Double.parseDouble(s2);
        System.out.println(x);
        System.out.println(y);
    }

 注意:以上为静态方法.

        2)大小写转换

public static void test10(){
        String str1 = "abcdef";
        String str2 = "ABCDEF";
        System.out.println(str1.toUpperCase().equals(str2));//true
        System.out.println(str2.toLowerCase().equals(str1));//true
}

        3)字符串转数组

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

        4)格式化

public static void test10(){
        String s = String.format("%d-%d-%d",2019,8,19);
        System.out.println(s);//2019-8-19
}

4.字符串替换

  public static void test10(){
        String str = "helloworld";
        System.out.println(str.replace("l","_"));//he__owor_d
        System.out.println(str.replaceFirst("l","_"));//he_loworld
}

5.字符串拆分

        可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串.

        1)实现字符串拆分处理

public static void test10(){
        String str = "hello world hello friend";
        String[] str2 = str.split(" ");
        for (String str1:str2) {
            System.out.print(str1);
        }
}
//hello
//world
//hello
//friend

        2)部分拆分处理

public static void test10(){
        String str = "hello world hello friend";
        String[] str2 = str.split(" ",2);
        for (String str1:str2) {
            System.out.print(str1);
        }
}
//hello
//world hello friend

         3)拆分网址

public static void test10(){
        String str = "192.168.1.1" ;
        String[] result = str.split("\\.") ;
        for(String s: result) {
            System.out.println(s);
        }
}

注意:

• 如果是"|","+","."等有含义字符需要加上转义字符 "\\".
• 如果是"\"就得写成"\\\\".
• 如果一个字符串有多个分隔符可以用"|"做连字符.

public static void test10(){
        String str = "name|hansan&age=18";
        String[] str2 = str.split("&|=|\\|");
        for (String str1:str2) {
            System.out.println(str1);
        }
}
//name
//hansan
//age
//18

        4)多次拆分 (开发中常用)

public static void test10(){
        String str = "name=zhansan&age=18";
        String[] str2 = str.split("&");//[name=zhangsan,age=18]
        for (int i = 0; i < str2.length; i++) {
            String[] temp = str2[i].split("=");
            for(String stemp:temp){
                System.out.println(stemp);
            }
        }
}
//name
//zhangsan
//age 
//18

6.字符串截取

public static void test10(){
        String str = "HelloWold";
        System.out.println(str.substring(5));//World
        System.out.println(str.substring(0,5));//Hello
}

7.其他操作方法

public static void test10(){
        String str = "  Hello Wold  ";
        System.out.println(str.trim());
}

trim()方法会去掉左右两边的空格,制表符,回车键等..... 

四.StringBuffer与StringBuilder

        由于String类的不可变性,为了方便字符串的修,java提供了两种类StringBuffer和StringBuilder.接下来介绍常见的操作方法.

public static void test10(){
        StringBuilder sb1 = new StringBuilder("hello");
        StringBuilder sb2 = sb1;
        sb1.append("world");//helloworld
        sb1.append(123);//hellloworld123
        System.out.println(sb1==sb2);//true
        System.out.println(sb1.charAt(0));//获取0号位上的字符
        System.out.println(sb1.length());//获取字符串的长度
        System.out.println(sb1.capacity());//
        sb1.setCharAt(0,'H');//Helloworld123
        sb1.insert(0,"Helloworld!!!");//Helloworld!!!Helloworld123
        System.out.println(sb1.indexOf("Hello"));//获取Hello第一次出现的位置
        System.out.println(sb1.lastIndexOf("Hello"));//获取Hello最后一次出现的位置
        sb1.deleteCharAt(0);//elloworld!!!Helloworld123
        sb1.delete(0,5);//orld!!!Helloworld123
        String str = sb1.substring(0,5);//orld!
        System.out.println(str);
        sb1.reverse();//321dlrowolleH!!!dlro
        str = sb1.toString();
        System.out.println(str);
}

注意:String 与 StringBuilder不能直接转换

• String转StringBuilder:利用StringBuilder的构造方法,或append()方法.
• StringBuilder转String:利用toString方法.

[面试题 ]

1.String,StringBuilder与StringBuffer的区别?

• String不可修改,StringBuilder与StringBuffer可以修改且大部分功能相似.
• StringBuffer采用同步处理线程更安全,但速度慢一点.StringBuilder未采用同步处理线程不安全,但速度更快.

2.以下共创建几个对象?[前提不考虑字符串常量池中存在]

String str1 = new String("hello");//2
String str2 = new String("world")+new String("hehe");//6

五.String类笔试题:

1.第一个只出现一次的字符

        由于只考虑小写字母,所以我们可以定义一个大小为26的整形数组,每个字符-'a'就会得到它数组中对于的位置, 该字符出现一次就给数组该位置的元素＋1,最后遍历字符串,如果字符在count数组中对应的元素为一就返回该字符.

public static int firstUniqChar(String s) {//第一个只出现一次的字符
        int[] count = new int[26];
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            count[ch-'a']++;
        }
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (count[ch-'a']==1){
                return i;
            }
        }
        return -1;
    }

2)计算字符串最后一个单词的长度 

 方法一:

        用字符串的内置方法String[] split()方法,以空格分隔字符串并保存与字符串数组中,返回数组最后一个元素即可. 

import java.io.InputStream;
import java.util.Scanner;
public class Main{
     public  static void  main(String [] args) throws Exception{
        Scanner scanner = new Scanner(System.in);
        String str  = scanner.nextLine();
        String[] str1 = str.split(" ");
        String str2 = str1[str1.length-1];
        System.out.println(str2.length());
     }
}

 方法二:

         更底层的做法较为推荐,将字符串转换为字符数组,从后往前遍历数组,遇到空格返回数组长度-1与空格下标的差值即可.

import java.io.InputStream;
import java.util.Scanner;
public class Main{
     public  static void  main(String [] args) throws Exception{
        Scanner scanner = new Scanner(System.in);
        String str  = scanner.nextLine();
        char[] arr = str.toCharArray();
        int index = -1;
        for(int i = arr.length-1;i>=0;i--){
           if(arr[i]==' '){
               index = i;
               break;
           }
       }
         System.out.println(arr.length-1-index);
     }
}

 3)验证回文串

        题中明确说明只考虑数字字符和字母,所以我们可以构造一个方法判断字符串是否合法,涉及到包装类Character的内置方法isDigit()和isLetter().题中强调不考虑字符的大小写,所以我们首先将字符串全部转换为小写或大写,然后定义首尾指针left和right比较字符串即可,注意比较时首先要满足left再考虑是否合法,比较后一定要记得移动指针. 

 public boolean isTrue(char ch){
        if(Character.isDigit(ch)||Character.isLetter(ch)){
            return true;
        }
        return false;
    }
    public boolean isPalindrome(String s) {
        String str = s.toLowerCase();
        int left = 0;
        int rigth = str.length()-1;
        while (left
            while (left
                left++;
            }
            while (left
                rigth--;
            }
            if (str.charAt(left)!=str.charAt(rigth)){
                return false;
            }
            left++;
            rigth--;
        }
        return true;
        
    }

 4)字符集合

         创建一个布尔数组大小为所有字母的编码之和(122-65),由于布尔数组默认初始化为false,所以我们可以判断如果字符串对应的数组下标为false,我们就将它拼接给StringBuilder对象,并将该下标对应元素置为true.最后以toString()返回StringBuilde对象并打印即可.

public static String test(String s){
        boolean[] arr = new boolean[58];
        StringBuilder str = new StringBuilder();
        for(int i = 0;i
               char ch = s.charAt(i);
               if(arr[ch-'A']==false){
                   str.append(ch);
                   arr[ch-'A'']=true;
               }
           }
        return str.toString();
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) { // 注意 while 处理多个 case
           String s = scanner.nextLine();
            System.out.println(test(s));
        }
    }

总结

        以上就是字符串深入剖析的全部内容,从字符串最底层的常量池到基本操作方法和面试题1万5千多字,码子字易如果对你有亿点点帮助和启发麻烦不要吝啬三连哦!