Java篇-String详解

一 : String内存解析

• 案例1

String str1 = "hellow world";
String str2 = "hellow world";
System.out.println(str1 == str2);//true

内存分析 :

str1->存放在字符串常量池中 假设地址为 0x12138 ,str2直接去常量池中找,发现常量池中有相同字符串,并且也指向地址0x12138 综上所述 str1 == str2 为真,(== 比较的是地址值)

图解分析 :

str1 与str2 指向同一块地址

内存分析

• 案例2

String str1 = "javaEE";
String str3 = new String("javaEE");
System.out.println(str1 == str3);//false
System.out.println(str1.equals(str3));//true

内存分析 :

String的 equals方法比较的是内容,也就是字符串本身是否相同
String的底层存储方式是数组.
String str3 = new String("hellow word") 进行源码分析

public String(String original) {
        this.value = original.value;
        this.coder = original.coder;
        this.hash = original.hash;
    }

其中 value属性就是存储字符串的数组,也就是字符串底层的存储方式

private final byte[] value;

this.value = original.value; 这一句相当于 把 "hellow word"的value地址值(假设是0x12138) 给了 str3的value,也就是 说str3 的value指向了"hellow word"的地址值.(也就是底层存放字符串的数组)而str3 则指向了堆空间的String对象内存地址为0x22222

图解分析 :

内存分析

• 案例3

String str1 = "tz"
String str4 = "hellow "+"tz";
String str5 = "hellow";
String str6 = str1 + str5;
System.out.println(str4 == str6);//false

内存分析 :

String str4 = "hellow "+"tz" , 将 "hellowtz" 组合完成后 地址分配给 str4 其等同于 String str4 = "hellowtz"
String str6 = str1 + str5;
运行期JVM首先会在堆中创建一个StringBuilder类，
同时用str1指向的字符串对象完成初始化，
然后调用append方法完成对str5所指向的字符串的合并，
接着调用StringBuilder的toString()方法在堆中创建一个String对象，
最后将刚生成的String对象的堆地址存放在局部变量str6中。

• 案例4

String str5 = "TZ ";
str5 = str5 + "Cool";

内存分析 :

String str5 = "TZ " ->在常量池 "TZ" 假设地址为 0x77520
str5 = str5 + "Cool" - >由于字符串底层是数组实现的,是不可变的,所以切断之前的地址指向,重新造了一个字符串 "TZCool"地址 为0x45630 str5此时指向新的地址

图解分析 :

内存分析

二 : String常用方法

    String str1 = "abcdefghijk";
    String str2 = "abcc";

---

• public boolean contains(CharSequence s)

字符串是否包含另一个字符串

System.out.println(str1.contains("abc"));

• public int length()

返回字符串长度

System.out.println(str1.length());

• public char charAt(int index)

返回在指定index位置的字符,index从0开始

    System.out.println(str1.charAt(3)); 

• public boolean equals(Object anObject)

比较两个字符串是否相等,相等返回true ,否则返回false

    System.out.println(str1.equals(str2));

• public int compareTo(String anotherString)

从头开始比较两个字符,当不同时返回差值

System.out.println(str1.compareTo(str2));//1

• public int indexOf(String str)

返回str字符串在当前字符串首次出现的位置,若没有返回-1

System.out.println(str1.indexOf("bc"));

• public int lastIndexOf(String str)

返回str字符串最后一次在当前字符串中出现的位置,若无返回-1

    System.out.println(str1.lastIndexOf("bc"));

• public int indexOf(String s ,int startpoint)

返回s字符串从当前字符串startpoint位置开始的，首次出现的位置

• public int lastIndexOf(String s ,int startpoint)

返回s字符串从当前字符串startpoint位置开始的，最后一次出现的位置

• public boolean startsWith(String prefix)

判断当前字符串是否以prefix开始

System.out.println(str1.startsWith("abcd"));

• public boolean endsWith(String suffix)

判断当前字符串是否以suffix结束

• public boolean regionMatches(int firstStart,String other,int otherStart ,int length)

判断当前字符串从firstStart开始的子串与另一个字符串other从otherStart开始，length长度的字串是否equals

System.out.println(str1.regionMatches(10, str3, 0, str3.length()));

• public String substring(int startpoint)

返回从start开始的子串

• public String substring(int start,int end)

返回从start开始到end结束的一个左闭右开的子串。start可以从0开始的

• pubic String replace(char oldChar,char newChar)

用newChar字符替换oldChar字符

• public String replaceAll(String regex, String replacement)

regex -- 匹配此字符串的正则表达式。

replacement -- 用来替换每个匹配项的字符串。

• public String trim()

