Java月末小结（二）

1. 异常

1.1 Thowable类

Thowable 类是Java中所有异常和错误的基类，规定一些操作方法
构造方法 Constructor
Throwable();
创建一个Throwable类对象，异常信息为null
Throwable(String message);
创建一个Throwable类对象，使用message信息作为当前异常/错误提示内容

成员方法:
String toString();
返回当前Throwable类对象简要信息描述
String getMessage();
返回房前Throwable类对象中message信息
void printStackTrace();

1.2 异常结构

Throwable 异常/错误的基类
–| Exception 异常
–| Error 错误

异常与错误除了结尾不同外,异常可以处置,错误只能避免

1.3 异常捕获

捕获:
	try {
	
	} catch (异常类型) {
		处理当前异常的方式
	}
	
	try {
	
	} catch () {
	
	} finally {
	
	}
	1. 在try大括号里面是有可能出现的异常代码
	2. catch之后的小括号是异常类型,catch大括号中是对应当前异常类型的处理方式
	3. finally大括号中是无论当前代码是否出现异常,都一定会执行的代码,通常用于资源关闭问题

1.4 异常抛出

关键字:
throw 在方法中抛出对应异常对象
throws 在方法声明位置告知调用者,当前方法抛出哪些异常

注意事项:
1. 在方法中使用throw根据对应条件抛出对应异常,同时需要在方法的声明的位置使用
throws关键字告知调用者这里都抛出了哪些异常
2. 在同一个条件内有且只能同时抛出以一个异常,因为代码块从throw语句不再执行
3. 如果需要在方法中抛出多个异常,需要多个条件辅助问题
4. 调用方法带有异常抛出,需要处理当前异常。可以再次抛出或者捕获处理。
如果当前异常是RuntimeException本身或者其子类，可以考虑交给JVM自行处理

1.5 抛出和捕获

用户层(需求找到xxx.java文件) --> Controller控制层(用户请求找到对应文件 ==> 发给目标方法)
–> findFile(String)(文件不存在) --> Controller控制层(直白表述未找到文件【抛出异常】)
–> 用户层(友好性的告知用户无法找到文件)

1.6 自定义异常

class MyException extends Exception {
	// 需要完成两个构造方法:
	// 无参构造方法
	// 有参构造方法(String message)
}

2. 泛型

2.1 泛型的基本格式和作用

格式:
<自定义无意义单个大写英文字母占位符>

泛型:
可以转换成任意类型

2.2 泛型在方法中使用

格式:
权限修饰符 [静态修饰] <泛型声明> 返回值类型 方法名(形式参数列表) {

}
1. 参数列表必须有一个参数类型是对应方法声明的自定义泛型
在方法中泛型对应的具体数据类型是通过该实际参数类型进行约束操作
2. 返回值类型可以使用自定义泛型
3. 在方法体在也可以使用自定义泛型

2.3 泛型在类中使用

格式:
	class 类名<自定义无意义单个大写英文字母占位符> {
		类内成员方法可以使用自定义泛型
	}

2.4 泛型在接口中使用

格式:
	interface A<自定义无意义单个英文大写字母占位符> {
		成员变量缺省属性: public static final 定义是必须初始化,泛型不是具体数据类型,无法进行初始化操作 不能使用泛型
		
		成员方法可以使用自定义泛型
	}

类遵从带有自定义泛型的接口,有两种模式
1. 自由模式
在类名位置声明和接口泛型一致的内容
2. 妻管严模式
类名未声明泛型,接口中直接对应泛型给与具体类型数据

3. 集合

3.1 开发中对于集合的期望

数组与集合的区别
1. 数据类型:
数组: 对应数据类型单一,不能满足多种数据类型的和代码复用的要求
集合: 支持所有数据类型,并且在数据类型多样化的情况下,没有丢失数据类型一致化要求

2. 操作方法:
数组: 数组操作对应方法没有统一规范,底层数组都对应一套方案
集合: 方法众多,工具方便

3. 容量:
数组: 数组容量一旦确定,无法改变
集合: 数组容量具有多种解决方式,可根据具体情况自由选择

集合提供了多种存储模型,可以根据当前数据的操作需要来选择合适的方式

