java字符串String

前言

String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。
字符串不变; 它们的值在创建后不能被更改。 字符串缓冲区支持可变字符串。 因为String对象是不可变的，它们可以被共享

public final class String implements java.io.Serializable, Comparable<String>, CharSequence{
    private final char value[];
    ...
}

1、构造器

参数是字节数组

bytes - 要解码为字符的 byte
offset - 要解码的第一个 byte 的索引（包括）
length - 要解码的 byte 数

String(byte[] bytes)
String(byte[] bytes, Charset charset)
String(byte[] bytes, int offset, int length)
String(byte[] bytes, int offset, int length, Charset charset)
String(byte[] bytes, int offset, int length, String charsetName)
String(byte[] bytes, String charsetName)

案例

byte[] b = {55,66,77,88,99};
String s = new String(b,2,3);
System.out.println(s);//MXc

参数是字符数组

value - 要解码为字符数组
offset - 要解码的第一个 byte 的索引（包括）
count - 要解码的 字符数

String(char[] value)
String(char[] value, int offset, int count)

案例

char[] b = {'a','b','c','d','e'};
String s = new String(b,2,3);
System.out.println(s);//cde

参数是int数组

String(int[] codePoints, int offset, int count)

案例

int [] b = {55,66,77,88,99};
String s = new String(b,2,3);
System.out.println(s);//MXc

参数是对象

String(String original)//初始化新创建的对象 String所以它代表相同的字符序列的说法；换句话说，新创建的字符串是一个副本的参数字符串。
String(StringBuffer buffer)//分配一个新的字符串，该字符串包含当前包含在字符串缓冲区中的字符的序列的字符串。
String(StringBuilder builder)//分配一个新的字符串，该字符串包含当前包含在字符串生成器参数中的字符的序列。

2、将对象换成字符串形式

//对象转换
static String valueOf(Object obj)

//将基本类型转换成字符串形式，注意：没有byte和short的转换
static String valueOf(boolean b)//返回的 boolean参数的字符串表示形式。
static String valueOf(double d)//返回的 double参数的字符串表示形式。
static String valueOf(float f)//返回的 float参数的字符串表示形式。
static String valueOf(int i)//返回的 int参数的字符串表示形式。
static String valueOf(long l)//返回的 long参数的字符串表示形式。
static String valueOf(char c)//返回的 char参数的字符串表示形式。

//将字符数组转换成字符串形式
static String valueOf(char[] data)//返回的 char数组参数的字符串表示形式。
static String valueOf(char[] data, int offset, int count)//返回一个特定的子阵的 char数组参数的字符串表示形式。

//将字符串转换成数组
char[] toCharArray()将此字符串转换为一个新的字符数组。

byte[] getBytes()
byte[] getBytes(Charset charset)
byte[] getBytes(String charsetName)

3、比较顺序

区别大小写：比较两个字符串的字典。该比较基于字符串中各个字符的 Unicode 值

int compareTo(String anotherString)  

源码

public int compareTo(String anotherString) {
        int len1 = value.length;//获取当前字符的长度
        int len2 = anotherString.value.length;//获取要比较字符长度
        int lim = Math.min(len1, len2);//返回最小的长度
        char v1[] = value;//把String的属性char value[] 赋值到局部变量v1
        char v2[] = anotherString.value;

        int k = 0;
        //当前最小字符串长度大于0
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        //当前最小字符串长度等于0，那么返回的是字符串的长度
        return len1 - len2;
}

总结：如果存在最小字符串长度等于0，那么返回的是字符串的长度；否则比较的最开始不同字符Unicode 值的差值

情况1:存在最小字符串长度等于0。结果是字符串的长度，

//a的Unicode值是97 b的Unicode值98
String s  = new String("abc");
String s1  = new String("");
int e = s.compareTo(s1);
int d = 'a';
System.out.println(d);97
System.out.println(e);3

情况2 : 不存在最小字符串长度等于0。比较的最开始不同字符Unicode 值的差值

String s  = new String("abc");
String s1  = new String("b");
int e = s.compareTo(s1);
int a = 'a';
int b = 'b';
System.out.println(a-b); -1
System.out.println(e); -1

