1：算法。计算的方法。每每到了数组都要讲下经典的排序和查找
1.1：排序（以下排序主要就是第二层的循环条件差别）
1.1.1：冒泡排序：相邻2个数进行比较将最大的值放到右边。所以每一轮排序都能找到一个最大的放在右边，已经在右边的就不用再比较了，所以比较的次数也会每次-1
1 public static int [] sort(int [] array){ 2 for(int i=0; i<array.length-1; i++){ 3 for(int j=0; j<array.length-i-1; j++){ 4 if(array[j]>array[j+1]){ 5 int temp = array[j]; 6 array[j] = array[j+1]; 7 array[j+1] = temp; 8 } 9 } 10 } 11 return array; 12 }
1.1.2：选择排序：假设第一个数是最小的，将后面的数跟第一个比较，如果小则交换。第一轮比较完则可以找到最小的。再假设第二个数是最小的，将后面的数跟第二个数进行比较。
1 public static int [] sort2(int[] array){ 2 for(int i=0; i<array.length; i++){ 3 for(int j=i; j<array.length-1; j++){ 4 if(array[i]>array[j+1]){ 5 int temp = array[i]; 6 array[i] = array[j+1]; 7 array[j+1] = temp; 8 } 9 } 10 } 11 return array; 12 }
1.1.3：插入排序：将后面的数插入到已经排好序的序列中。
1 public static int[] sort3(int [] array){ 2 3 for(int i=0; i<array.length; i++){ 4 for(int j=0; j<i; j++){ 5 if(array[i]<array[j]){ 6 int temp = array[i]; 7 array[i] = array[j]; 8 array[j] = temp; 9 } 10 } 11 } 12 return array; 13 }
1.2：查找
1.2.1：顺序查找（按顺序一个个对比）
1.2.2：二分查找
1 //二分查找 2 public static int search1(int [] array, int a){ 3 4 int mid = -1; 5 int index = -1; 6 int low = 0, high = array.length-1; 7 while(low<=high){ 8 mid = (low+high)/2; 9 if(a>array[mid]){ 10 low = mid-1; 11 }else if(a<array[mid-1]){ 12 high = mid+1; 13 }else{ 14 index = mid; 15 break; 16 } 17 } 18 19 return index; 20 }
1.3：除去数组中的重复元素
1 /* 2 * 去除重复元素 3 */ 4 public static int[] removeRepeatNum(int [] array){ 5 if(array==null){ 6 return null; 7 } 8 Arrays.sort(array);//先对传入的数组进行排序 9 int len = 1;//新数组的长度，初始是1 10 //比较相邻的两个数组是否相等 11 for(int i=1; i<array.length; i++){ 12 if(array[i-1]!=array[i]){//如果前后两个数不相等，则不重复个数+1 13 len ++; 14 } 15 } 16 17 int[] array2 = new int[len];//新建一个数组，数组的大小即为不重复元素的个数 18 int j = 0;//array2 的下标 19 for(int i=1; i<array.length;i++){//遍历array 20 if(array[i-1]!=array[i]){//如果array相邻两个数不等，就将前面的数赋给array2 21 for(; j<len-1;){ 22 array2[j] = array[i-1]; 23 j++; 24 break; 25 } 26 } 27 //由于循环赋值时，最后一个数没有涉及到，所以另外处理 28 if(i==array.length-1){ 29 array2[len-1] = array[i]; 30 } 31 } 32 33 return array2; 34 35 } 36
2：Arrays类：专门对数组进行操作的类。里面的方法都是静态方法。
排序：Arrays.sort(要排序的数组); 查找：Arrays.binarySearch(数组, 要找的数);
3：可变参数
当写一个方法的时候，只能确定数据类型，不能确定参数的个数，这个时候可以用可变参数。
可变参数： 类型... a:a表示一个数组，
允许参数列表中同时存在其他参数和参数列表， 可变参数必须放在参数列表的最后一个，也可以说参数列表后面不能再有参数了。
比如：
public int add(int... a){
}
调用的时候可以这样做：
add(1,2)
add(1,2,3,4)
4：二维数组：数组中的数又是一个数组。
4.1：二维数组的定义。
1：int[][] array = new int[5][3];
2：int[][] array = new int [3][] ;第二个可以先不指定大小
array[0] = new int[2];
array[1] = new int[3];
array[2] = new int[4];
4.2 二维数组的遍历：先把一维的数组遍历出来，在遍历一维的数组。因为二维数组是数组中的数组，所以要用到两层循环来遍历
5：异常
5.1：异常：不正常。
如果发生了异常，则程序会提前终止。结束运行。
5.2：异常体系
Throwable
Error Exception
Error:错误就像人得了绝症，就不能治疗了。Error的子类的名字在后面有一个Error的单词。错误只能修改代码，不能用代码来处理异常。
Exception：得了一般的病了，可以治疗了。凡是Exception的子类都带有Exception单词。
5.3：Throwable
1：getMessage() :获得错误的信息
2：printStackTrace( ) :打印出堆栈的信息:异常的名字，异常的信息，异常的位置。
jvm的处理异常的方式是调用printStackTrace()方法（默认的）
5.4：异常的处理方式
5.4.1：try :方法内部自己处理。
try{
有可能出现异常的代码
}catch(){
发生异常后会执行的代码
}catch(){//如果写多个catch。应该先捕获子类的异常，再捕获父类的异常。
//正常情况下，抛什么异常就捕获什么异常。
}
finally{
不管是否发生异常，都会执行的代码，一般都是释放资源。
finally可有可无。
}
5.4.2：throws：抛出异常。后面接的是异常类的名。
后面可以接多个异常类名，中间用,隔开。
定义方法的时候，告诉调用者这个方法调用后有可能发生哪些异常异常，让调用者去处理这些异常。可以try…catch(){}，也可以throws，一定要有其中一个。
5.4.3：什么时候该throws，什么时候该try?
自己能处理的就尽量try,否则就throws.
5.4.4：异常的种类：
非受检异常==运行时异常：指程序的逻辑错误，RuntimeException以及RuntimeException的子类。程序可做处理，也可以不做处理。正常情况下应该不要处理，让错误暴露出现，这样程序员就可以根据错误来修改代码。
受检异常==编译异常==非运行时异常：必须进行处理的异常，这种错误是因为用户的操作而出现的异常。对这类异常程序员必须进行处理。
如果方法内有可能发生RuntimeException或者它的子类的异常，那么方法可以处理异常，也可以不处理异常。调用者可处理可不处理。
如果方法声明的是非RuntimeEception异常，那么调用者就必须处理异常。
5.4.5：throws和throw的区别
1：throws后面接的是异常类名，而throw接的是异常的对象。
2：throws后面可以写多个异常类名，而throw只能抛出一个异常对象。
3：throw是写在方法内主动抛出一个异常对象，抛给调用者。而throws是写在方法的声明上，告诉调用者方法有可能出现的异常。
4：如果方法内有throw。并且throw后面的对象是非RuntimeException异常，那么方法要么在声明上throws,要么在方法内进行try.
5.4.6:方法重写的注意事项。
子类重写父类的方法时，如果父类抛出了异常，子类要么抛跟它一样的异常，要么不抛，或者抛父类异常的子类。如果有可能出现跟父类不一样的异常，那么就只能try.也就是说子类不能抛比父类多或者范围大的异常。发生多态时，如果子类抛出的异常和父类抛出的异常一致，那么调用重写方法时就要在调用的方法上抛出大于或等于父类异常的异常或者用try…catch处理。
5.4.7：自定义异常>>day0728有代码
5.4.7：常见的一些异常：
算术异常：ArithmeticException，比如除数为零
下标越界异常：IndexOutOfBoundsException，比如数组下标大于数组的长度了
无法找到类异常：ClassNotFoundException，比如你调用了有参构造方法但是你没有写这个够杂方法
输入输出异常：IOException，一般处理输入输出流引发的
类型转换异常：ClassCastException
空指针异常：NullPointerException
6.常用的一些类---详细方法可以看java帮助文档
以下的类也不能说是常用的，知识有几个用得真的是很多的，例如String，Math和包装类
6.1 字符串序列
6.1.1 String 字符串：不可变字符序列
6.1.2 StringBuffer 字符串缓冲类：线程安全的可变字符序列。 由于线程安全，所以效率不高。
6.1.3 StringBuilder 字符串缓冲类：线程不安全的可变字符序列。由于线程不安全，所以效率高
StringBuilder跟StringBuffer 的方法一样。 如果对字符串进行追加或者删除操作，那么建议用StringBuilder.
StringBuffer reverse();字符串反转
6.2 包装类，每种基本数据类型java都提供了对应的一个类
6.2.1 Integer-->int
Integer i = new Integer(4);
Integer i = 4; //自动装箱
int j = I; //自动拆箱
6.2.2 Byte -->byte
6.2.3 Short -->short
6.2.4 Long -->long
6.2.5 Float-->float
6.2.6 Double -->doule
6.2.7 Character -->char 有判断是否为大小写，是否为数字的方法
6.2.8 Boolean --> Boolean
除了Character 没有parseXXX( )方法外，其他都有。xxxValues( )方法是所有包装类都有的
6.3 数学类Math
数学类中的方法全部是静态方法，可以静态导入。只要在所在的类中导包的位置上添加语句：import static java.util.* 即可在调用Math方法时不用写类名，直接写方法就行了
6.4 随机类Random
例如：Random random = new Random();
random.nextInt(n); 可以产生一个0-n（n必须是正数）之间的随机数，包括0但不包括n。很多应用程序会发现 Math.random() 方法更易于使用
6.5 系统类System：能获取系统的一些属性。
6.7 应用程序类 Runtime
此类没有构造方法
Runtime runtime = Runtime.getRuntime();
runtime.exec(可执行文件路径);//可以打开可执行文件，如果路径后面加一个空格再加完整路径则可以使用给可执行文件打开该文件
6.8 日期类 Date
这个是在java.util包中的，很多方法已经过时，而且很多方法都在日历类中实现了
6.9 日历类 Calender ：日历类中应该留意下的就是月份的计算是从0开始的即十二个月表示是0-11.
6.10 格式化类 Format
最为常用的是 DateFormat 这个子类中的SimpleDateFormat 类
6.11 Arrays数组
排序sort、查找binarySearch
7. 枚举（Enum）
7.1 凡是枚举里面的常量，会自动加上public static final，枚举类中的构造方法都是私有的。枚举类型的对象只能在这个类里面定义，可以在switch语句中使用
7.2 创建：
public enum Season {
春,夏,秋,冬;
}
8. 正则表达式
字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）
预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
d 数字：[0-9]
D 非数字： [^0-9]
s 空白字符：[ x0Bf ]
S 非空白字符：[^s]
w 单词字符：[a-zA-Z_0-9]
W 非单词字符：[^w]
边界匹配器
^ 行的开头
$ 行的结尾
单词边界
B 非单词边界
A 输入的开头
G 上一个匹配的结尾
输入的结尾，仅用于最后的结束符（如果有的话）
z 输入的结尾
Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次