常见对象中的问题3

常见对象中的问题3

13.01StringBuffer的概述

StringBuffer类的概述
	我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，即耗时，
	又浪费空间。而StringBuffer就可以解决这个问题
	
	线程安全的可变字符序列
StringBuffer和String的区别？
构造方法：
	public StringBuffer()
	public StringBuffer(in capacity)
	public StringBuffer(String str)

 线程安全（）
 安全--同步--数据是安全的
 不安全--不同步-效率高一些
 安全：医院的网站，银行网站
 效率：新闻网站，论坛之类
 
 StringBuffer
 	线程安全的可变字符串
 	
 StringBuffer和String的区别？
 前者长度和内容可变，后者不可变
 如果使用前者做字符串的拼接不会浪费太多资源

## 13.02StringBufferer类的构造方法
构造方法：
	public StringBuffer()
	public StringBuffer(in capacity)
	public StringBuffer(String str)
public class StringBufferDemo {
	public static void main(String[] args) {
		//public StringBuffer()：无参构造方法
		StringBuffer sb = new StringBuffer();
		System.out.println("sb:" + sb);
		System.out.println("sb.capacity():" +sb.capacity());//默认容量为16
		System.out.println("sb.length():"+sb.length());
		System.out.println("----------------");
		
		//public StringBuffer(in capacity)：指定容量的字符串缓冲区对象
		StringBuffer sb2 = new StringBuffer(50);//指定容量50
		System.out.println("sb2:" +sb2);
		System.out.println("sb2.capacity:" +sb2.capacity());
		System.out.println("sb2.length():" +sb2.length());
		System.out.println("---------------");
		
		//public StringBuffer(String str)：指定字符串内容的字符串缓冲区对象
		StringBuffer sb3 = new StringBuffer("hello");
		System.out.println("sb3:" +sb3.capacity());
		System.out.println("sb3:" +sb3.length());
		System.out.println("---------------");
	}
}

13.03添加功能

/*StringBuffer的添加功能：
 public StringBuffer append(String str):可以把任意类型数据添加到字符缓冲区里面，并返回字符串缓冲区本身
 public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身

	*/
public class StringBufferDemo {
	public static void main(String[] args) {
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		
		//public StringBuffer append(String str);
		StringBuffer sb2 = sb.append("hello");
		System.out.println("sb:" +sb);
		System.out.println("sb2:" +sb2);
		System.out.println(sb == sb2);//true
		
		//一步一步添加数据
		sb.append("hello");
		sb.append(true);
		sb.append(12);
		sb.append(34.56);
		System.out.println("sb:" +sb);
		
		
		//链式编程
		sb.append(true).append("hello").append(12).append(34.56);
		System.out.println("sb:" +sb);
		
		
		//public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身
		sb.insert(5, "java");
		System.out.println("sb:"+sb);
	}
}

13.04StringBuffer的删除功能

/*
 StringBuffer的删除功能
 public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
 public StringBuffer delete(int start,int end):删除指定位置从起始到结尾的部分并返回本身
 
 */
public class StringBufferDemo {
	public static void main(String[] args) {
		//public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
		StringBuffer sb = new StringBuffer("woshiyigedagege");
		sb.deleteCharAt(2);
		System.out.println("删除后的:" +sb);
		//public StringBuffer delete(int start,int end):删除指定位置从起始到结尾的部分并返回本身
		sb.delete(0, 5);
		System.out.println("删除后的:" +sb);
		//删除所有数据
		sb.delete(0, sb.length());
		System.out.println("删除后的:" +sb);
		
}
}

13.05StringBuffer的替换功能

/*
 StringBuffer的替换功能：
 public StringBuffer replace(int start, int end, String str)
 从start开始到end用str替换
 
 
 */
public class StringBufferDemo {

	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		//添加数据
		sb.append("hello");
		sb.append("world");
		sb.append("java");
		
		//public StringBuffer replace(int start, int end, String str)
		//需求：我们要把这个world这个数据替换为节日快乐
		sb.replace(5, 10, "节日快乐");
		System.out.println(sb);
		
	}

}

13.06StringBuffer的反转功能

