Java基础总结---String

学了这么久的Java,总感觉没有学精,自己写代码的时候不熟悉.所以这次准备将下面的几个方面深入了解,当作一个Java基础的总结.

一. String

一. 自己的理解

1. String的不可变性(字符串常量都存储在常量池中)

class Demo{
    public static void main(String[] args){
        // 这里会先去常量池寻找是否有"ABC"这个常量,没有就新建"ABC"常量,有就将str引用指向"ABC"
        String str = "ABC";

        //这里会在常量池中新建一个"D",(如果常量池中有的话应该不需要新建),然后和str指向的"ABC"进行拼接,产生新的字符串"ABCD",再将str指向新产生的"ABCD" 
        str = str + "D";

        // 输出结果是"ABCD"
        System.out.println("str="+str);

        // 创建过程:先去常量池中寻找"ABC",有就在堆区中创建一个对象,指向"ABC",然后str2指向创建的对象.
        //
        // 没有会先在常量池中创建"ABC",再在堆区中创建一个对象指向"ABC",用str2指向这个对象
        String str2 = new String("ABC");
    }   
}

String的不变性指的是刚开始创建的那个字符串始终不会改变,正如上面的”ABC”,当把”ABC”和”D”进行拼接的时候,原来的”ABC”没有改变,而是产生一个新的字符串”ABCD”.所以会有StringBuilder和StringBuffer,在拼接过程中不会产生过渡的字符串,可以提高字符串的拼接效率,节省内存.

2. String 的构造方法(了解,2,3有重载方法)

    1. 空构造器--new String();
    2. byte[]类构造器--new String(byte[] b);
    3. char[]类构造器--new String(char[] c);
    4. int[] 类构造器--new String(int[] i,int offset, int count);
    5. String类构造器--new String("字符串常量");
    6. new String(StringBuilder sb);
    7. new String(StringBuffer sb); 

byte[],char[],int[]三个构造器应该转化成char[],再去转化成String.

3. String的几个常用方法

    1. char charAt(int index); 获得输入下表的那个字符
    2. int length();  获取字符串的长度
    3. boolean equals(String str); 比较两个字符串是否相等
    4. String[] split(String regex); 根据正则将字符串分隔为一个字符串数组
    5. static String valueOf(Object args),静态方法,多个重载,将参数转换为字符串

/**
 * 测试上面的几个常用方法
 */
class Demo1{
    public static void main(String[] args){
        // 使用常量字符串初始化
        String str = "567.89";
        char c = str.charAt(0);
        int length = str.length();
        boolean isEquals = str.equals("567.89");
        boolean isEquals2 = str.equals(567.89);// 和double类型进行比较,编译的时候有提示
        String[] strs = str.split("\\.");// 根据-来将字符串划分成两个部分
        String str2 = String.valueOf(199.1);
        System.out.println("c="+c+" length="+length+" isEquals="+isEquals+" isEquals2="+isEquals2);
        System.out.println("strs="+strs[0]+" "+strs[1]);
        System.out.println("str2="+str2);
    }
}

结果为:

c=5 length=6 isEquals=true isEquals2=false
strs=567 89
str2=199.1

刚开始使用的567.89测试的,结果正则表达式的时候用 . 去分割然而 . 是代表任意一个字符,所以得到的是一个长度为0 的数组.改成567-89; 如果要去匹配 567.89 ,正则应该怎么写?
首先要去匹配 . 的话需要使用到\. 去转义,变成字符串要再加上\,所以split()应该写成str.split("\\.");

二.不熟悉的地方

1.方法

1. new String(byte[] b); 参数是byte[],int[],char[]