3.2 集合的基本结构

interface Collection Java中所有集合的总接口
interface List 特征: 有序,可重复
class ArrayList
底层存储数据的方式是数组形式,提供对应操作方式(增删满,查询快)
class LinkedList
底层存储数据的结构是双向链表 (增删快,查询满)
class Vector
是ArrayList线程安全版,效率低于ArrayList,线程安全性高
interface Set 特征: 无序,不可重复
class HashSet
底层数据采用哈希(Hash)表结构,存储效率极高
class TreeSet
底层数据采用属性结构存储,数据存储需要有对应有对应的比较方式

3.3 Collection<E> 接口的常用方法

增:
	add(E e);
	添加用户指定数据类型到当前Collection集合中
	addAll(Collection<? extends E> c);
	添加参数集合到当前集合中,要求参数集合汇总保存的数据类型是E类型本身或者其子类对象
	
删:
	remove(obiect obj);
	删除当前集合中用户指定的类对象,对象类型为Object类型,不限制用户输入的数据
	removeAll(Collection<?> c);
	在当前调用方法的集合对象中,删除参数集合和当前集合的交集,参数集合中保存的数据类型不限制
	reatinAll(Collection<?> c);
	在当前调用方法的集合对象中,保留参数集合和当前集合的交集,参数集合中保存的数据类型不限制
	clear();
	删除集合中所有元素,清空集合
		
查:
	int size();
	当前集合中有效元素个数
	boolean isEmpty();
	判断当前集合是否为空
	boolean contains(Object obj);
	判断当前集合中是否包含对应元素
	Object[] toArray();
	返回当前集合中所有元素的Object类型数组

3.4 Iterator 涉及到的方法

Iterator涉及到的方法:
	Iterator<E> iterator();
	通过集合对象调用,获取当前集合对应的Iterator对象,Iterator对象的泛型和对应集合中存储元素一致
	E next();
	获取当前Iterator指向元素,并将Iterator指向下一个元素
	boolean hasNext();
	判断当前Iterator对象是否可以继续获取元素 
	void remove();
	删除
		1. 删除元素有且只能是next取出元素
        2. remove之前必须有一个next,不允许跨越其他next

4. List集合

4.1 List集合特征分析

interface List
有序 添加顺序和存储顺序一致
可重复 在List集合允许出现相同元素
class ArrayList 可变长数组
class LinkedList 双向链表结构
class Vector 线程安全的可变长数组
List在开发中常用

4.2 List集合常用方法

增:
	add(E e);
	添加当前集合要求元素到当前集合末尾
	addAll(Collection<? entends E> c);
	添加另一个集合到当前集合末尾,要求参数集合中的存储元素
	是当前集合存储元素本身或者其他子类对象
	add(int index, E e);
	在当前集合指定小标位置,添加集合要求数据类型元素
	addAll(int index, Collection<? entends E> c);
	在当前集合指定下标位置,添加另一个集合对象,要求参数集合中的存储元素
	是当前集合存储元素本身或者其他子类对象

删:
	remove(Object obj);
	删除当前集合中的指定元素
	removeAll(Collection<?> c);
	在当前集合中,删除当前集合和参数结合的交集
	retainAll(Collection<?> c);
	在当前集合中,保留当前集合和参数集合的交集
	clea();
	清空整个集合
	E remove(int index);
	删除当前集合中指定下标元素,返回值类型是被删除的元素
	
改:
	E set(int index, E e);
	使用指定元素,替换指定下标元素,返回值是被替换的元素
	
查:
	int size();
	当前集合中有效元素个数
	boolean isEmpty();
	判断当前集合是否为空
	boolean contains(Obiect obj);
	判断当前集合中是否包含指定元素
	boolean containsAll(Collection<?> c);
	判断当前参数集合是否是当前集合的子集合
	Object[] toArray();
	返回当前集合中所有元素的Object类型数组
	E get(int index);
	获取指定下标元素
	int indexOf(Object obj);
	找出指定元素在List集合中最后一次出现的下标位置
	List<E> subList(int beginIndex, int endIndex);
	截取子List集合,要求从beginIndex开始,到endIndex,要头不要尾

4.3 List集合对应迭代器