忽略大小写的差异

int compareToIgnoreCase(String str)

源码

public int compare(String s1, String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            for (int i = 0; i < min; i++) {
                char c1 = s1.charAt(i);
                char c2 = s2.charAt(i);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
}

总结：如果存在最小字符串长度等于0，那么返回的是字符串的长度；否则比较的最开始不同字符Unicode 值的差值。注意这里的差值都是小写化后的差值

4、是否包含

boolean contains(CharSequence s)//如果并且只有当此字符串包含指定的字符序列的字符串值，则返回真值。  

案例

String s  = new String("sdfgh");                
System.out.println(s.contains("df"));//true 

5、equals，hashCode

boolean equals(Object anObject)
//将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true
boolean equalsIgnoreCase(String anotherString)//将此 String 与另一个 String 比较，不考虑大小写

源码

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
}

总结：
1、如果地址相同返回true，
2、如果地址不同且都是String类型，判断每个字符的Unicode值，如果相同返回true

int hashCode()

源码

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

boolean contentEquals(CharSequence cs)比较这个字符串来指定 CharSequence。  
boolean contentEquals(StringBuffer sb)比较这个字符串来指定 StringBuffer。  

contentEquals和equals区别

这两个方法都可以用来比较String对象内容序列的异同，但也存在差异。

最大的差别就是String的equals方法只有在另一个对象是String的情况下才可能返回true，

而contentEquals只要求另一个对象是CharSequence或其子类的对象

6、区域比较

toffset -此字符串中的子区域的索引。
other -字符串参数。
ooffset -在字符串参数的分区起始索引。
len -比较的字符数。

boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)//测试如果两个字符串区域是相等的。  
boolean regionMatches(int toffset, String other, int ooffset, int len)//测试如果两个字符串区域是相等的。  

案例

String str = "0123dnf2"; 
String str2 = "29dnf4567";
System.out.println(str.regionMatches(4, str2, 2, 3));//true

7、格式化

底层是Formatter的format方法

//使用指定的语言环境、格式字符串和参数返回一个格式化字符串。
static String format(Locale l, String format, Object... args)

//使用指定的格式字符串和参数返回格式化的字符串。  
static String format(String format, Object... args)

8、复制

static String copyValueOf(char[] data)//等于 valueOf(char[])。  

static String copyValueOf(char[] data, int offset, int count)//等于 valueOf(char[], int, int)。  

srcBegin ：字符串中要复制的第一个字符的索引。
srcEnd：字符串中要复制的最后一个字符之后的索引。(不包括)
dst ： 目标数组。
dstBegin： 目标数组中的起始偏移量

void getChars (int srcBegin, int srcEnd, char[] dst, int dstBegin)  //将此字符串的字符复制到目标字符数组中

案例

String str = "65577m";
char[] chararr = new char[4];                                 
str.getChars(0,3, chararr,1);
System.out.print(chararr);//<空格>655
System.out.print(Arrays.toString(chararr));//[ ,6,5,5] 

9、字符串中字符信息

int codePointAt(int index)返回指定索引字符的代码点。  
int codePointBefore(int index)//返回指定索引前一个字符的代码点。 

案例

char [] b = {'7','B','M','X','c'};
String s  = new String(b);
System.out.println(s.charAt(0));‘7’
System.out.println(s.codePointAt(0));55
System.out.println(s.codePointAt(1));66
System.out.println(s.codePointBefore(2));66
System.out.println(s.codePointBefore(3)); 7

int codePointCount(int beginIndex, int endIndex)//指定文本范围中 Unicode 代码点的数量  

案例

char [] b = {'7','B','M','X','c'};
String s  = new String(b);
System.out.println(s. codePointCount(1,4));3
System.out.println(s. codePointCount(2,4));2

10、字符串前后缀判断

boolean startsWith(String prefix)测试这个字符串是否以指定的前缀开始。  

boolean startsWith(String prefix, int toffset)  toffset - 在此字符串中开始查找的位置。  
             