class Demo2{
    public static void main(String[] args){
        byte[] b = new byte[]{1,2,3,4,49,65,97};//byte的范围为-128~127
        String s1 = new String(b);
        System.out.println("s1="+s1);

        char[] c = new char[]{34443,49,65,97};// char无符号为0~65535,
        String s2 = new String(c);
        System.out.println("s2="+s2);

        //int类型4个字节,32位,超过了char的范围,所以如果不在char范围内,会报IllegalArgumentException
        int[] i = new int[] {300000,49,65,97};

        // 构造器为:new String(int[] i, int offset, int count);offset代表下标,count代表从下标开始的数量
        String s3 = new String(i,0,4);
        System.out.println("s3="+s3);
    }
}

运行结果
s1=1Aa
s2=蚋1Aa
s3=��1Aa

2. int codePointAt(int index); 返回输入下标处的字符的整数值.

3. int compareTo(String s);返回负数,0,正数,分别对应小于,等于,大于输入的字符串,
    忽略大小写的 int compareToIgnoreCase(String s)

4. String concat(String s); 连接字符串后并返回 

    5. boolean contains(CharSequence c);  // CharSequence 是一个接口,String实现了这个接口.所以可以直接放入一个字符串,方法检查是否包含输入的字符串.Character没有实现CharSequence接口.

6. boolean endsWith(String s);以输入字符串结束
 boolean startsWith(String s); 以输入字符串开始

7. static String format(String format, Object ... args ); // String.format("Hi,%s:%s.%s", "王南","王力","王张"); 这是参数化输出.用的挺少.

8. int indexOf(int ch);
int indexOf(String str);
int lastIndexOf(int ch);
int lastIndexOf(String str); // 获取输入下标位置的字符的int型数值

9. boolean isEmpty(); // 返回字符串 是否为空

10. boolean matches(String regex); // 返回字符串是否匹配正则式

11. String replace(char oldChar, char newChar);
String replaceAll(String regex, String replacement); // 根据正则表达式用replacement替换所有

12. String substring(int begin, int end);// 截取字符串

13. String trim(); // 去掉头部和尾部的空格

/**
 * 测试上面的方法
 */
 public class Demo3{
    public static void main(String[] args){
        String s1 = "abcdef";
        int i1 = s1.codePointAt(1);//codePointAt()方法
        System.out.println("i1="+i1);

        String s2 = "aBcdef";
        int i2 = s1.compareTo(s2);// compareTo()方法
        System.out.println("i2="+i2);

        String s3 = "ab";
        int i3 = s3.compareTo(s1);
        System.out.println("i3="+i3);

        String s4 = s1.concat(s2); // concat()方法,
        System.out.println("s4="+s4);

        boolean isContains = s1.contains(s3); // contains()方法
        System.out.println("isContains="+isContains);

        boolean isEnd = s1.endsWith(s3); // endsWith()方法
        boolean isStart = s1.startsWith(s3); // startWith()方法
        System.out.println("isEnd="+isEnd+" isStart="+isStart);

        int i4 = s1.indexOf(s3); // indexOf(String str)方法
        int i5 = s1.indexOf('c'); // indexOf(int index)方法
        System.out.println("i4="+i4+" i5="+i5);

        String s5 = new String("");
        boolean isEmpty = s5.isEmpty(); // isEmpty()方法
        System.out.println("isEmpty="+isEmpty);

        String s6 = "123.45-9";
        boolean isMatch = s6.matches("\\d{3}\\.\\d{2}-\\d"); // matches()方法
        System.out.println("isMatch="+isMatch);

        String s7 = "123aa45bb678cc";
        s7 = s7.replaceAll("\\d\\d","--"); // replaceAll(String regex,String replament)方法
        System.out.println("s7="+s7);

        String s8 = s6.substring(1,4); // substring()方法,这里注意小写
        System.out.println("s8="+s8);

        String s9 = "   This is a String   ";
        String s10 = s9.trim(); // trim()方法
        System.out.println("s10="+s10);
    }
}

输出结果:
i1=98
i2=32
i3=-4
s4=abcdefaBcdef
isContains=true
isEnd=false isStart=true
i4=0 i5=2
isEmpty=true
isMatch=true
s7=–3aa–bb–8cc
s8=23.
s10=This is a String