异常

Error：JVM系统内部错误、资源耗尽等偶然情况。
Exception：其它因编程错误或偶然的外在因素导致的一般性问题。
- 空指针访问
- 试图读取不存在的文件
- 网络连接中断

异常类层次

捕获异常

try{
  //可能会出现异常的地方
}catch(Exception e){//可以写Error或Throwable
  //可以写多个catch来处理各种异常，但异常需要从小到大来写，因为catch执行一次就不会执行下面的catch了
  //当不知道捕获的是什么类型的异常时，可以直接使用所有异常的父类Exception
  e.printStackTrace();
  e.getMessage();
}catch(...){
	...
}finally{
  //可写可不写
  //不论是否异常都执行的代码
  //IO操作和JDBC用的比较多
}

抛出异常

public void methodA() throws IOException{//方法上是throws
  //调用该方法必须在try/catch中
  if(...){
    
  }else{
    throw new IOException("IO异常！");//这里是throw
  }
}
//重写方法不能抛出比被重写方法抛出的异常范围大
//重写methodA方法只能抛出比IOException更小的异常

自定义异常

class MyException extends Exception{
  public MyException(String message){
    super(message);
  }
}
//在使用时，用throw MyException("你的错误信息");

集合

Java集合类存放于java.util包中，是一个用来存放对象的容器。

集合只能存放对象。比如你存一个int型数据放入集合中，其实它是自动转换成Integer类后存入的，Java中每一种基本类型都有对应的引用类型。
集合存放的是多个对象的引用，对象本身还是放在堆内存中。
集合可以存放不同类型，不限数量的数据类型。

Java 集合可分为Set、List和Map三种大体系。

Set：无序、不可重复的集合
List：有序，可重复的集合
Map：具有映射关系的集合

在JDK5之后，增加了泛型，Java集合可以记住容器中对象的数据类型。

HashSet

HashSet是Set 接口的典型实现，大多数时候使用Set 集合时都使用这个实现类。我们大多数时候说的Set集合指的都是HashSet。

HashSet按Hash 算法来存储集合中的元素，因此具有很好的存取和查找性能。

特点：

不能保证元素的排列顺序
不可重复
HashSet不是线程安全的
集合元素可以使null

当向 HashSet集合中存入一个元素时，HashSet会调用该对象的 hashCode()方法来得到该对象的 hashCode值，然后根据 hashCode值决定该对象在HashSet中的存储位置。如果两个元素的equals()方法返回true，但它们的hashCode()返回值不相等，hashSet将会把它们存储在不同的位置，但依然可以添加成功。

HashSet类—实现—>Set接口—继承—>Collection接口

import java.util.Set;
import java.util.HashSet;
public class Test{
  public static void main(String[] args){
    Set set = new HashSet();
    set.add(1);
    set.add("A");//添加
    set.remove(1);//删除
    set.contains(1);//是否包含
    set.clear();//清空
    set.size();//集合大小
  }
}

遍历

//使用迭代器
Iterator it = set.iterator();
while(it.hasNext()){
  System.out.println(it.next());
}
//for each
for(Object obj : set){//:相当于 in
  System.out.println(obj);
}

hashCode()

HashSet 集合判断两个元素相等的标准：两个对象通过equals()方法比较相等，并且两个对象的 hashCode()方法返回值也相等。

如果两个对象通过equals()方法返回true，这两个对象的hashCode 值也应该相同。

泛型

想要让集合只能存同样类型的对象，使用泛型。

Set<String> setString = new HashSet<String>();
setString.add("asd");
setString.add(1);//错误

TreeSet

TreeSet是SortedSet 接口的实现类，TreeSet可以确保集合元素处于排序状态。 TreeSet支持两种排序方法：自然排序和定制排序。默认情况下，TreeSet采用自然排序。

TreeSet类—实现—>NavigableSet类—继承—SortedSet接口>—继承—>Set接口—继承—>Collection接口

自然排序

