Java基础学习笔记13——（StringBuffer的使用，数组高级，Arrays工具类，Integer和Character等包装类）

1:StringBuffer(掌握)

(1)用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了 一个字符串缓冲区类。
StringBuffer供我们使用。
(2)StringBuffer的构造方法
A:StringBuffer()
B:StringBuffer(int size)
C:StringBuffer(String str)
(3)StringBuffer的常见功能
A:添加功能 —— public StringBuffer append(String str)
—— public StringBuffer insert(int offset,String str)
B:删除功能 —— public StringBuffer deleteCharAt(int index)
—— public StringBuffer delete(int start,int end)
C:替换功能 —— public StringBuffer replace(int start,int end,String str)
D:反转功能 —— public StringBuffer reverse()
E:截取功能(返回值是字符串) —— public String substring(int start)
—— public String substring(int start,int end)
(4)StringBuffer的相关练习

A:String和StringBuffer相互转换

		String -- StringBuffer
			构造方法
		StringBuffer -- String
			toString()方法

	package cn.itcast_07;
	/*
	 * 
	 * 为什么我们要讲解类之间的转换：
	 * A -- B 的转换
	 * 我们把A转换成B，其实是为了使用B的功能
	 * 我们可能要的结果是A类型，所以还得转回来
	 * 
	 * String 和 StringBuffer的相互转换
	 */
	public class StringBufferTest {
		public static void main(String[] args) {
			// String -- StringBuffer
			String s = "hello";
			// 注意：不能把字符串的值直接赋值给StringBuffer
			// StringBuffer sb = "hello";
			// StringBuffer sb = s;
			
			// 方式1:通过构造方法
			StringBuffer sb = new StringBuffer(s);
			// 方式2：通过append()方法
			StringBuffer sb2 = new StringBuffer();
			sb2.append(s);
			
			// StringBuffer -- String
			StringBuffer buffer = new StringBuffer("java");
			buffer.append(s);
			// String(StringBuffer buffer)
			// 方式1：通过构造方法
			String str = new String(buffer);
			// 方式2：通过toString()方法
			String str2 = buffer.toString();
			System.out.println("str:" + str);
			System.out.println("str2:" + str2);
		}
	}			

输出结果：
str: javahello
str2: javahello

B:字符串的拼接

	package cn.itcast_07;
	/*
	 * 把数组拼接成一个字符串
	 */
	public class StringBufferTest2 {
		public static void main(String[] args) {
			// 定义一个数组
			int[] arr = { 44, 33, 55, 11, 22 };
			// 定义功能
			// 方式1：用String做拼接的方式
			String s1 = arrayToString(arr);
			System.out.println("s1:" + s1);

			// 方式2：用StringBuffer做拼接的方式
			String s2 = arrayToString2(arr);
			System.out.println("s2:" + s2);

		}

		// 用StringBuffer做拼接的方式
		public static String arrayToString2(int[] arr) {
			StringBuffer sb = new StringBuffer();
			sb.append("[");
			for (int x = 0; x < arr.length; x++) {
				if (x == arr.length-1) {
					sb.append(arr[x]);
				} else {
					sb.append(arr[x]).append(", ");
				}
			}
			sb.append("]");
			return sb.toString();
		}

		// 用String做拼接的方式
		public static String arrayToString(int[] arr) {
			String s = "";

			s += "[";
			for (int x = 0; x < arr.length; x++) {
				if (x == arr.length - 1) {
					s += arr[x];
				} else {
					s += arr[x];
					s += ", ";
				}
			}
			s += "]";
			return s;
		}
	}			

C:把字符串反转

	package cn.itcast_07;
	import java.util.Scanner;
	/*
	 * 把字符串反转
	 */
	public class StringBufferTest3 {
		public static void main(String[] args) {
			// 键盘录入数据
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入数据：");
			String s = sc.nextLine();
	
			// 方式1：用String做拼接
			String s1 = myReverse(s);
			System.out.println("s1:" + s1);
			// 方式2：用StringBuffer的reverse（）功能
			String s2 = myReverse2(s);
			System.out.println("s2:" + s2);
		}
	
		// 用StringBuffer的reverse()功能
		public static String myReverse2(String s) {
	//		StringBuffer sb = new StringBuffer(s);
	//		sb.reverse();
	//		return sb.toString();
		
			return new StringBuffer(s).reverse().toString();
		}
		
		// 用String拼接
		public static String myReverse(String s) {
			String result = "";
			
			// 字符串转化成字符数组
			char[] chs = s.toCharArray();
			for (int x = chs.length - 1; x >= 0; x--) {
				result += chs[x];
			}
			return result;
		}
	}

