毕向东Java视频学习笔记【Day15 字符串+StringBuffer+StringBuilder类基础】

.01 string类特点

String类的特点：

字符串对象一旦被初始化就不可以被改变。 而 StringBuffer和 StringBuilder类可以改变缓冲区 更加灵活

 

面试题

String s = “abc”;

String s1 = NEW String (“abc”);

System.out.println(s==s1); 输出false表示这两个字符串地址是不是相等的，为什么？

答：第一个是在字符串常量池中创建了abc字符串并且赋给了引用型变量s

第二个是在堆内存中用new的方式创建了string对象 并且在new的时候接受了一个字符串abc

（创建两个对象一个new一个字符串对象在堆内存中）

第一个产生一个对象

第二个产生两个对象

  

在常量池中是可以被共享的  而第二个不能共享

String类中的equals复写object中的equals建立了string类自己判断字符串相同的方法

其实就是比较字符串内容

package day15;
public class StringDemo {
	public static void main(String[] args) {
		/*
		 * String类的特点：
		 * 字符串对象一旦被初始化就不会被改变。
		 */
		stringDemo1();
		System.out.println();
		stringDemo2();
	}
	public static void stringDemo2() {
		// TODO Auto-generated method stub
		
		String s = "abc";//创建一个字符串对象在常量池中。		
		String s1 = new String("abc");//创建两个对象一个new一个字符串对象在堆内存中。
		System.out.println(s==s1);//false
		System.out.println(s.equals(s1));//true
		//string类中的equals复写Object中的equals建立了string类自己的判断字符串对象是否相同的依据。
		//其实就是比较字符串内容。
	}
	/*
	 * 演示字符串定义的第一种方式，并明确字符串常量池的特点.
	 * 池中没有就建立，池中有，直接用。
	 */
	private static void stringDemo1() {
		String s = "abc"; //"abc"存储在字符串常量池中。
		String s1 = "abc";		
		System.out.println(s==s1);//true
	}

}

 

.02string 类  构造函数

package day15;

public class StringConstructorDemo {

	public static void main(String[] args) {
		stringConstructorDemo2();
	}
	
	private static void stringConstructorDemo2() {
		char[] arr = {'w','a','p'};
		String s2 = new String(arr);
		System.out.println("s2="+s2);
	}

	public static void stringConstructorDemo(){
		@SuppressWarnings("unused")
		String s = new String();//等效于stirng s = "";不等string s = null;
		byte[] arr ={65,66,67,68};
		String s1 = new String(arr);
		System.out.println("s1="+s1);
	}
}

.03String类常见方法 获取

 

/*

 * 按照面向对象的思想对字符串进行功能分类。

 * "abcd"

 *

 * 1,获取：

 * 1.1 获取字符串中字符的个数(长度).

 * int length();

 * 1.2 根据位置获取字符。

 * char charAt(int index);

 * 1.3 根据字符获取在字符串中的第一次出现的位置.

 * int indexOf(int ch)

 * int indexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置

 * int indexOf(String str);

 * int indexOf(String str,int fromIndex);

 *  根据字符串获取在字符串中的第一次出现的位置.

 * int lastIndexOf(int ch)

 * int lastIndexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置

 * int lastIndexOf(String str);

 * int lastIndexOf(String str,int fromIndex);

 * 1.4 获取字符串中一部分字符串。也叫子串.

 * String substring(int beginIndex, int endIndex)//包含begin不包含end。

 * String substring(int beginIndex);

 *

 *

 *

 * 2，转换。

 * 2.1 将字符串变成字符串数组(字符串的切割)

 * String[]  split(String regex):涉及到正则表达式.

 * 2.2 将字符串变成字符数组。

 * char[] toCharArray();

 * 2.3 将字符串变成字节数组。

 * byte[] getBytes();

 * 2.4 将字符串中的字母转成大小写。

 * String toUpperCase():大写

 * String toLowerCase():小写

 * 2.5  将字符串中的内容进行替换

 * String replace(char oldch,char newch);

 * String replace(String s1,String s2);

 * 2.6 将字符串两端的空格去除。

 * String trim();

 * 2.7 将字符串进行连接 。

 * String concat(string);

 *

 * 3，判断

 * 3.1 两个字符串内容是否相同啊？

 * boolean equals(Object obj);

 * boolean equalsIgnoreCase(string str);忽略大写比较字符串内容。

 * 3.2 字符串中是否包含指定字符串？

 * boolean contains(string str);

 * 3.3 字符串是否以指定字符串开头。是否以指定字符串结尾。

 * boolean startsWith(string);

 * boolean endsWith(string);

 *

 * 4，比较。

 *

 */

对字符串进行方法处理以后，他会赋给一个新的字符串 不再是之前那一个字符串的地址（不再是之前那个字符串常量池中的字符串）

package day15;



public class StringMethodDemo {
	public static void main(String[] args) {

		stringMethodDemo_4();
		
//		System.out.println("abc".concat("kk"));
//		System.out.println("abc"+"kk");
		
//		System.out.println(String.valueOf(4)+1);
//		System.out.println(""+4+1);
		
	}