import java.util.Set; 
import java.util.TreeSet;
public class Test4{
  public static void main(String[]args){
		Set<Integer>set=new TreeSet<Integer>()；
		//TreeSet自然排序
  	set.add(5);
    set.add(2);
    set.add(4);
    set.add(3);
    System.out.println(set);//[2,3,4,5]
}

排序：TreeSet会调用集合元素的 compareTo(Object obj)方法来比较元素之间的大小关系，然后将集合元素按升序排列

如果this>obj，返回正数1
如果this<obj，返回负数-1
如果this=obj，返回0，则认为这两个对象相等
必须放入同样类的对象.（默认会进行排序）否则可能会发生类型转换异常，我们可以使用泛型来进行限制

class Person implements Comparator<Person>{//把person对象存到rreeset中并且按照年龄排序
	int age;
  String name;
  public Person(int age,String name){
    this.age = age;
    this.name = name;
  }
  @override
  public int compare(Person ol, Person o2){
    if(ol. age>o2. age){
    	return 1; 
    }else if(ol. age<o2. age){
    	return-1; 
    }else{
    	return 0;
    }
  }
}
public class Test{
  public static void main(String[] args){
    Person pl=new Person("张三"，23);
    Person p2=new Person("李四"，20);
    Person p3=new Person("王五"，16);
    Person p4=new Person("Lucy"，29);
    Set<Person> set=new TreeSet<Person>(new Person()); //Comparator源码需要一个比较器
    set.add(pl); 
    set.add(p2); 
    set.add(p3); 
    set.add(p4);
  }
}

List

ArrayList

List代表一个元素有序、且可重复的集，集合中的每个元素都有其对应的顺序索引
List允许使用重复元素，可以通过索引来访问指定位置的集合元素。
List 默认按元素的添加顺序设置元素的索引。
List 集合里添加了一些根据索引来操作集合元素的方法

ArrayList类—实现—>List接口—继承—>Collection接口

List<String> lst = new List<String>();
lst.add("123");//索引0
lst.add("321");//索引1
lst.add(0,"asd");//在指定索引处插入值
lst.addAll(0,lst);//在指定索引处插入集合
lst.get(0);//获取索引0的元素
//indexOf lastIndexOf remove 
lst.set(index,value);//修改某索引的值
List<String> sublist = lst.subList(2,4);//[2,4)范围

Vector

ArrayList 和Vector是List 接口的两个典型实现。

区别：

Vector是一个古老的集合，通常建议使用ArrayList
ArrayList是线程不安全的，而Vector是线程安全的。
即使为保证List集合线程安全，也不推荐使用Vector

Map

Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的Key，另外一组用于保存Map里的Value。 Map中的key和value都可以是任何引用类型的数据Map中的Key 不允许重复，即同一个Map对象的任何两个Key 通过equals 方法比较中返回 false。 Key 和Value之间存在单向一对一关系，即通过指定的Key 总能找到唯一的，确定的Value。

Map<String,Integer> map = new HashMap<String,Integer>();
map.put("a",1);//添加键值对
map.get("a");//根据key取值
map.remove("a");//根据key值删除键值对
map.containsKey("a");//是否包含指定key
map.containsValue(1);//是否包含指定value

遍历

//for each
Set<String> keys = map.ketSet();//键集合
Set<Integer> keys = map.values();//值集合，这个这里用不着
for(String key : keys){
  System.out.println("key:"+key+" value:"+map.get(key));
}
//map.entrySet()
Set<Entry<String,Integer>> entrys = map.entrySet();
for(Entry<String,Integer> en : entrys){
  System.out.println("key:"+en.getKey()+" value:"+en.getValue());
}

HashTable

HashMap 和 Hashtable 是Map接口的两个典型实现类区别：

Hashtable是一个古老的Map实现类，不建议使用
Hashtable 是一个线程安全的Map实现，但HashMap是线程不安全的。
Hashtable不允许使用null作为key和value，而HashMap可以

与HashSet 集合不能保证元素的顺序一样，Hashtable、HashMap 也不能保证其中key-value对的顺序

Hashtable、HashMap判断两个Key 相等的标准是：两个Key 通过equals方法返回true，hashCode值也相等。 Hashtable相等的标准是：两个Value 通过equalHashMap 判断两个Values方法返回true

TreeMap

TreeMap 存储Key-Value 对时，需要根据 Key 对key-value 对进行排序。TreeMap 可以保证所有的Key-Value对处于有序状态。 TreeMap的Key的排序：

自然排序：TreeMap的所有的Key 必须实现Comparable接口，而且所有的Key应该是同一个类的对象，否则将会抛出ClasssCastException，默认使用英文字典排序
定制排序（了解）：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中的所有key进行排序。此时不需要Map的Key实现Comparable接口

一般使用map集合，不会使用过于复杂对象做key

Collections

Collections 是一个操作Set、List和Map等集合的工具类Collections中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法排序操作：

reverse(List)：反转List`中元素的顺序
shuffle(List)：对List `集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定List集合元素按升序排序
sort(List,Comparator)：根据指定的Comparator 产生的顺序对List集合元素进行排序
swap(List,int,int)：将指定 list集合中的i处元素和j处元素进行交换

import java.util.Collections;
Collections.reverse(List);

泛型

为了使集合只能存放一种类型数据，作为约束而使用泛型。

泛型类

//T可任意取名，一般用T，表示type
class A<T>{
  private T key;
  