D:判断一个字符串是否对称

	package cn.itcast_07;
	import java.util.Scanner;
	/*
	 * 判断一个字符串是否是对称字符串
	 * 例如 "abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm" 是对称字符串
	 * 
	 * 分析：
	 * 		判断一个字符串是否是对称的字符串，我们只需要把第一个和最后一个比较，第二个与倒数最后一个比较...
	 * 		比较的次数为长度除以2
	 */
	public class StringBufferTest4 {
		public static void main(String[] args) {
			// 创建键盘录入对象
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入一个字符串：");
			String s = sc.nextLine();
			
			// 一个一个的比较
			boolean b = isSame(s);
			System.out.println("b:" + b);
			
			// 用字符串缓冲区的反转功能
			boolean b2 = isSame(s);
			System.out.println("b2:" + b2);
		}
		
		public static boolean isSame2(String s) {
			return new StringBuffer(s).reverse().toString().equals(s);
		}
	
		public static boolean isSame(String s) {
			boolean flag = true;
			// 先把字符串转成字符数组
			char[] chs = s.toCharArray();
			
			for (int start = 0 ,end = chs.length-1; start <= end; start++, end--) {
				if (chs[start] != chs[end]) {
					flag = false;
					break;
				}
			}
			return flag;
		}
	}

(5)面试题

小细节：
	StringBuffer：同步的，数据安全，效率低。
	StringBuilder：不同步的，数据不安全，效率高。
A:String,StringBuffer,StringBuilder的区别
B:StringBuffer和数组的区别?

	package cn.itcast_08;
	/*
	 * 面试题：
	 * 1：String,StringBuffer,StringBuilder的区别？
	 * A：String是内容不可变的，而StringBuffer，StringBuilder都是内容可变的
	 * B：StringBuffer是同步的，数据安全，低效率的；StringBuilder是不同步的，数据不安全，效率高
	 * 
	 * 2：StringBuffer和数组的区别
	 * 二者都可以看做是一个容器，装其他的数据。
	 * 但是，StringBuffer的数据最终是一个字符串数据
	 * 而数组可以放置多种数据，但必须是同一种数据类型的
	 * 
	 * 3：形式参数问题
	 * String作为参数传递
	 * StringBuffer作为参数传递
	 * 
	 * 形式参数：
	 * 		基本类型：形式参数的改变不影响实际参数    String
	 * 		引用类型：形式参数的改变直接影响实际参数  StringBuffer
	 * 
	 * 注意：
	 * 		String作为参数传递，效果和基本类型作为参数传递一样
	 */
	public class StringBufferDemo {
		public static void main(String[] args) {
			String s1 = "hello";
			String s2 = "world";
			System.out.println(s1 + "----" + s2);  // hello----world
			change(s1,s2);
			System.out.println(s1 + "----" + s2);  // hello----world
			
			StringBuffer sb1 = new StringBuffer("hello");
			StringBuffer sb2 = new StringBuffer("world");
			System.out.println(sb1 + "----" + sb2);  // hello----world
			change(sb1,sb2);
			System.out.println(sb1 + "----" + sb2);  // hello----worldworld
		}
		
		public static void change(StringBuffer sb1,StringBuffer sb2) {
			sb1 = sb2;
			sb2.append(sb1);
		}
		
		public static void change(String s1 ,String s2) {
			s1 = s2;
			s2 = s1 + s2;
		}
	}

输出结果：
hello----world
hello----world
hello----world
hello----worldworld

(6)注意的问题：
String作为形式参数，StringBuffer作为形式参数。

2:数组高级以及Arrays(掌握)

(1)排序

A:冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。

	public static void bubbleSort(int[] arr) {
		for(int x=0; x<arr.length-1; x++) {
			for(int y=0; y<arr.length-1-x; y++) {
				if(arr[y] > arr[y+1]) {
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
				}
			}
		}
	}

B:选择排序
把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。

	public static void selectSort(int[] arr) {
		for(int x=0; x<arr.length-1; x++) {
			for(int y=x+1; y<arr.length; y++) {
				if(arr[y] < arr[x]) {
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
	}

(2)查找

A:基本查找
针对数组无序的情况

	public static int getIndex(int[] arr,int value) {
		int index = -1;
		
		for(int x=0; x<arr.length; x++) {
			if(arr[x] == value) {
				index = x;
				break;
			}
		}
		
		return index;
	}

B:二分查找(折半查找)
针对数组有序的情况(千万不要先排序，在查找)

	public static int binarySearch(int[] arr,int value) {
		int min = 0;
		int max = arr.length-1;
		int mid = (min+max)/2;
		
		while(arr[mid] != value) {
			if(arr[mid] > value) {
				max = mid - 1;
			}else if(arr[mid] < value) {
				min = mid + 1;
			}
			if(min > max) {
				return -1;
			}
			mid = (min+max)/2;
		}
		return mid;
	}

(3)Arrays工具类

A:是针对数组进行操作的工具类。包括排序和查找等功能。
B:要掌握的方法

把数组转成字符串：
排序：
二分查找：

C:把字符串中的字符进行排序
举例：

"edacbgf"
得到结果
"abcdefg"

	package cn.itcast_03;
	/*
	 * 把字符串中的字符进行排序
	 * 			举例："dacgebf"
	 * 			结果："abcdefg"
	 * 
	 * 分析：
	 * 		A：定义一个字符串
	 * 		B：把字符串转换为字符数组
	 * 		C：把字符数组进行排序
	 * 		D：把排序后的字符数组转成字符串
	 * 		E：输出最后的字符串
	 */
	public class ArrayTest {
		public static void main(String[] args) {
			// 定义一个字符串
			String s = "dacgebf";
			// 把字符串转换为字符数组
			char[] chs = s.toCharArray();
			// 把字符数组进行排序
			bubbleSort(chs);
			// 把排序后的字符数组转成字符串
			String result = String.valueOf(chs);
			// 输出最后的字符串
			System.out.println("result:" + result);
		}
		// 冒泡排序
		public static void bubbleSort(char[] chs) {
			for (int x = 0; x < chs.length - 1; x++) {
				for (int y = 0; y < chs.length - 1 - x; y++) {
					if (chs[y] > chs[y + 1]) {
						char temp = chs[y];
						chs[y] = chs[y + 1];
						chs[y + 1] = temp;
					}
				}
			}
		}
	}

(4)Arrays工具类的源码解析

	1.public static int binarySearch(int[] a,int key) 二分查找
		// Like public version, but without range checks.
		private static int binarySearch0(int[] a, int fromIndex, int toIndex,
										 int key) {
			int low = fromIndex;
			int high = toIndex - 1;

			while (low <= high) {
				int mid = (low + high) >>> 1;
				int midVal = a[mid];

				if (midVal < key)
					low = mid + 1;
				else if (midVal > key)
					high = mid - 1;
				else
					return mid; // key found
			}
			return -(low + 1);  // key not found.
		}
		
	 2.public static String toString(int[] a) 把数组转成字符串
			public static String toString(int[] a) {
			if (a == null)
				return "null";
			int iMax = a.length - 1;
			if (iMax == -1)
				return "[]";

			StringBuilder b = new StringBuilder();
			b.append('[');
			for (int i = 0; ; i++) {
				b.append(a[i]);
				if (i == iMax)
					return b.append(']').toString();
				b.append(", ");
			}
		}

3:Integer(掌握)

(1)为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型

byte 		Byte
short		Short
int			Integer
long		Long
float		Float
double		Double
char		Character
boolean		Boolean

(2)Integer的构造方法

A:Integer i = new Integer(100);

B:Integer i = new Integer("100");
	注意：这里的字符串必须是由数字字符组成

(3)String和int的相互转换

    A:String -- int
    	Integer.parseInt("100");
    B:int -- String
    	String.valueOf(100);

(4)其他的功能(了解)
进制转换

(5)JDK5的新特性
自动装箱 基本类型–引用类型
自动拆箱 引用类型–基本类型

把下面的这个代码理解即可：
	Integer i = 100;
	i += 200;
	System.out.println("ii:" + ii);
	
    // 通过反编译后的代码
    //		Integer ii = Integer.valueOf(100);  // 自动装箱
    //		ii = Integer.valueOf(ii.intValue() + 200);  // 自动拆箱，再自动装箱 
    //		System.out.println((new StringBuilder("ii:")).append(ii).toString()); 
    //		Integer iii = null;

(6)面试题
-128到127之间的数据缓冲池问题

	package cn.itcast_06;
	/*
	 * 看程序写结果
	 * 
	 * 注意：Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据
	 */
	public class IntegerDemo {
		public static void main(String[] args) {
			Integer i1 = new Integer(127);
			Integer i2 = new Integer(127);
			System.out.println(i1 == 12);
			System.out.println(i1.equals(i2));
			System.out.println("-----------");
			
			Integer i3 = new Integer(128);
			Integer i4 = new Integer(128);
			System.out.println(i3 == i4);
			System.out.println(i3.equals(i4));
			System.out.println("----------");
			
			Integer i5 = 128;
			Integer i6 = 128;
			System.out.println(i5 == i6);
			System.out.println(i5.equals(i6));
			System.out.println("----------");
			
			Integer i7 = 127;
			Integer i8 = 127;
			System.out.println(i7 == i8);
			System.out.println(i7.equals(i8));
			System.out.println("----------");
			// 通过查看源码，我们知道了，针对-128到127之间的数据，做了一个数据缓冲池，如果数据在该范围内，每次并不创建新的空间
			// Integer ii = Integer.valueOf(127);
		}
	}

4:Character(了解)

(1)Character构造方法
Character ch = new Character(‘a’);
(2)要掌握的方法：(自己补齐)
A:判断给定的字符是否是大写:public static boolean isUpperCase(char ch)
B:判断给定的字符是否是小写:public static boolean isLowerCase(char ch)
C:判断给定的字符是否是数字字符:public static boolean isDigit(char ch)
D:把给定的字符转成大写:public static char toUpperCase(char ch)
E:把给定的字符转成小写:public static char toLowerCase(char ch)
(3)案例：
统计字符串中大写，小写及数字字符出现的次数

	package cn.itcast_03;
	import java.util.Scanner;
	/*
	 * 统计一个字符串中大写字符字符，小写字母字符，数字字符出现的次数。（不考虑其他字符）
	 * 
	 * 分析：
	 * 		A:定义三个统计变量。
	 * 			int bigCount = 0;
	 * 			int smallCount = 0;
	 * 			int numberCount = 0;
	 * 		B:键盘录入一个字符串
	 * 		C：把字符串转换为字符数组
	 * 		D：遍历字符数组获取到每一个字符
	 * 		E：判断该字符是
	 * 			大写	bigCount++;
	 * 			小写 	smallCount++;
	 * 			数字	numberCount++;
	 * 		F：输出结果即可
	 */
	public class CharacterTest {
		public static void main(String[] args) {
			// 定义三个统计变量
			int bigCount = 0;
			int smallCount = 0;
			int numberCount = 0;
			// 键盘录入一个字符串
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入一个字符串：");
			String line = sc.nextLine();
			// 把字符串转换为字符数组
			char[] chs = line.toCharArray();
			
			// 遍历字符数组获取到每一个字符
			for(int x=0; x<chs.length; x++) {
				char ch = chs[x];
				
				//判断该字符
				if(Character.isUpperCase(ch)) {
					bigCount++;
				} else if (Character.isLowerCase(ch)) {
					smallCount++;
				} else if(Character.isDigit(ch)) {
					numberCount++;
				}
			}
			// 输出结果即可
			System.out.println("大写字母：" + bigCount + "个");
			System.out.println("小写字母：" + smallCount + "个");
			System.out.println("数字字符：" + numberCount + "个");
		}
	}