异常链化:以一个异常对象为参数构造新的异常对象。新的异对象将包含先前异常的信息。这项技术主要是异常类的一个带Throwable参数的函数来实现的。这个当做参数的异常，我们叫他根源异常（cause）。

要注意的地方:

1、finally块没有处理异常的能力。处理异常的只能是catch块。

2、在同一try...catch...finally块中 ，如果try中抛出异常，且有匹配的catch块，则先执行catch块，再执行finally块。如果没有catch块匹配，则先执行finally，然后去外面的调用者中寻找合适的catch块。

3、在同一try...catch...finally块中 ，try发生异常，且匹配的catch块中处理异常时也抛出异常，那么后面的finally也会执行：首先执行finally块，然后去外围调用者中寻找合适的catch块。

想了半天呢，不太好想，要熟悉这些使用方法。

通过迭代器来遍历List:

1 迭代器本身也是一个接口，是Iterator  例子为：Iterator it = coursesToSelect.iterator();  

2 他有一个hasNext的方法  即如果含有元素便返回一个真值。

3 可以用next的方法来取出元素

也可以通过for each 去遍历

String 对象创建后则不能被修改，是不可变的，所谓的修改其实是创建了新的对象，所指向的内存空间不同。

package setlist;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Random;

public class collectionsort {

List <String> stringList =new ArrayList();

Random random=new Random();

String k;

public void sortTest() {

System.out.println("--------排序前----------");

for(int i=0;i<10;i++) {

k=stringRandom();

stringList.add(k);

}

for(String string:stringList) {

System.out.println(string);

}

System.out.println("--------排序后---------");

Collections.sort(stringList);

for(String string:stringList) {

System.out.println(string);

}

}

public String stringRandom() {

String allString="0123456789zxcvbnmlkjhgfdsaqwertyuiopZXCVBNMKLJHGFDSAQWERTYUIOP";

StringBuffer sb=new StringBuffer();

for(int i=0;i<random.nextInt(11);i++){

sb.append(allString.charAt(random.nextInt(62)));

}

return sb.toString();

}

public static void main(String[] args) {

// TODO Auto-generated method stub

collectionsort cs=new collectionsort();

cs.sortTest();

}

}

# java 异常学习笔记

## 一：异常 的父类

+ Throwable

+ Error (无法修复的)

+ VirtualMachinError :虚拟机异常

+ ThreadDeal :死锁

+ Exception

+ RuntimeExcetion 检查异常，

+ 非检查异常


### （1）检查异常

+ ---

### （2）RuntimeExcetion 的子类们[非检查异常]

+ NullPointerExceptin (空指针异常)

+ ArrayIndexOutOfBundsException (数组越界限)

+ ClassCastException(转换异常)

+ ArichmeticException (算术运算错误)

## try catch finall (可以使用多重 catch)

``` java

@Test

public  void  tyrCatchTest() {

try {

int i= 2/0;

}catch (ArithmeticException e){

e.printStackTrace();

System.out.println("错了");

}catch (Exception e){

}

finally{

}

}

```

> 多重catch 字类应该在父类前

## 抛出异常 throws throw

```java

public void  throwsAndthrowTest() throws Exception {

throw new Exception();

}

````

## 自定义异常需要 继承

> extends Exception

``` JAVA

class customerExceptionImpl extends Exception {

public customerExceptionImpl(String message) {

super(message);

}

public customerExceptionImpl() {

super();

}

}

```

## 异常链

```java

@Test

public  void  tyrCatchTest() throws Exception {

try {

int i= 2/0;

}catch (ArithmeticException e){

RuntimeException runtimeException=new RuntimeException(e);

throw  runtimeException;

}catch (Exception e){

RuntimeException runtimeException=new RuntimeException(e);

throw  runtimeException;

}

finally{

//throw new Exception("dddd");

}

}

@Test

public void  throwsAndthrowTest() throws Exception {

try {

tyrCatchTest();

}catch (Exception ex){

ex.printStackTrace();

}

}