  public void setKey(T key){
    this.key = key;
  }
  
  public T getKey(){
    return this.key;
  }
}

A<String> test = new A<String>();//类型取决于自己传的类型
test.add("123");
test.getKey();

A test2 = new A();
//什么都不写等价于
A<Object> test2 = new A<Object>();

泛型接口

interface IB<T>{
  T test(T t);
}

//未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
class B1<T> implements IB<T>{
  @override
  public T test(T t){
    return t;
  }
}
B1<String> b1 = new B1<String>();//需要传递类型

//如果实现接口时指定接口的泛型的具体数据类型
//这个类实现接口所有方法的位置都要泛型替换实际的具体数据类型
class B2 implements IB<String>{
  @override
  public String test(String t){
    return t;
  }
}
B2 b2 = new B2();//不需要传递类型

泛型方法

class C{
  //无返回值的泛型方法
  public <T> void test1(T s){
    T t=s;
  }
  //有返回值的泛型方法
  public <T> T test2(T s){
    return s;
  }
  //可变参数的泛型方法
  public <T> void test3(T... ss){
    for(T s : ss){
      ...
    }
  }
}

泛型通配符

//当传递泛型参数时，不知道是什么类型，可以用?表示
void test(List<?> lst){
  
}

<?extends Person>(无穷小，Person] 只允许泛型为Person及Person子类的引用调用
<?super Person>[Person，无穷大) 只允许泛型为Person及Person父类的引用调用
<?extends Comparable>
只允许泛型为实现Comparable接口的实现类的引用调用

枚举类

在某些情况下，一个类的对象是有限而且固定的。例如季节类，只能有4个对象手动实现枚举类：

private修饰构造器
属性使用private final修饰
把该类的所有实例都使用public static final 来修饰

//单例模式实现
class Season{
  private final String S_NAME;
  private final String S_DESC;
  public Season(String name,String desc){
    this.S_NAME = name;
    this.S_DESC = desc;
  }
  
  private static Season spring = new Season("春天","春天在哪里");
  private static Season summer = new Season("夏天","好热");
  private static Season autumn = new Season("秋天","秋高气爽");
  private static Season winter = new Season("冬天","寒风阵阵");
  
  public static Season getSpring(){
    return spring;
  }
  public static Season getSummer(){
    return summer;
  }
  public static Season getAutumn(){
    return autumn;
  }
  public static Season getWinter(){
    return winter;
  }
}

Enum

import 
enum SeasonEnum{
  SPRING("春天","春暖花开"),//相当于调用构造函数
  SUMMER("夏天","好热"),
  AUTUMN("秋天","秋高气爽"),
  WINTER("冬天","寒风阵阵");
  
  private final String name;
  private final String desc;
  
  private Season(String name,String desc){
    this.name = name;
    this.desc = desc;
  }
  