ListIterator
ListIterator listIterator();
获取当前List集合对应List专属Iterator对象
boolean hasNext();
判断当前是否还可以继续获取元素
E next();
取出当前元素,并且指向下一个元素
void remove();
删除通过next得到的当前元素

5. ArrayList 可变长数组

5.1 ArrayList原理

ArrayList底层存储数据的是一个Object类型数组。可以支持任意类型，但是通过泛型约束，在添加操作数据的过程中，
约束对应的数据类型，从而满足数据类型一致化要求。

ArrayList集合中提供了两个常用构造方法，一个是无参数构造方法，一个是带有用户指定初始化容量构造方法。
	
	ArrayList();
		如果采用无参数构造方法创建对应的ArrayList对象，底层数组的初始化容量为10，采用的是当前ArrayList中规定的常量
		private static final int DEFAULT_CAPACITY = 10;
	
	ArrayList(int initCapacity);
	根据用户提供的容量数据，在合法范围以内使用。
	
	ArrayList完成可变长操作依赖于底层的grow方法，在需要进行底层数组扩容的情况下，新数组容量是原数组容量的1.5倍左右。

5.2 ArrayList特征

ArrayList使用特征:
增加慢:
1. 有可能需要从添加位置开始，之后的元素整体向后移动，移动过程非常浪费使用
2. 在添加数据有可能触发底层数组扩容问题，在数组扩容过程中，第一会浪费空间，需要新数组进行数据保存和原数组同时存在，
3. 第二会导致时间浪费，数据在转移的过程会浪费时间。
删除慢:
4. 在删除数据的过程中，可能从删除位置开始，之后的需要整体向前移动，移动过程浪费时间。
5. 如果删除数据过多，空闲空间占比过大，会导致大量的空间浪费，需要继续缩容操作。
查询快:
ArrayList底层是Object类型数据，查询操作都是按照数组下标方式来进行获取，查询的。
整个过程完成是CPU直接访问地址得到数据，效率极高.

6. LinkedList 双向链表

LinkedList特征:
查询慢:
想要获取对应下标的元素,需要通过元素一个一个跳转完成
增删快:
1. 只需要进行地址交换转移
2. 不涉及数据的转移过程
3. 不考虑数据容量不足问题

LinkedList特征方法:
addFirst(E e);
addLast(E e);
E getFirst();
E getLast();
E removeFirst();
E removeLast();

堆栈:
先进后出
addLast(E e); E getLast(); E removeLast();

队列:
先进先出
addLast(E e); E getFirst(); E removeFrist();

7. set集合

interface Set
class HashSet
底层是哈希表结构,利用每一个单元格的唯一编号,可以快速存储和查询操作
类似于Excel表格,每一个单元格位置都有唯一编号,并且在使用Excel表格过程中,我们期望没一个单元格中,有且只有一个数据
class TreeSet
底层是一个树形结构,并且是一个平衡二叉树

Set集合数据特征:
1. 数据不可重复,具有唯一性
2. Set存储元素顺序和添加顺序不一致,无序
3. Set,没有特征方法,全部方法来自Collection

8. Map双边队列

8.1 Map结构

interface Map<K, V>
K 约束双边队列键对应数据类型 V 约束双边队列值对应数据类型
class HashMap<K, V>
底层采用哈希结构,用于存储的效验数据是K
class TreeMap<K, V>
底层采用二叉树结构,用于比较判断的数据是K

8.2 Map方法

增:
	put(K k, V v);
		添加当前Map双边队列约束的K和V到当前双边队列中
	putAll(Map<? extends K, ? extends V> map);
		添加另一个Map双边队列，要求参数Map中，K是当前Map对应K类型或者其子类，V
		是当前Map对应V类型或者其子类
删:
	V remove(Object k);
		根据K删除对应的键值对
改:
	put(K k, V v);
		如果K存在，使用当前v替换原数据
查:
	boolean containsKey(Object key);
		判断指定K是否存在
	boolean containsValue(Object value);
		判断指定V是否存在
	Set<K> keySet();
		返回当前Map中所有Key对应的Set集合
	Collection<V> values();
		返回当前Map中所有Value的Collection集合
	V get(Object k);
		根据指定K获取对应V