海阔天空

手机扫码查看

Sting类

字符串是常量，创建之后不可改变
字符串字面值存储在字符串池中，可以共享

String s1="abc";
String s2="abc";
String s3=new String("abc");
System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false

String s=”hello”;//产生一个对象，字符串池中存储
String s=new String(“hello”);//产生两个对象，堆、池各存储一个。

常用方法
public char charAt(int index);//根据下标获取字符

String s="hello";
System.out.println(s.charAt(0));//获取下标0的字符

//源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public char charAt(int index){
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }
}

public boolean contains(String str);//判断当前字符串是否包含str

String s="hello";
System.out.println(s.contains("lo"));

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public boolean contains(CharSequence s) {
        return indexOf(s.toString()) > -1;
    }
}*/

pulic char[] toCharArray();//将字符串转换成数组

String s="hello";
char[] c=s.toCharArray();
for(int i=0;i<c.length;i++){
    System.out.print(c[i]);
}

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public char[] toCharArray() {
        // Cannot use Arrays.copyOf because of class initialization order issues
        char result[] = new char[value.length];
        System.arraycopy(value, 0, result, 0, value.length);
        return result;
    }
}*/

public int indexOf(String str);//查找str首次出现的下标，存在返回下标，否则返回-1

String s="hello";
System.out.println(s.indexOf('e'));

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public int indexOf(int ch) {
        return indexOf(ch, 0);
    }
}*/

public int lastIndexOf(String str);//查找字符串最后一次出现的下标索引

String s="hello";
System.out.println(s.lastIndexOf('e'));

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public int lastIndexOf(int ch) {
        return lastIndexOf(ch, value.length - 1);
    }
}*/

public int length();//返回字符串长度

String s="hello";
System.out.println(s.length());

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public int length() {
        return value.length;
    }
}*/

public String trim();//去掉字符串前后的空格

String s=" hello ";
System.out.println(s.trim());

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public String trim() {
        int len = value.length;
        int st = 0;
        char[] val = value;    

        while ((st < len) && (val[st] <= ' ')) {
        st++;
        }
        while ((st < len) && (val[len - 1] <= ' ')) {
        len--;
        }
        return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
        }
}*/

public String toUpperCase();//将小写转换成大写
public String toLowerCase();//将大写转换成小写

String s=" hello ";
System.out.println(s.toUpperCase());
System.out.println(s.toLowerCase());

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
private final char value[];
    public String toUpperCase() {
        return toUpperCase(Locale.getDefault());
    }
    public String toLowerCase() {
        return toLowerCase(Locale.getDefault());
    }
}*/

public boolean equalsIgnoreCase(String str);//比较两个字符串，不考虑大小写

String s=" hello ";
String s1=s.toUpperCase();
String s2=s.toLowerCase();
System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public boolean equalsIgnoreCase(String anotherString) {
        return (this == anotherString) ? true
                : (anotherString != null)
                && (anotherString.value.length == value.length)
                && regionMatches(true, 0, anotherString, 0, value.length);
    }
}*/

public boolean endWith(String str);//判断字符串是否以str结尾
public boolean startsWith(String str);//判断字符串是否以str开头

String s="hello.java";
System.out.println(s.endsWith(".java"));
System.out.println(s.startsWith("hello"));

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public boolean endsWith(String suffix) {
        return startsWith(suffix, value.length - suffix.value.length);
    }
    public boolean startsWith(String prefix) {
        return startsWith(prefix, 0);
    }
}*/

public String replace(char oldchar,char newchar);//将旧字符串转换成新字符串

String s="hello";
System.out.println(s.replace('e','A'));

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; 

            while (++i < len) {
        if (val[i] == oldChar) {
        break;
        }
        }
        if (i < len) {
        char buf[] = new char[len];
        for (int j = 0; j < i; j++) {
        buf[j] = val[j];
        }
        while (i < len) {
        char c = val[i];
        buf[i] = (c == oldChar) ? newChar : c;
        i++;
        }
        return new String(buf, true);
        }
        }
        return this;
        }
}*/

public String[] split(String str);//根据str拆分

String s="一二三四五，上山打老虎，老虎没打着，打到一个小松鼠";
String[] split = s.split("，");
for(int i=0;i<split.length;i++){
    System.out.println(split[i]);
}

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public String[] split(String regex) {
        return split(regex, 0);
    }
}*/

public String subString(int index);//字符串截取，返回一个新的字符串
public String subString(int startindex,int endindex);//字符串截取，index为开始截取位置，endindex为截取最后的位置-1

String s="HelloWorld";
System.out.println(s.substring(1));
System.out.println(s.substring(2, 5));

/*源码
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
    private final char value[];
    public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }
}*/