StringBuffer类和包装类

1. StringBuffer类的概述
* A:StringBuffer类概述
        * 通过JDK提供的API，查看StringBuffer类的说明
        * 线程安全的可变字符序列 
* B:StringBuffer和String的区别
        * String是一个不可变的字符序列
        * StringBuffer是一个可变的字符序列 
2. StringBuffer类的构造方法
* A:StringBuffer的构造方法：
        * public StringBuffer():无参构造方法
        * public StringBuffer(int capacity):指定容量的字符串缓冲区对象
        * public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
* B:StringBuffer的方法：
        * public int capacity()：返回当前容量。 理论值(不掌握)
        * public int length():返回长度（字符数）。 实际值

StringBuffer sb = new StringBuffer();
System.out.println(sb.length());			//容器中的字符个数,实际值
System.out.println(sb.capacity());			//容器的初始容量,理论值

StringBuffer sb2 = new StringBuffer(10);
System.out.println(sb2.length());
System.out.println(sb2.capacity());

StringBuffer sb3 = new StringBuffer("heima");
System.out.println(sb3.length());			//实际字符的个数
System.out.println(sb3.capacity());			//字符串的length + 初始容量

3. StringBuffer的添加功能
* A:StringBuffer的添加功能
        * public StringBuffer append(String str):
                * 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
        * public StringBuffer insert(int offset,String str):
                * 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
4. StringBuffer的删除功能
* A:StringBuffer的删除功能
        * public StringBuffer deleteCharAt(int index):
                * 删除指定位置的字符，并返回本身
        * public StringBuffer delete(int start,int end):
                * 删除从指定位置开始指定位置结束的内容，并返回本身
5. StringBuffer的替换和反转功能
* A:StringBuffer的替换功能
        * public StringBuffer replace(int start,int end,String str):
                * 从start开始到end用str替换
* B:StringBuffer的反转功能
         * public StringBuffer reverse():
                * 字符串反转
6. StringBuffer的截取功能及注意事项
* A:StringBuffer的截取功能
        * public String substring(int start):
                * 从指定位置截取到末尾

        * public String substring(int start,int end):

               * 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

7. StringBuffer和String的相互转换
* A:String -- StringBuffer
        * a:通过构造方法
        * b:通过append()方法
* B:StringBuffer -- String
        * a:通过构造方法
        * b:通过toString()方法
        * c:通过subString(0,length);

public class Demo7_StringBuffer {
	/**
	 * * A:形式参数问题
			* String作为参数传递
			* StringBuffer作为参数传递 
		* B:案例演示
			* String和StringBuffer分别作为参数传递问题
			* 
	基本数据类型的值传递,不改变其值
	引用数据类型的值传递,改变其值
	
	String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的
	 */
	public static void main(String[] args) {
		String s = "heima";
		System.out.println(s);
		change(s);
		System.out.println(s);
			
		System.out.println("---------------------");
		StringBuffer sb = new StringBuffer();
		sb.append("heima");
		System.out.println(sb);
		change(sb);
		System.out.println(sb);
	}

	public static void change(StringBuffer sb) {
		sb.append("itcast");
	}

	public static void change(String s) {
		s += "itcast";
	}
}

7. 把数组转成字符串

public class Test1 {
	/**
	 * * 需求：把数组中的数据按照指定个格式拼接成一个字符串
	* 
			举例：
				int[] arr = {1,2,3};	
			输出结果：
				"[1, 2, 3]"
				
			用StringBuffer的功能实现
	 */
	public static void main(String[] args) {
		int[] arr = {1,2,3};
		System.out.println(arrayToString(arr));
	}


	/*
	 * 将数组转换为字符串
	 * 1,返回值类型String
	 * 2,参数列表int[]
	 * 
	 * arrayToString 将数组转换为字符串
	 * array2String		2与to的发音一样就用2替换了to,后来演变成了一种书写习惯
	 * dom4j  domForJ
	 */
	