去除当前字符串中首尾出现的空格，若有多个，就去除多个

• public String concat(String str)

连接当前字符串与str

• public String[] split(String regex)

按照regex将当前字符串拆分，拆分为多个字符串，整体返回值为String[]

三 : String常用转换

• 字符串 与基本数据类型、包装类之间转换

①字符串 --->基本数据类型、包装类:调用相应的包装类的parseXxx(String str);

String str1 = "123";
        int i = Integer.parseInt(str1);
        System.out.println(i);

②基本数据类型、包装类--->字符串:调用字符串的重载的valueOf()方法

String str2 = i + "";
        str2 = String.valueOf(i);
        System.out.println(str2);

• 字符串与字节数组间的转换

①字符串---->字节数组:调用字符串的getBytes()

String str = "abcd123";
        byte[] b = str.getBytes();
        for(int j = 0;j < b.length;j++){
            System.out.println((char)b[j]);
        }

②字节数组---->字符串：调用字符串的构造器

String str3 = new String(b);
        System.out.println(str3);

• 字符串与字符数组间的转换

①字符串---->字符数组：调用字符串的toCharArray();

String str4 = "abc123";
        char[] c = str4.toCharArray();
        for(int j = 0;j < c.length;j++){
            System.out.println(c[j]);
        }

②字符数组---->字符串:调用字符串的构造器

String str5 = new String(c);
        System.out.println(str5);

四 : StringBuffer 与 StringBuilder

代表可变的字符序列，可以对字符串内容进行增删

StringBuffer 常用方法

StringBuffer sb = new StringBuffer();

---

• StringBuffer append(String s)

• StringBuffer append(int n)

• StringBuffer append(Object o)

• StringBuffer append(char n)

• StringBuffer append(long n)

• StringBuffer append(boolean n)

sb.append("abc").append("123").append(true);

• StringBuffer insert(int index, String str)
  在某个位置插入字符串

        sb.insert(3, "hello");

• public StringBuffer reverse()
  反转此StringBuffer

StringBuffer sb1 = sb.reverse();

---

其他方法有的与String类似方法

• StringBuffer delete(int startIndex, int endIndex)
• public char charAt(int n )
• public void setCharAt(int n ,char ch)
• StringBuffer replace( int startIndex ,int endIndex, String str)
• public int indexOf(String str)
• public String substring(int start,int end)
• public int length()

StringBuilder

可变的字符序列，是jdk5.0新加入的，线程不安全，效率要高于StringBuffer.

五 : 编程演练五分钟

• 模拟一个trim方法,去除字符串两端空格

public static String deleteSpace(String str) {
        int begain = 0;
        int end  = str.length() -1;
        while (begain <= end && str.charAt(begain) == ' ') {
            begain ++;
            
        }
        while (begain <= end && str.charAt(end) == ' ') {
            end --;
            
        }
        
        return str.substring(begain, end+1);
        
    }

• 将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg”

public static String reveseString(String str,int startpoint,int endpoint) {
        String firstStr = str.substring(0,startpoint);
        String endStr = str.substring(endpoint+1);
        
        String midStr = str.substring(startpoint, endpoint+1);
        char[] charArray = midStr.toCharArray();
        for (int i = 0,j = charArray.length - 1; i < j; i++,j--) {
            char temp = charArray[i];
            charArray[i] = charArray[j];
            charArray[j] = temp;
        }
        
        String newStr = new String(charArray);
        return firstStr+newStr+endStr;
    }

• 获取一个字符串在另一个字符串中出现的次数。判断str2在str1中出现的次数

public static int getTime (String str1,String str2) {
        int time = 0;
        int index;
        while((index = str1.indexOf(str2)) != -1) {
            time ++;
            str1 = str1.substring(index+str2.length());
        }
        return time;
    }

• 获取两个字符串中最大相同子串

public static List<String> getMaxStr(String str1,String str2) {
        String maxStr = str1.length() > str2.length() ? str1: str2;
        String minStr = str1.length() < str2.length() ? str1: str2;
        int len = minStr.length();
        List<String> list = new ArrayList<>();
        for (int i = 0; i < len; i++) {
            for(int x = 0,y = len - i;y <= len;x++,y++ ) {
                
                String subStr = minStr.substring(x, y);
                
                if (maxStr.contains(subStr)) {
                    list.add(subStr);
                }
                    
            }
            
            if (list.size() != 0) {
                return list;
            }
        }
        return null;
    } 
    

• 对字符串中字符进行自然顺序排序。

public static String reverse(String str) {
        
        char[] c = str.toCharArray();
        Arrays.sort(c);
        return new String(c);
        
    }