public class StringBufferDemo {

	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		//添加数据
		sb.append("hello");
		sb.append("world");
		sb.append("java");
		
		//public StringBuffer replace(int start, int end, String str)
		//需求：我们要把这个world这个数据替换为节日快乐
		sb.replace(5, 10, "节日快乐");
		sb.append("急得我看是总复习");
		System.out.println(sb);
		
		sb.reverse();
		System.out.println(sb);
	}

}

13.07StringBuffer的截取功能

/*
 截取功能：
 public String substring(int start)（截取int之前的内容）
 public String substring(int start,int end)（截取起始到结尾，输出截取中间的内容）
 
 */
public class StringBufferDemo {

	public static void main(String[] args) {
	//创建字符串缓冲区对象
	StringBuffer sb = new StringBuffer();
	//添加元素
	sb.append("hello").append("world").append("java");
	System.out.println("sb: " +sb);
	
	
	//截取功能
	//public String substring(int start)（截取int之前的内容,输出不包括的）
	String s =sb.substring(5);
	System.out.println(s);
	//public String substring(int start,int end)（截取起始到结尾，输出截取中间的内容）要哪截哪
	String ss = sb.substring(5, 10);
	System.out.println(ss);
	}

}

13.08StringBuffer的相互转换功能

/*
 为什么我们要讲类之间的转换
 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);
		System.out.println("sb:" +sb);
		System.out.println("sb2:" +sb2);
		System.out.println("---------------");
		//StringBuffer -- String
		StringBuffer buffer = new StringBuffer("java");
		//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);
	}

}

13.09把数组拼接成指定格式的字符串案例

public class StringBufferTest1 {

	public static void main(String[] args) {
		//定义一个数组
		int[] arr = { 44, 33,55,11,22};
		//定义功能
		//方式1：用String做拼接的方式
		String s1 = arrayToString(arr);
		System.out.println(s1);
		
		String s2 = arrayToString(arr);
		System.out.println(s2);
	}
		//方式2：用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]);
					sb.append(", ");
				}
			}
			sb.append("]");
			return sb.toString();
		
	}
	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;
	}

}

运行结果
[44, 33, 55, 11, 22]
[44, 33, 55, 11, 22]

13.11判断一个字符串是否对称案例

import java.util.Scanner;

/*
判断一个字符串是否对称案例

分析：
	判断一个字符串是否是对称的字符串，我只需要把
		第一个和最后一个比较
		第二个和倒数第二个比较
		。。。
		比较的次数是长度除以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);
		//调用
		boolean c = isSame2(s);
		System.out.println(c);
	}
	//方式一
//	public static boolean siSame(String s) {
//		//把字符串转成字符数组
//		char[] chs = s.toCharArray();
//		for(int start = 0, end = chs.length - 1;start <= end;start++,end--) {
//			if(chs[start] != chs[end]) {
//				return false;
//			}
//		}
//				return true;
//		}
	
	//方式二
	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;
		}
	//方式三用字符串缓冲区的反转功能
	public static boolean isSame2(String s) {
		return new StringBuffer(s).reverse().toString().equals(s);
	}
	
}

13.12String和StringBuffer区别

/*
1.String,StringBuffer,StringBuilder的区别？
A:String的内容是不可变的，而StringBuffer,StringBuilder都是内容可变的
B:StringBuffer是同步的，数据安全，效率低；StringBuilder是不同步的，数据不安全，效率高

2.StringBuffer和数组的区别？/
二者都可以看出是一个容器，装其他的数据。
但是呢,StringBuffer的数据最终是一个字符串类型
而数组可以防止多种数据，但必须是同一种数据类型的

3.形式参数问题
String作为参数传递
StringBuffere作为参数传递
*/

13.13String和StringBuffer分别作为形式参数传递

形式参数：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数

注意;
String作为参数传递，效果和基本类型作为参数传递是一样的。

13.14数组高级冒泡排序原理图解

排序
冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
选择排序
从0索引开始，一次和后面元素比较。小的往前方，第一次完毕，最小值出现在了最小索引处
查找
基本查找 数组元素无序
二分查找 数组元素有序