```

> <font color=#FF0000>Caused by: java.lang.ArithmeticException: / by zero

at com.tianmaoyu.Main.tyrCatchTest(Main.java:49)

... 23 more</font>

StringBulider>StringBuffer>String;

String确定字符串之后是固定的不可改变的；重新添加字符串就会成为一个新的对象，并非是原对象；

StringBulider确定字符串后可对字符串进行修改、增加内容，且指定的还是原对象，性能比string高；

StringBulider和StringBuffer比较，前者没有实现线程安全功能，后者是线程安全，所以前者比后者高；

StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此一般情况下，如果需要创建一个内容可变的字符串对象，应优先考虑使用 StringBuilder 类。

结论

　　　  1、不管有没有异常，finally中的代码都会执行

　　　2、当try、catch中有return时，finally中的代码依然会继续执行

　　　3、finally是在return后面的表达式运算之后执行的，此时并没有返回运算之后的值，而是把值保存起来，不管finally对该值做任何的改变，返回的值都不会改变，依然返回保存起来的值。也就是说方法的返回值是在finally运算之前就确定了的。

　　　4、finally代码中最好不要包含return，程序会提前退出，也就是说返回的值不是try或catch中的值

　　举例：

　 情况1：try{}catch{}finally{} return;

　　　　　　程序正常进行

　 情况2：try{return;}catch{}finally{} return;

　　　　　a、先执行try中的语句，包括return后面的表达式，b、然后执行finally中的语句，c、最后执行try中的return      

　　　　　ps：返回值是try中的return后面的表达式的值，finally后面的return语句不会被执行

　　情况3：try{} catch{return;} finally{} return;

　　　　　先执行try中的代码块

　　　　　有异常：a、先执行catch中的语句，包括return后面的表达式，b、然后执行finally中的语句，c、最后执行catch中的return，finally后面的return不会被执行

　　　　　无异常：执行finally中的代码块，然后执行return语句　

　　情况4：try{return;} catch{} finally{return;}

　　　　　a、先执行try中的语句，包括return后面的表达式，b、然后执行finally中的语句，c、最后执行finally中的return     

　　　　　ps：返回的值是finally中return后面的表达式的值，因为finally中有return语句，所以会提前退出

　　情况5：try{} catch{return} finally{return};

　　　　　先执行try中的代码块

　　　　　有异常：a、先执行catch中的语句，包括return后面的表达式，b、然后执行finally中的语句，c、最后执行finally中的return，因为finally中有return语句，所以会提前退出

　　　　　无异常：执行finally中的代码块，然后执行finally中的return

　　情况6：try{return;} catch{return;} finally{return;}

　　　　　先执行try中的代码块，包括return后面的表达式

　　　　　有异常：a、先执行catch中的语句，包括return后面的表达式，b、然后执行finally中的语句，c、最后执行finally中的return，因为finally中有return语句，所以会提前退出

　　　　　无异常：执行finally中的代码块，然后执行finally中的return

　　最总结论：在执行try、catch中的return之前一定会执行finally中的代码（如果finally存在），如果finally中有return语句，就会直接执行finally中的return方法，所以finally中的return语句一定会被执行的。编译器把finally中的return语句标识为一个warning.

　　最后的例子：

打印的结果是：

分析结果：

　　1、先执行try中return后面的表达式，然后执行finally的语句

　　2、返回值是try中return后面的表达式计算出来的值，即使finally中对chang进行了修改，也不会修改最后的返回值。try中先把计算出来的值放到不同于chang的局部变量中，执行完finally后在取出结果。应该是保存在函数栈中的。

Collection接口和Collections类

一、两者的区别

Collection接口和Collections类都在java.util包下，前者是接口，后者是类。 
1、java.util.Collection是集合类的顶级接口。它提供对集合对象进行基本操作的通用接口方法。它的直接继承接口有List，Set和Queue. 
2、java.util.Collections是一个包装类。此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它不能被实例化，起到一个工具类的作用。常见的如对集合元素进行排序、搜索以及线程安全等各种操作，服务于Java的Collection框架。

二、集合的结构

1、List和Set继承自Collection接口。 
Set无序不允许元素重复。HashSet和TreeSet是两个主要的实现类。 
List有序且允许元素重复。ArrayList、LinkedList和Vector是三个主要的实现类。 
2、Map也属于集合系统，但和Collection接口没关系。Map是key对value的映射集合，其中key列就是一个集合。key不能重复，但是value可以重复。 HashMap、TreeMap和Hashtable是三个主要的实现类。 
3、SortedSet和SortedMap接口对元素按指定规则排序，SortedMap是对key列进行排序。

重写的equals()方法

@Override

public boolean equals(Object obj)

{

//判断当前对象是否Object对象相等，相等返回true

if(this == obj)

return true; 

//判断Object对象是否为空，为空则返回false

if (obj == null)

return false;

//判断Object对象是否是Course类型，不等则返回false

if(!(obj instanceof Course))

return false;

//若上边三个条件成立，则说明当前Object对象是Course类型的

//因此将Object对象强转为Course类型

Course course = (Course) obj;

//判断当前对象是否为空，且是否相等

if(this.name == null)

{

if(course.name == null)

return true;

else

return false;

}else

{

if(this.name.equals(course.name))

return true;

else

return false;

}

}

用format（）和parse（）进行各种格式设置。