	public static String arrayToString(int[] arr) {
		StringBuffer sb = new StringBuffer();				//创建字符串缓冲区对象
		sb.append("[");										//将[添加到缓冲区
		
		
		//{1,2,3}
		for (int i = 0; i < arr.length; i++) {				//遍历数组
			//sb.append(arr[i] + ", ");						//这样做没有]
			if(i == arr.length - 1) {
				sb.append(arr[i]).append("]");				//[1, 2, 3]
			}else {
				sb.append(arr[i]).append(", ");				//[1, 2,
			}
		}
		return sb.toString();
	}
}

8. 字符串反转

public class Test2 {
	/**
	 * * A:案例演示
	* 
			需求：把字符串反转
				举例：键盘录入"abc"		
				输出结果："cba"
				
			用StringBuffer的功能实现	
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);				//创建键盘录入对象
		String line = sc.nextLine();						//将键盘录入的字符串存储在line中
		
		/*StringBuffer sb = new StringBuffer(line);			//将字符串转换为StringBuffer对象
		sb.reverse();										//将缓冲区的内容反转
		
		System.out.println(sb.toString());*/
		
		System.out.println(revString(line));
	}
	/*
	 * 将字符串反转
	 * 1,返回值类型String
	 * 2,参数列表String line
	 */
	
	public static String revString(String line) {
		StringBuffer sb = new StringBuffer(line);			//将字符串转换为StringBuffer对象
		sb.reverse();										//将缓冲区的内容反转
		
		return sb.toString();
	}
}

9. StringBuffer和StringBuilder的区别
* A:StringBuilder的概述
        * 通过查看API了解一下StringBuilder类
* B:面试题
        * String,StringBuffer,StringBuilder的区别
        * StringBuffer和StringBuilder的区别
        * StringBuffer是jdk1.0版本的,是线程安全的,效率低
        * StringBuilder是jdk1.5版本的,是线程不安全的,效率高

        * String和StringBuffer,StringBuilder的区别

        * String是一个不可变的字符序列
        * StringBuffer,StringBuilder是可变的字符序列
10 String和StringBuffer分别作为参数传递
* A:形式参数问题
        * String作为参数传递
        * StringBuffer作为参数传递 
* B:案例演示
        * String和StringBuffer分别作为参数传递问题
11 Arrays类的概述和方法使用
* A:Arrays类概述
        * 针对数组进行操作的工具类。
        * 提供了排序，查找等功能。
* B:成员方法
        * public static String toString(int[] a)
        * public static void sort(int[] a)
        * public static int binarySearch(int[] a,int key)
12 基本类型包装类的概述
* A:为什么会有基本类型包装类
        * 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
* B:常用操作
       * 常用的操作之一：用于基本数据类型与字符串之间的转换。
* C:基本类型和包装类的对应
* 

		byte 			Byte
		short			Short
		int				Integer
		long			Long
		float			Float
		double			Double
		char			Character
		boolean			Boolean
public class Demo1_Integer {
	public static void main(String[] args) {
		System.out.println(Integer.toBinaryString(60));
		System.out.println(Integer.toOctalString(60));
		System.out.println(Integer.toHexString(60));
	}
}

13 Integer类的概述和构造方法
* A:Integer类概述
        * 通过JDK提供的API，查看Integer类的说明
        * Integer 类在对象中包装了一个基本类型 int 的值,
        * 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
        * 还提供了处理 int 类型时非常有用的其他一些常量和方法
* B:构造方法
        * public Integer(int value)
        * public Integer(String s)

public class Demo2_Integer {
	public static void main(String[] args) {
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);
		
		Integer i1 = new Integer(100);
		System.out.println(i1);
		
		//Integer i2 = new Integer("abc");			//java.lang.NumberFormatException数字格式异常
		//System.out.println(i2);						//因为abc不是数字字符串,所以转换会报错
		
		Integer i3 = new Integer("100");
		System.out.println(i3);
	}
}

14. String和int类型的相互转换
* A:int -- String
        * a:和""进行拼接
        * b:public static String valueOf(int i)
        * c:int -- Integer -- String(Integer类的toString方法())
        * d:public static String toString(int i)(Integer类的静态方法)
* B:String -- int
        * a:String -- Integer -- int
        * public static int parseInt(String s)