规律：
1.两两比较，大的往后放
2.第一季比较完毕后，下一次比较的时候就会减少一个元素的比较
3.第一次比较，有0个元素不比
4.第二次比较有一个元素不比
。。。。
4.总共需要比较数组长度-1次

13.15数组高级冒泡排序代码

/*
 数组排序之冒泡排序;
 	相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。
 	
 */
public class ArrayDemo {

	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 24, 69, 25, 13, 66 };
		//调用
		System.out.println("排序前：");
		printArray(arr);
		
		
/*
		//第一次比较
		//为了防止数据越界
		for(int x = 0;x <arr.length-1;x++) {
			if(arr[x] > arr[x +1]) {
				int temp = arr[x];
				arr[x] = arr[x+1];
				arr[x +1] = temp;
			}
		}
		System.out.println("第一次排序后的：");
		printArray(arr);
		
		//第二次比较
		//array.length-1为了防止数据越界
		//arr.length-1-1是为了减少判断次数不判断最后一个元素
		for(int x = 0;x <arr.length-1-1;x++) {
			if(arr[x] > arr[x +1]) {
				int temp = arr[x];
				arr[x] = arr[x+1];
				arr[x +1] = temp;
			}
		}
		System.out.println("第二次排序后的：");
		printArray(arr);
		
		//第三次比较
				//array.length-1为了防止数据越界
				//arr.length-1-2是为了减少判断次数不判断最后一个元素
				for(int x = 0;x <arr.length-1-2;x++) {
					if(arr[x] > arr[x +1]) {
						int temp = arr[x];
						arr[x] = arr[x+1];
						arr[x +1] = temp;
					}
				}
				System.out.println("第三次排序后的：");
				printArray(arr);
*/
		
		//改进版
		/*
		for(int y = 0 ;y<arr.length-1;y++) {
			for(int x = 0;x<arr.length-1-y;x++) {
				if(arr[x] >arr[x+1]) {//举例：arr[x]=5,arr[x+1]=2,5>2
					int temp =arr[x];//temp =5
					arr[x] = arr[x+1];//arr[x] =2
					arr[x +1] = temp;//arr[x+1]=5
				}
			}
		}
		System.out.println("排序后的结果：");
		printArray(arr);
		*/
		//调用冒泡排序方法
		bubbleSort(arr);
		System.out.println("排序后的结果：");
		printArray(arr);
	}	
	
	
		//冒泡排序代码：
		public static void bubbleSort(int[] arr) {
			for(int y = 0 ;y<arr.length-1;y++) {
				for(int x = 0;x<arr.length-1-y;x++) {
					if(arr[x] >arr[x+1]) {//举例：arr[x]=5,arr[x+1]=2,5>2
						int temp =arr[x];//temp =5
						arr[x] = arr[x+1];//arr[x] =2
						arr[x +1] = temp;//arr[x+1]=5
					}
				}
			}
			
		}
		//遍历数组
	public static void printArray(int[] arr) {
		System.out.print("[");
		for(int x =0;x<arr.length;x++) {
			if(x==arr.length-1) {
				System.out.print(arr[x]);
			}else {
				System.out.print(arr[x]+", ");
			}
		}
		System.out.println("]");
	}
}

13.16数组高级选择排序原理图解

选择排序：
从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处。其他的同理
既可以得到一个排好序的数组。

规则：
1.第一次是从第一个元素开始用第一个元素和第二个元素比较，第二个大于第一个的话位置不变，第一个
元素如果小于第二个就交换位置。
最后一次是数组长度-2的元素和数组长度-1的元素比较

13.17数组高级选择排序代码实现

/*
 数组排序之选择排序：
 		从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最左边
 		
 		
 */
public class ArrayDemo {

	public static void main(String[] args) {
		//定义一个数组：
			int[] arr = {24, 69, 80, 57, 13 };
			System.out.println("排序前:");
			printArray(arr);
			
			for(int x =0;x<arr.length;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;
				}
			}
			}
			System.out.println("第一次比较后");
			printArray(arr);
	}
		//遍历功能
		public static void printArray(int[] arr) {
			System.out.print("[");
			for(int x =0;x<arr.length;x++) {
				if(x == arr.length - 1) {
					System.out.print(arr[x]);
				}else {
					System.out.print(arr[x]+", ");
				}
			}
			System.out.println("]");
		}
}