boolean endsWith(String suffix）测试此字符串是否以指定的后缀结束

案例

String s  = new String("dd.s");
System.out.println(s.endsWith("s")); //true

11、寻找字符

char charAt(int index)//返回指定索引的 char值。

int indexOf(int ch) //ch - 一个字符（Unicode 代码点）。

int indexOf(int ch, int fromIndex)//返回在指定字符的第一个发生的字符串中的索引，在指定的索引处开始搜索。  

int indexOf(String str)//返回指数在这个字符串指定的子字符串中第一个出现的。  
int indexOf(String str, int fromIndex)//返回此字符串的指定子字符串中第一个出现在索引中，从指定索引处开始。  


int lastIndexOf(int ch)//返回在指定字符的最后一个发生的字符串内的索引。  
int lastIndexOf(int ch, int fromIndex)//返回在指定字符的最后一个发生的字符串内的索引，在指定的索引处搜索向后开始。  
int lastIndexOf(String str)//返回指数在这个字符串的指定子字符串中最后出现。  
int lastIndexOf(String str, int fromIndex)//返回此字符串的指定子字符串中最后出现在索引，搜索后从指定索引处开始。

案例

String str = "rgh45hj";                                 
System.out.println(str.indexOf('4'));//3
System.out.println(str.indexOf("4"));//3

12、字符串替换

String replace(char oldChar, char newChar)//一个从此字符串派生的字符串，它将此字符串中的所有 oldChar 替代为 newChar。 

String replace(CharSequence target, CharSequence replacement)//每个子串替换该字符串指定的文本替换序列靶序列匹配的文字。

String replaceAll(String regex, String replacement)//使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。  

String replaceFirst(String regex, String replacement)//代替这个字符串的替换，给 regular expression匹配第一个字符串。  

案例1

String str = "1234s77sss";                                 
System.out.println(str.replace('s', 'a'));//1234a77aaa

案例2

String str = "1234ss77sss";                              
System.out.println(str.replace("ss", "a"));//1234a77as

案例3

String str = "1234ss123sss";                                  
System.out.println(str.replaceAll("[12]", "#"));//##34ss##3sss

案例4

String str = "1234ss123sss";                              
System.out.println(str.replaceFirst("[12]", "#"));//#234ss123sss

13、字符串按正则分割

String[] split(String regex)//根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit) //limit - 分割的次数

案例

String str = "1234ss123sss";                                  
System.out.println(Arrays.toString(str.split("\\d",3)));//[, , 34ss123sss]

14、字符串截断

String substring(int beginIndex)beginIndex - 起始索引（包括）。  
String substring(int beginIndex, int endIndex)

CharSequence subSequence(int beginIndex, int endIndex)endIndex - 结束索引（不包括）。

案例

String str1 = "012345678";                                 
System.out.println(str1.substring(1, 5));//1234

String str2 = "0123dnf2";    
System.out.println(str2.subSequence(2,5)); 23d

15、大小写转换

String toLowerCase()将所有的角色在这 String以较低的情况下使用默认的区域设置规则。  
String toLowerCase(Locale locale)将所有的角色在这 String以较低的情况下使用给定的 Locale规则。  

 
String toUpperCase()将所有的角色在这 String上使用的默认区域设置规则。  
String toUpperCase(Locale locale)将所有的角色在这 String大写使用给定的 Locale规则。  

16、字符串插入

//返回一个由 CharSequence elements副本的新字符串连接在一起的一份指定的 delimiter。  
static String join(CharSequence delimiter, CharSequence... elements)

//返回一个由 CharSequence elements String加入新的副本，连同一份指定的 delimiter。 
static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

案例

String [] str = {"a","b","c"};
System.out.println(String.join("-",str));a-b-c

17、拼接字符串

String concat(String str)将指定字符串连接到此字符串的结尾。

案例

String s  = new String("s");              
System.out.println(s.concat("d")); //sd

18、前导和尾随空格删除

String trim()

案例

String str = "   sdfg    ";                               
System.out.println(str.trim());
sdfg

19、正则匹配

boolean matches(String regex)//告诉是否这个字符串匹配给定 regular expression。