public class Demo3_Integer {
	/**
	 * * A:int -- String
			* a:和""进行拼接
			* b:public static String valueOf(int i)
			* c:int -- Integer -- String(Integer类的toString方法())
			* d:public static String toString(int i)(Integer类的静态方法)
		* B:String -- int
			* a:String -- Integer -- int
				* public static int parseInt(String s)
		基本数据类型包装类有八种,其中七种都有parseXxx的方法,可以将这七种的字符串表现形式转换成基本数据类型
	 */
	public static void main(String[] args) {
		
		//demo1();
		String s1 = "true";
		boolean b = Boolean.parseBoolean(s1);
		System.out.println(b);
		
		//String s2 = "abc";
		//char c = Character.p		//char的包装类Character中没有pareseXxx的方法
									//字符串到字符的转换通过toCharArray()就可以把字符串转换为字符数组
	}

	private static void demo1() {
		//int ----> String int转换成String
		int i = 100;
		String s1 = i + "";						//推荐用
		String s2 = String.valueOf(i);			//推荐用
		
		Integer i2 = new Integer(i);
		String s3 = i2.toString();
		
		String s4 = Integer.toString(i);
		System.out.println(s1);
		
		//String----> int String 转换int
		String s = "200";
		Integer i3 = new Integer(s);
		int i4 = i3.intValue();					//将Integer转换成了int数
		
		int i5 = Integer.parseInt(s);			//将String转换为int,推荐用这种
	}
}

15. JDK5的新特性自动装箱和拆箱
* A:JDK5的新特性
        * 自动装箱：把基本类型转换为包装类类型
        * 自动拆箱：把包装类类型转换为基本类型
* B:案例演示
        * JDK5的新特性自动装箱和拆箱
        * Integer ii = 100;
        * ii += 200;
* C:注意事项
        * 在使用时，Integer  x = null;代码就会出现NullPointerException。
        * 建议先判断是否为null，然后再使用

public class Demo4_JDK5 {
	/**
	 * * A:JDK5的新特性
			* 自动装箱：把基本类型转换为包装类类型
			* 自动拆箱：把包装类类型转换为基本类型
		* B:案例演示
			* JDK5的新特性自动装箱和拆箱
			
			* Integer ii = 100;
			* ii += 200;
		* C:注意事项
			* 在使用时，Integer  x = null;代码就会出现NullPointerException。
			* 建议先判断是否为null，然后再使用。
	 */
	public static void main(String[] args) {
//		int x = 100;
//		Integer i1 = new Integer(x);			//将基本数据类型包装成对象,装箱
//		
//		int y = i1.intValue();					//将对象转换为基本数据类型,拆箱
		
		Integer i2 = 100;						//自动装箱,把基本数据类型转换成对象
		int z = i2 + 200;						//自动拆箱,把对象转换为基本数据类型
		System.out.println(z);
		
		Integer i3 = null;
		int a = i3 + 100;						//底层用i3调用intValue,但是i3是null,null调用方法就会出现
		System.out.println(a);					//空指针异常java.lang.NullPointerException
	}


}

16. Integer的面试题

public class Demo5_Integer {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Integer i1 = new Integer(97);
		Integer i2 = new Integer(97);
		System.out.println(i1 == i2);				//false
		System.out.println(i1.equals(i2));			//true
		System.out.println("-----------");
	
		Integer i3 = new Integer(197);
		Integer i4 = new Integer(197);
		System.out.println(i3 == i4);				//false
		System.out.println(i3.equals(i4));			//true
		System.out.println("-----------");
	
		Integer i5 = 127;
		Integer i6 = 127;
		System.out.println(i5 == i6);				//true
		System.out.println(i5.equals(i6));			//true
		System.out.println("-----------");
	
		Integer i7 = 128;
		Integer i8 = 128;
		System.out.println(i7 == i8);
		System.out.println(i7.equals(i8));			//true
		
		/*
		 * -128到127是byte的取值范围,如果在这个取值范围内,自动装箱就不会新创建对象,而是从常量池中获取
		 * 如果超过了byte取值范围就会再新创建对象
		 * 
		 * public static Integer valueOf(int i) {
		        assert IntegerCache.high >= 127;
		        if (i >= IntegerCache.low && i <= IntegerCache.high)			//i>= -128 && i <= 127
		            return IntegerCache.cache[i + (-IntegerCache.low)];
		        return new Integer(i);
		    }
		 */
	}


}