13.18把字符串中的字符进行排序案例

/*
 举例："decagfb";
 结果："abcdefg";
 
 	分析
 		A:定义一个字符串
 		B:把字符串转换为字符数组
 		C:把字符数组进行排序
 		D:把排序后的字符数组转成字符串
 		E:输出最后的字符串
 */
public class ArrayTest {

	public static void main(String[] args) {
		//定义一个字符串
		String s = "decagfb";
		//把字符串转换为字符数组
		char[] chs = s.toCharArray();
		//把字符数组进行排序
		System.out.println("排序前的顺序："+s);
		bubbleSort(chs);
		String result = String.valueOf(chs);
		System.out.println("排序后的内容:" +result);
	}
	public static void bubbleSort(char[] chs) {
		for(int y = 0;y<chs.length-1;y++) {
			for(int x =0;x<chs.length-1-y;x++) {
				if(chs[x] > chs[x+1]) {
					char temp = chs[x];
					chs[x] = chs[x+1];
					chs[x+1] =temp;
				}
			}
		}
	}
}

13.19数组高级二分查找

二分查找：（折半查找）
前提：数组必须是有序的
思想：每次都猜中间的那个元素，比较大或者小，就能减少一半的元素、

思路：
	A:定义最小索引，最大索引
	B:计算出中间索引
	C:拿中间索引的值和要查找的元素进行比较
		相等：就直接返回当前的中间索引
		不相等：
			大了，在左边找
			小了：在右边找
	D:重写获取最小索引或者最大索引
		大了 在左边找
			max = mid - 1;
		小了 在右边找
			min = mid +1;
	E:回到B的位置

/*
  二分查找
 */
public class ArrayDemo {
	public static void main(String[] args) {
		//定义一个数组
		int[] arr = {1,2,3,4,5,6,7};
		int index = getIndex(arr, 5);
		System.out.println("你要查找的元素的索引是:" +index);
	}
	public static int getIndex(int[] arr ,int value) {
		int max = arr.length-1;
		int min = 0;
		//中间的索引
		int mid = (max + min)/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 = (max + min)/2;
			}
			return mid;
		}
	}

13.22Arrays工具类的概述和使用

Arrays类的概述
针对数组进行操作的工具类
提供了排序，查找等功能
成员方法
public static String toString(int[] a)
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)

import java.util.Arrays;

/*
 Arrays:针对数组进行操作的工具类，比如说排序和查找
 1.public static String toString(int[] a) 把数组转成字符串
 2.public static void sort(int[] a) 对数组进行排序
 3.public static int binarySearch(int[] a,int key)二分查找
 */
public class ArrayDemo {

	public static void main(String[] args) {
		//定义一个数组
		int[] arr = {24,69,80,57,13};
		//public static String toString(int[] a) 把数组转成字符串
		//Arrays.toString();直接遍历数组
		System.out.println("排序前："+Arrays.toString(arr));
		//利用Arrays.sort();直接进行排序
		Arrays.sort(arr);
		System.out.println("排序后："+Arrays.toString(arr));
		//public static int binarySearch(int[] a,int key)二分查找
		System.out.println("binartSearch:" +Arrays.binarySearch(arr, 57));
	}

}

13.24基本类型包装类的引入

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一：用于基本数据类型与字符串之间的转换

基本类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Doble
char Character
boolean Boolean

/*
需求1：要求把100这个数据的二进制，八进制，十六进制计算出来
需求2：要求判断一个数据是否在int范围内的
 */
public class IntegerDemo {

	public static void main(String[] args) {
		//public static String toBinaryString(int i)
		System.out.println(Integer.toBinaryString(100));
		//public static String toOctalString(int i)
		System.out.println(Integer.toOctalString(100));
		//Public static String toHexString(int i)
		System.out.println(Integer.toHexString(100));
		
		//int的范围
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);
	}

}

13.25Integer的构造

/*
 Integer的构造方法：
 	public Integer(int value)
 	public Integer(String s)
 		注意：这个字符串必须是由数字字符组成的
 */
public class IntegerDemo {

