黑马程序员---java学习笔记之字符串

1、字符串最大的特点是：一旦被初始化，字符串就不可被改变。

public class StringDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		/*
		 * 下述第一句代码，在内存中只会产生一个对象实体
		 * 第二句代码，在内存中会产生两个实体，一个是字符串常量，存放在方法区的常量池中。另一个是对象实体，存放在堆中。
		 * */
		
		String s1 = "abc";
		String s2 = new String("abc");
		
		/*
		 * 因为s1和s2分别指向不同的对象实体，指代的地址不同。
		 * */
		System.out.println(s1 == s2);//打印结果为false
		
		/*
		 * String类重写了Object类中equals方法，用来比较两字符串对象是否具有相同的字符串序列
		 * */
		
		
		System.out.println(s1.equals(s2));//打印结果为true
		

	}

}

2、下面是一段示例代码

public class StringDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		String s1 = "abc";
		String s2 = new String("abc");
		String s3 = "abc";
		
		System.out.println(s1 == s2);//打印结果为false
		/*
		 * 为什么下述代码的打印结果是true，s1和s3不是分别指向两个对象吗？
		 * 首先说一下字符串常量池，该常量池位于方法区中，常量池可以理解成字符数组，
		 * 使用s3指向一字符串常量"abc"时，发现常量池中已经存在一个"abc"时，就不会再在常量池中创建一个"abc"，而是使两个引用s1和s3
                 * 指向常量池中的同一地址
		 * */
		System.out.println(s1 == s3);//打印结果为true
		

	}

}

3、String类方法中的startswith(...)、endswith(...)和contains(...)方法的一个实用场景就是判断文件名字符串。

4、String类中的int index(String str)方法一方面可以判断某字符串是否在该字符串中(这是contains的功能)，还能返回第一次出现该字符串的字符串位置。

String s = "hello java";
		
		String s1 = s.replace('a','n');
		String s1_1 = s.replace('q','n');
		
		System.out.println(s);//打印结果是：hello java
		System.out.println(s1);//打印结果是：hello jnvn
		System.out.println(s1_1);//打印结果是：hello java(当替换的旧字符不在原字符串中时)
		
		String s2_1 = s.replace("java","world");
		String s2_2 = s.replace("jave","world");
		
		System.out.println(s);//打印结果是：hello java
		System.out.println(s2_1);//打印结果是：hello world
		System.out.println(s2_2);//打印结果是：hello java(当替换的旧字符串不在原字符串中时)

5、根据视频中的讲解，我自己想到了一个新的例子：

String s1 = "zhangsan,lisi,,wangwu";
		String[] arr = s1.split(",");
		for( int i = 0; i < arr.length; i++ )
			System.out.println(arr[i]);

运行结果是：

zhangsan
lisi

wangwu

6、String类中几个之前不怎么了解的函数：

        trim():去除字符串两端的空格；*****

        compareTo():按字典序返回两字符串的差值；

        toUpperCase/toLowerCase:字符串转换成大写或者小写；

7、模仿trim函数

public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		String str = "   hello world";
		
		int i = 0;
		
		while( str.charAt(i) == ' ' )
			i++;
		int j = str.length() - 1;
		while( str.charAt(j) == ' ' )
			j--;
		String str1 = str.substring(i, j+1);
		System.out.println(str1);

	}

8、在实际编程中，我发现这样是可以的。

String str = "abc";
		str.substring(3,3);

我们知道，字符串"abc"的最大下标值是2，而在subString(...,...)函数中，第一个参数的值居然可以是最大下标值加1。
9、字符串反转

String str = "abcd123";
		int len = str.length();
		char[] chs = new char[len];
		
		for( int i = 0; i < len; i++ )
			chs[i] = str.charAt(len-1-i);
		String str1 = new String(chs);
		System.out.println(str1);

10、查看某字符串中有另一字符串的次数：

public static int subStringCnt(String dadString,String sonString)
	{
		int cnt = 0;
		int index;
		String strTemp = new String(dadString);

		while( (index = strTemp.indexOf(sonString)) != -1)
		{
			cnt++;
			strTemp = strTemp.substring(index+sonString.length(),strTemp.length());
		}
		
		return cnt;
	}

11、求两字符串最大相同子串的非常经典的java代码：

public static String getMaxSubstring(String str1, String str2)
	{
		String max = "", min = "";
		max = (str1.length() > str2.length())?str1:str2;
		min = (str1.length() < str2.length())?str1:str2;
		
		for( int i = 0; i < min.length(); i++ )
			for( int j = 0, k = min.length()-i; k != min.length()+1; j++,k++ )
			{
				String strTemp = min.substring(j,k);
				if( max.contains(strTemp) )
					return strTemp;
			}
		return "";
	}

12、字符串String和字符串缓冲区StringBuffer的区别是：

        a）：首先字符串的里面的内容是不可变的，意思就是当你调用String类中的方法对字符串本身进行操作时，比如replace操作，字符串本身并不发生变化，而是新开辟内存空间用来存储操作后的内容示例如下：

String s1 = "hello java";
		String s2 = s1.replace('a','n');
		
		System.out.println(s1);//打印结果是：hello java
		System.out.println(s2);//打印结果是：hello jnvn
		System.out.println(s1 == s2);//打印结果是：false

这说明，调用String类的方法，对字符串操作并不改变源字符串的内容，而是新开辟了一个空间用来存储操作后的内容；

        字符串缓冲区StringBuffer就不是这样了，它长度也可变。

StringBuffer s1 = new StringBuffer("hello java");
		StringBuffer s2 = s1.append(" !!! ");
		
		System.out.println(s1);//打印结果是hello java !!! 
		System.out.println(s2);//打印结果是：hello java !!! 
		System.out.println(s1 == s2);//打印结果是：true

这说明字符串缓冲区类中的方法是对原StringBuffer对象实体进行地操作。

13、字符串缓冲区的特点：

        a）：长度和内容可变；

        b）：可以操作多种数据；

        c）：最终要通过toString方法转换成字符串。

14、注意一下，StringBuffer类中的substring方法返回的是String而不是StringBuffer。

15、StringBuffer线程同步，StringBuider线程不同步。

16、java升级是为了改善这三方面的因素：

        a）：提高安全性；

        b）：提高效率；

        c）：简化书写；

17、基本数据类型包装类：

18、

Integer x = 4;//自动装箱，自动调用new Integer（int ...）的方法
		x = x + 3;//自动拆箱，先将右方x的值使用intValue()方法拿出来进行运算后，再装箱。

Integer x = 128;
		Integer x1 = 128;
		System.out.println(x == x1);//打印结果是：false
		
		Integer y = 127;
		Integer y1 = 127;
		System.out.println(y == y1);//打印结果是：true

第二段代码很奇特：同样都是数进行同样的操作，但是打印结果却不同！对于新特性，如果数值存在于byte范围内，且同样的对象已经存在，java就不会再为它开辟内存空间。