  public void showInfo(){
    System.out.println(this.name+" "+this.desc);
  }
}

Seanson spring = Season.SPRING;
spring.showInfo();

Annotation注解

Annotation是从JDK5开始引入的技术

Annotation的作用
- 不是程序本身，可以对程序作出解释（这一点和注释没区别）
- 可以被其他程序（如编译器等）读取
Annotation的格式
- 注解是以"@注释名"在代码中存在的，还可以添加一些参数值
- 例如：@SuppressWarnings(value="unchecked")
Annotation在哪里使用
可以附加在package、class、method、field等上面，相当于给他们添加了额外的辅助信息，我们可以通过凡涉及机制编程实现对这些元数据的访问
@Override：定义在java.lang.Override包中，限定重写父类方法，该注释只能用于方法
@Deprecated：定义在java.lang.Deprecated包中，用于表示某个程序元素（类，方法等）已过时
@SuppressWarnings：定义在java.lang.SuppressWarnings包中，抑制编译器警告
- 与前两个注释有所不同，需要添加一个参数才能正常使用，这些参数都是已经定义好了的
  - @SuppressWarnings("all")
  - @SuppressWarnings("unchecked")
  - @SuppressWarnings(vlaue={"unchecked","deprecation"})
  - ..
```
public class SomeClass{
    //抑制所有警告
    @SuppressWarnings("all")
    void method(){
        int i = 0;
        //正常情况下，i未使用，IDEA会有个小提示，添加上方注解就没有了
    }
}
```

元注解

元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明
这些类型和他们所支持的类在Java.lang.annotation包中可以找到
- @Target：用于描述注解的使用范围
  - ElementType.ANNOTATION_TYPE 可以给一个注解进行注解
  - ElementType.CONSTRUCTOR 可以给构造方法进行注解
  - ElementType.FIELD 可以给属性进行注解
  - ElementType.LOCAL_VARIABLE 可以给局部变量进行注解
  - ElementType.METHOD 可以给方法进行注解
  - ElementType.PACKAGE 可以给一个包进行注解
  - ElementType.PARAMETER 可以给一个方法内的参数进行注解
  - ElementType.TYPE 可以给一个类型进行注解，比如类、接口、枚举
- @Retention：表示需要在什么级别保存该注解新消息，用于描述注解的生命周期（SOURCE < CLASS < RUNTIME）
- @Document：说明将该注解被包含在Javadoc中
- @Inherited：说明子类可以继承父类中的该注解

package com.volcano.annotation;

import java.lang.annotation.*;

//放此处非法
//@MyAnnotation
@MyAnnotation2
public class MetaAnnotation {
    @MyAnnotation
    void SomeMethod(){

    }
}
//定义一个注解，只能用在方法上
@Target(ElementType.METHOD)
@interface MyAnnotation{

}
//定义一个注解，能用在方法和类上
@Target(value ={ElementType.METHOD,ElementType.TYPE})
//有效范围，SOURCE源代码有效，CLASS编译成class后有效，RUNTIME运行时有效，范围从小到大
@Retention(RetentionPolicy.RUNTIME)
//在Javadoc中依旧生成
@Documented
//子类可以继承父类的注解
@Inherited
@interface MyAnnotation2{

}

自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口

@interface用来声明一个注解，格式：@interface 注解名{ 定义内容 }
其中的每一个方法实际上都是声明了一个配置参数
返回值类型就是参数的类型（返回值只能是基本类型或Class、String、enum）
可以通过default来声明参数的默认值
如果只有一个参数成员，一般参数名为value
注解元素必须要有值，定义注解元素时，经常使用空字符串，0作为默认值

package com.volcano.annotation;

import java.lang.annotation.*;
//没有default的必须传参，顺序可变
@TestAnn(id=1)
public class DIYAnnotation {
    //只有一个值，value可直接传参
    @TestAnn2(1)
    void method(){

    }
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TestAnn{
    //注解的参数：参数类型 参数名();
    int id();
    //指定默认值可不用传参
    String desc() default "";
    //如果默认值为1，代表不存在
    int noexist() default -1;

    String[] authors() default {"can","da","shuai"};
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface TestAnn2{
    //如果只有一个参数，建议使用value命名，传参时不用value=
    int value();
}

Java 异常与集合

异常