	public static void main(String[] args) {
		//方式1：
		int i = 100;
		Integer ii = new Integer(i);
		System.out.println("ii的值:"+ii);
		
		//方式2：
		String s = "100";
		Integer iii = new Integer(s);
		System.out.println("iii的值是："+iii);
	}

}

13.26String和int类型的相互转换

int类型和String类型的相互转换
int - String
String - int

public int intValue()
public static int parseInt(String s)
public static String toString(int i)
public static Integer valueOf(int i)
public static Integer valueOf(String)


public class IntegerDemo {
	public static void main(String[] args) {
			//int--String
			int number = 100;
			//方式1：
			String s1 = "" +number;
			System.out.println("s1" +s1);
			//方式2：掌握
			String s2 = String.valueOf(number);
			System.out.println("s2"+s2);
			//方式3：
			Integer i = new Integer(number);
			String s3 = i.toString();
			System.out.println("s3:"+s3);
			//方式4：
			String s4 = Integer.toString(number);
			System.out.println("s4:"+s4);
			System.out.println("-------------------");
			
			//String - int 
			String s5 = "100";
			//方式1:将String类型转换为Integer类型在转换为int
			Integer i1 = new Integer(s5);
			int ii = i1;
			System.out.println("ii:"+ii);
			//方式2：用方法Integer.parseInt()
			int iii = Integer.parseInt(s5);
			System.out.println("iii:"+iii);
			
	}
		
		

}

//打印结果
s1100
s2100
s3:100
s4:100
-------------------
ii:100
iii:100

13.27Integer中进制转换的操作

十进制到其他进制：
Integer.toString(要转的数据,转换的进制)；
进制范围：2-36
0…9，a…z
其他进制到十进制：
Integer.parseInt(要转的数据,转换的进制)
只能转换为进制中包括的比如123转换2进制就不可以

13.28JDK5的新特性自动装箱和拆箱

/*
 JDK5的新特性
 	自动装箱：把基本类型转换为包装类类型
 	自动拆箱：把包装类类型转换为基本类型
 */
public class IntegerDemo {

	public static void main(String[] args) {
		//定义了一个Int类型的包装类类型变量i
		//Integer i = new Integer(100);
		Integer ii =100;
		ii +=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());
		
		// java.lang.NullPointerException
		//Dead code死代码
		Integer iii = null;
		if(iii != null) {
		iii+=1000;
		System.out.println(iii);
		
		}
	}

}

13.30Character的概述

/*
 Character 类在对象中包装一个基本类型 char的值
 此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转成小写，反之亦然
 
 构造对象：
 	Character(char value)
 */
public class CharacterDemo {

	public static void main(String[] args) {
		 //创建对象
		 Character ch = new Character('a');
		 System.out.println("ch:" +ch);
	}

}

13.31Character常见方法讲解

/*
   public static boolean isUpperCase(char ch)判断给定字符是否是大写
   public static boolean isLowerCase(char ch)判断给定字符是否是小写
   public static boolean isDigit(char ch)判断给定字符是否是数字
   public static char toUpperCase(char ch)把给定字符转成大写
   public static char toLowerCase(char ch)把给定字符转成小写
 */
public class CharacterDemo {

	public static void main(String[] args) {
		//public static boolean isUpperCase(char ch)
		System.out.println("isUpperCase:"+Character.isUpperCase('A'));
		System.out.println("isUpperCase:"+Character.isUpperCase('a'));
		System.out.println("isUpperCase:"+Character.isUpperCase('0'));
		System.out.println("------------------------------------");
		//public static boolean isLowerCase(char ch)判断给定字符是否是小写
		System.out.println("isLowerCase:"+Character.isLowerCase('A'));
		System.out.println("isLowerCase:"+Character.isLowerCase('a'));
		System.out.println("isLowerCase:"+Character.isLowerCase('0'));
		System.out.println("------------------------------------");
		//public static boolean isDigit(char ch)判断给定字符是否是数字
		System.out.println("isDigit:"+Character.isDigit('A'));
		System.out.println("isDigit:"+Character.isDigit('a'));
		System.out.println("isDigit:"+Character.isDigit('0'));
		System.out.println("------------------------------------");
		//public static char toUpperCase(char ch)把给定字符转成大写
		System.out.println("toUpperCase:"+Character.toUpperCase('a'));
		//public static char toLowerCase(char ch)把给定字符转成小写
		System.out.println("toLowerCase:"+Character.toLowerCase('A'));
		
		
	}

}