	private static void stringMethodDemo_4() {
		
		System.out.println("abc".compareTo("aqz"));
	}

	@SuppressWarnings("unused")
	private static void stringMethodDemo_3() {
		String s = "abc";
		System.out.println(s.equals("ABC".toLowerCase()));
		System.out.println(s.equalsIgnoreCase("ABC"));
		
		System.out.println(s.contains("cc"));
		
		String str  = "ArrayDemo.java";
		
		System.out.println(str.startsWith("Array"));
		System.out.println(str.endsWith(".java"));
		System.out.println(str.contains("Demo"));
	}

	@SuppressWarnings("unused")
	private static void stringMethodDemo_2() {
		
		String  s = "张三,李四,王五";
		String[] arr = s.split(",");
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
		char[] chs = s.toCharArray();
		
		for (int i = 0; i < chs.length; i++) {
			System.out.println(chs[i]);
		}
		s = "ab你";
		byte[] bytes = s.getBytes();
		for (int i = 0; i < bytes.length; i++) {
			System.out.println(bytes[i]);
		}
		
		System.out.println("Abc".toUpperCase());
		
		
		String s1 = "java";
		String s2 = s1.replace('q', 'z');
		System.out.println(s1==s2);//true
		
		System.out.println("-"+"    ab  c    ".trim()+"-");
		
	}

	@SuppressWarnings("unused")
	private static void stringMethodDemo_1() {
		
		String  s = "abcdae";
		
		System.out.println("length:"+s.length());//6
		System.out.println("char:"+s.charAt(2));//c//StringIndexOutOfBoundsException
		System.out.println("index:"+s.indexOf('k'));//0//-1 我们可以根据-1，来判断该字符或者字符串是否存在。
		System.out.println("lastIndex:"+s.lastIndexOf('a'));//4
		
		
		System.out.println("substring:"+s.substring(2,4));
	}

}

注意：System.out.println("index:"+s.indexOf('k'));//0//-1 我们可以根据-1，来判断该字符或者字符串是否存在。返回-1，该字符不存在

String Buffer类
* StringBuffer:就是字符串缓冲区。 用于存储数据的容器。 

StringBuffer 的默认初始容量为 16字节的数组   如果不够 会自动增长 新数组的大小为2*（旧数组长度+1）

当然StringBuffer（）提供了重载函数 可以直接在括号输入字节长度，有些时候，比默认的StringBuffer更节约时间

如果自己开的字符数组容量过大，会浪费内存空间，可以使用trimToSize（）将容量降低到实际的大小
* 特点： 
* 1，长度的可变的。 
* 2，可以存储不同类型数据。
* 3，最终要转成字符串进行使用。 
* 4，可以对字符串进行修改。
* 
* 既然是一个容器对象。应该具备什么功能呢？
* 
*  1，添加：
*   StringBuffer append(data);
*   StringBuffer insert(index,data);
*   
*  2，删除： 
*   StringBuffer delete(start,end):包含头，不包含尾。
*   StringBuffer deleteCharAt(int index):删除指定位置的元素 
*   
*  3，查找：
*   char charAt(index); 
*   int indexOf(string); 
*   int lastIndexOf(string); 
*   
*  4，修改：
*   StringBuffer replace(start,end,string); 
*   void setCharAt(index,char);
* 
*  增删改查 C(create)U(update)R(read)D(delete)
*/

.

package day15;
public class StringBufferDemo {
	public static void main(String[] args) {
		bufferMethodDemo_2();
	}
	private static void bufferMethodDemo_2() {
		StringBuffer sb = new StringBuffer("abce");
		// sb.delete(1, 3);//ae
		// 清空缓冲区。
		// sb.delete(0,sb.length());
		// sb = new StringBuffer();
		// sb.replace(1, 3, "nba");
		// sb.setCharAt(2, 'q');
		// sb.setLength(10);
		// System.out.println("sb:"+sb);
		// System.out.println("len:"+sb.length());
		System.out.println(sb.reverse());
	}
	@SuppressWarnings("unused")
	private static void bufferMethodDemo_1() {
		StringBuffer sb = new StringBuffer("abce");

		// sb.append("xixi");
		sb.insert(2, "qq");

		System.out.println(sb.toString());
	}
	public static void bufferMethodDemo() {
		// 创建缓冲区对象。
		StringBuffer sb = new StringBuffer();
		sb.append(4).append(false);// .append("haha");
		sb.insert(1, "haha");
		// sb.append(true);
		System.out.println(sb);
	}
}

String Builder类

/*
* jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder
* 
* 不同的是：
* StringBuffer是线程同步的。通常用于多线程。
* StringBuilder是线程不同步的。通常用于单线程。 它的出现提高效率。
* 
* jdk升级：
* 1，简化书写。
* 2，提高效率。
* 3，增加安全性。
*/