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);
4000
// 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