13.32统计字符串中大写小写数字出现的次数案例

import java.util.Scanner;

/*
 统计字符串中大写小写以及数字出现的次数案例
 分析：
 	A：定义三个统计变量
 		int bigCount = 0;
 		int smalCount = 0;
 		int numberCount = 0;
 	B:键盘录入一个字符串
 	C：把字符串转换为字符数组
 	D：遍历字符数组获取到每一个字符
 	E：判断该字符是
 		大写：bigCount++
 		小写：smalCount++
 		数字：numberCount++
 	F:输出结果
 */
public class CharacterTest {

	public static void main(String[] args) {
		//定义三个统计变量
		int bigCount = 0;
		int smalCount = 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)) {
 				smalCount++;
 			}else if(Character.isDigit(ch)){
 				numberCount++;
 			}
 		}
 	//输出结果
 		System.out.println("大写字母有：" +bigCount +"个");
 		System.out.println("小写字母有：" +smalCount +"个");
 		System.out.println("数字有：" +numberCount +"个");
	}

}

总结

1:StringBuffer
(1)用字符串最拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，
Java就提供了一个字符串缓冲区类。StringBuffer供我们使用。
(2)StringBuffer的构造方法
A:StringBuffer()
B:StringBuffer(int size)
C:StringBuffer(String str)
(3)StringBuffer的常见功能
A:添加功能
/*StringBuffer的添加功能：
public StringBuffer append(String str):可以把任意类型数据添加到字符缓冲区里面，并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身
/
B:删除功能
/
StringBuffer的删除功能
public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end):删除指定位置从起始到结尾的部分并返回本身
/
C:替换功能
/
StringBuffer的替换功能：
public StringBuffer replace(int start, int end, String str)
从start开始到end用str替换
/
D:反转功能(调用)
sb.reverse();
E:截取功能
/
public String substring(int start)（截取int之前的内容）
public String substring(int start,int end)（截取起始到结尾，输出截取中间的内容）
*/
(4)StringBuffer的练习
A：String和StringBuffer相互转换
String – StringBuffer
构造方法
StringBuffer – String
toString()方法
代码如下：
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);
System.out.println(“sb:” +sb);
System.out.println(“sb2:” +sb2);
System.out.println("---------------");
//StringBuffer – String
StringBuffer buffer = new StringBuffer(“java”);
//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);
}

}

	B:字符串的拼接
	C:把字符串反转
	D:判断一个字符串是否对称
(5)小细节
	StringBuffer:同步，数据安全，效率低
	StringBuilder:不同步，数据不安全，效率高
(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;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 void 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.lrngth -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:要掌握的方法：
		把数组转成字符串
		排序
		二分查找

代码如下：
/*
Arrays:针对数组进行操作的工具类，比如说排序和查找
1.public static String toString(int[] a) 把数组转成字符串
2.public static void sort(int[] a) 对数组进行排序
3.public static int binarySearch(int[] a,int key)二分查找
*/
public class ArrayDemo {

public static void main(String[] args) {
	//定义一个数组
	int[] arr = {24,69,80,57,13};
	//public static String toString(int[] a) 把数组转成字符串
	//Arrays.toString();直接遍历数组
	System.out.println("排序前："+Arrays.toString(arr));
	//利用Arrays.sort();直接进行排序
	Arrays.sort(arr);
	System.out.println("排序后："+Arrays.toString(arr));
	//public static int binarySearch(int[] a,int key)二分查找
	System.out.println("binartSearch:" +Arrays.binarySearch(arr, 57));
}

}

(4)把字符串中的字符进行排序
	举例：
		"edacbgf"
		得到结果
		"abcdefg"

代码如下：
/*
举例：“decagfb”;
结果：“abcdefg”;

分析
	A:定义一个字符串
	B:把字符串转换为字符数组
	C:把字符数组进行排序
	D:把排序后的字符数组转成字符串
	E:输出最后的字符串

*/
public class ArrayTest {

public static void main(String[] args) {
	//定义一个字符串
	String s = "decagfb";
	//把字符串转换为字符数组
	char[] chs = s.toCharArray();
	//把字符数组进行排序
	System.out.println("排序前的顺序："+s);
	bubbleSort(chs);
	String result = String.valueOf(chs);
	System.out.println("排序后的内容:" +result);
}
public static void bubbleSort(char[] chs) {
	for(int y = 0;y<chs.length-1;y++) {
		for(int x =0;x<chs.length-1-y;x++) {
			if(chs[x] > chs[x+1]) {
				char temp = chs[x];
				chs[x] = chs[x+1];
				chs[x+1] =temp;
			}
		}
	}
}

}
3:Integer
(1)为了让基本类型的数据进行更多的操作，JAVA就为每种类型提供了对应的包装类类型
byte
short
int Integer
long
float
double
char Character
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;

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

4:Character
(1)Character构造方法
Character ch = new Character(‘a’);
代码如下：
/*
Character 类在对象中包装一个基本类型 char的值
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转成小写，反之亦然

构造对象：
Character(char value)
*/
public class CharacterDemo {

public static void main(String[] args) {
	 //创建对象
	 Character ch = new Character('a');
	 System.out.println("ch:" +ch);
}

}
(2)要掌握的方法
A:判断给定的字符是否是大写
B:判断给定的字符是否是小写
C:判断给定的字符是否是数字
D:把给定的字符串转成大写
E:把给定的字符串转成小写
代码如下：
/*
public static boolean isUpperCase(char ch)判断给定字符是否是大写
public static boolean isLowerCase(char ch)判断给定字符是否是小写
public static boolean isDigit(char ch)判断给定字符是否是数字
public static char toUpperCase(char ch)把给定字符转成大写
public static char toLowerCase(char ch)把给定字符转成小写
*/
public class CharacterDemo {

public static void main(String[] args) {
	//public static boolean isUpperCase(char ch)
	System.out.println("isUpperCase:"+Character.isUpperCase('A'));
	System.out.println("isUpperCase:"+Character.isUpperCase('a'));
	System.out.println("isUpperCase:"+Character.isUpperCase('0'));
	System.out.println("------------------------------------");
	//public static boolean isLowerCase(char ch)判断给定字符是否是小写
	System.out.println("isLowerCase:"+Character.isLowerCase('A'));
	System.out.println("isLowerCase:"+Character.isLowerCase('a'));
	System.out.println("isLowerCase:"+Character.isLowerCase('0'));
	System.out.println("------------------------------------");
	//public static boolean isDigit(char ch)判断给定字符是否是数字
	System.out.println("isDigit:"+Character.isDigit('A'));
	System.out.println("isDigit:"+Character.isDigit('a'));
	System.out.println("isDigit:"+Character.isDigit('0'));
	System.out.println("------------------------------------");
	//public static char toUpperCase(char ch)把给定字符转成大写
	System.out.println("toUpperCase:"+Character.toUpperCase('a'));
	//public static char toLowerCase(char ch)把给定字符转成小写
	System.out.println("toLowerCase:"+Character.toLowerCase('A'));
	
	
}

}

(3)统计字符串中国的大写，小写，数字出现的次数

代码如下：
/*
统计字符串中大写小写以及数字出现的次数案例
分析：
A：定义三个统计变量
int bigCount = 0;
int smalCount = 0;
int numberCount = 0;
B:键盘录入一个字符串
C：把字符串转换为字符数组
D：遍历字符数组获取到每一个字符
E：判断该字符是
大写：bigCount++
小写：smalCount++
数字：numberCount++
F:输出结果
*/
public class CharacterTest {

public static void main(String[] args) {
	//定义三个统计变量
	int bigCount = 0;
	int smalCount = 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)) {
			smalCount++;
		}else if(Character.isDigit(ch)){
			numberCount++;
		}
	}
//输出结果
	System.out.println("大写字母有：" +bigCount +"个");
	System.out.println("小写字母有：" +smalCount +"个");
	System.out.println("数字有：" +numberCount +"个");
}

}