关于项目中异常的处理、
泛型以及集合的概念随笔
（附加MyArrayList工具类的实现）
在项目中出现最多的是各种异常。错误的基类是Throwable类，Throwable分为异常Exception异常和Error错误，异常可以处理，而错误就是GG。
Throwable常用的方法有
1.Throwable（）：Throwable的构造方法，Throwable类对象中，存储的异常或者错误信息为null。
2.Throwable(String message); Throwable构造方法，Throwable类对象中，存储的异常或者错误信息为message。
异常的处理分两种，一种是捕获异常，另一种是抛出异常。在用到捕获异常时，代码中从异常发生位置开始，之后的代码都不在运行；代码中有多个异常，可以使用多个catch块进行捕获操作，分门别类处理；异常被捕获之后代码可以正常运行。而在用到抛出异常时，
一个代码块内，有且只能抛出一个异常； 代码中存在使用throw抛出异常，在方法的声明位置必须告知调用者这里有什么异常。
在这里介绍几种在代码中常见的异常。RuntimeException运行时异常，java虚拟机在运行时可以不通过检查发现，例如：ArrayIndexOutOfBoundException；NullPointerException；StringIndexOutOfBoundException ；ArithmeticException。这些异常在代码中如果出现，不需要代码中强制进行捕获或者抛出处理。
我们也可以自定义异常，运用于生活中的代码有很多无法涵盖的异常不能用规定的名词所解释，因此我们可以自定义异常。
在项目中我们需要很多类型的数据，根据用户要求对应不用类型的数据，这里就用到了java的泛型。泛型可以在方法中使用，也可以在类和接口中使用。泛型在方法中使用时，自定义泛型声明在返回值之前，已保证方法的参数和返回值都可以使用对应的泛型；方法声明的泛型，在方法的参数中必须有一个参数是对应声明的自定义泛型。泛型在类中使用时，在类内的成员变量和成员方法都可以使用自定义泛型，成员变量不建议使用自定义泛型。在接口中使用泛型时，接口中的泛型有且只能用于成员方法。
开发中会使用大量的相同数据类型的情况，如果使用数组来解决问题，能使用的方法非常少，很多功能方法需要程序员自己实现。集合则是为此问题应运而生的，集合的方法多种多样，基本功能都很完善；数据类型支持多样化，但是又不失数据类型一致要求；容量可以变，并且不用开发者操心。
下面是MyArrayList自定义工具的各方法的实现：
public class MyArrayList<E> {
/**
* 准备一个底层数组，用于存储数据内容
*/
private Object[] elements;
/**
* 初始化默认容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 最大数组容量, -8是为了腾出一定的空间，保存数组的必要内容
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 当前底层数组中保存的有效元素个数
*/
private int size = 0;
/**
* 无参数构造方法，但是需要提供给用户一个初始化容量来保存必要的数据
*/
public MyArrayList() {
elements = new Object[DEFAULT_CAPACITY];
}
/**
* 用户指定保存元素容量的初始化过程，要求用户指定的容量范围是有效的
*
* @param initCapacity 用户指定的初始化容量，但是不能小于等于0 ，不能大于
* MAX_ARRAY_SIZE
*/
public MyArrayList(int initCapacity) {
// 用户传入参数的合法性判断过程
if (initCapacity < 0 || initCapacity > MAX_ARRAY_SIZE) {
// 抛出异常
// IllegalArgumentException 是一个RuntimeException运行时异常的子类
// 不需要强制声明抛出异常
throw new IllegalArgumentException("IllegalArgumentException : " + initCapacity);
}
elements = new Object[initCapacity];
}
/*
* 增加方法
*/
/**
* 添加元素到当前集合的末尾
*
* @param e 要求是符合泛型约束的指定数据类型
* @return 添加成功返回true， 否则返回false
*/
public boolean add(E e) {
// 直接调用在指定下标位置添加元素的方法，只不过这里指定下标位置就是
// 尾插法下标位置
return add(size, e);
}
/**
* 在底层数组的指定下标位置保存对应的元素
*
* @param index 指定下标位置，不能超出有效范围，0<= index <= size
* @param e 符合泛型约束的数据类型
* @return 添加成功返回true， 否则返回false
*/
public boolean add(int index, E e) {
if (index < 0 || index > size) {
throw new ArrayIndexOutOfBoundsException(index);
}
ensureCapacity(size + 1);
for (int i = size; i > index; i--) {
elements[i] = elements[i - 1];
}
elements[index] = e;
size += 1;
return true;
}
/*
* addAll方法
* 1. 需要得到添加集合中元素内容，有效元素个数
* 2. 确认容量问题
* 3. size = srcSize + newSize
*/
/**
* 添加另一个集合到当前集合的末尾
*
* @param list MyArrayList类型，自定义ArrayList，要求存储元素和当前集合一致，或者
* 是其子类
* @return 添加成功返回true，添加失败返回false
*/
public boolean addAll(MyArrayList<? extends E> list) {
Object[] array = list.toArray();
int newSize = array.length;
ensureCapacity(size + newSize);
for (int i = 0; i < newSize; i++) {
elements[i + size] = array[i];
}
size += newSize;
return true;
}
/**
* Do yourself 作业
* @param index
* @param list
* @return
*/
public boolean addAll(int index, MyArrayList<? extends E> list) {
return true;
}
/**
* 删除指定元素
*
* @param obj 指定删除的元素
* @return 删除成功返回true
*/
public boolean remove(Object obj) {
int index = indexOf(obj);
return null != remove(index);
}
/**
* 删除下标元素
*
* @param index 指定的下标范围
* @return 删除成功返回对应元素，失败返回null
*/
public E remove(int index) {
if (-1 == index) {
return null;
}
E e = get(index);
for (int i = index; i < size - 1; i++) {
elements[i] = elements[i + 1];
}
// 原本最后一个有效元素位置上的内容赋值为null
elements[size - 1] = null;
size -= 1;
return e;
}
/**
* 获取集合中指定下标的元素
*
* @param index 指定下标的范围，但是不能超出有效下标范围
* @return 返回对应的元素
*/
@SuppressWarnings("unchecked")
public E get(int index) {
if (index < 0 || index > size) {
throw new ArrayIndexOutOfBoundsException(index);
}
return (E) elements[index];
}
/**
* 查询指定元素在集合中的第一次出现下标位置
* @param obj 指定的元素
* @return 返回值大于等于0表示找到元素，否则返回-1
*/
public int indexOf(Object obj) {
int index = -1;
for (int i = 0; i < size; i++) {
// equals 判断对象是否一致地方的方法
if (obj.equals(elements[i])) {
index = i;
break;
}
}
return index;
}
/**
* 查询指定元素在集合中的最后一次出现下标位置
*
* @param obj 指定的元素
* @return 返回值大于等于0表示找到元素，否则返回-1
*/
public int lastIndexOf(Object obj) {
int index = -1;
for (int i = size - 1; i >= 0; i--) {
// equals 判断对象是否一致地方的方法
if (obj.equals(elements[i])) {
index = i;
break;
}
}
return index;
}
/**
* 返回MyArrayList集合中所有有效元素的Object数组
*
* @return 包含所有集合元素的Object类型数组
*/
public Object[] toArray() {
// size是有效元素个数，通过该方法可以获取到一个只有当前数组中有效元素的数组
return Arrays.copyOf(elements, size);
}
/**
* 替换指定下标的元素
*
* @param index 指定下标元素，但是必须在有效范围以内
* @param e 符合泛型约束的对应数据类型
* @return 被替换的元素
*/
public E set(int index ,E e) {
if (index < 0 || index >= size) {
throw new ArrayIndexOutOfBoundsException(index);
}
E temp = get(index);
elements[index] = e;
return temp;
}
/**
* 判断指定元素是否存在
*
* @param obj 指定元素
* @return 存在返回true，不存在返回false
*/
public boolean contains(Object obj) {
return indexOf(obj) > -1;
}
/**
* 作业
* 集合1 {1, 3, 5, 7, 9}
* 集合2 {3, 5, 7} 子集合！！True
* 集合3 {3, 7, 5} 不是！！！ false
*
* @param list
* @return
*/
public boolean containsAll(MyArrayList<?> list) {
return false;
}
/**
* 判断集合是否是空的
*
* @return 如果为空，返回true， 否则返回false
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 获取当前集合中有效元素个数
*
* @return 有效元素个数
*/
public int size() {
return size;
}
/**
* 获取当前集合的子集合，截取范围是fromIndex <= n < endIndex
*
* @param fromIndex fromIndex <= endIndex 不得小于0
* @param endIndex endIndex >= fromIndex 小于等于size
* @return 截取得到的一个MyArrayList子集合对象
*/
public MyArrayList<E> subList(int fromIndex, int endIndex) {
if (fromIndex > endIndex || fromIndex < 0 || endIndex > size) {
throw new ArrayIndexOutOfBoundsException();
}
MyArrayList<E> listTemp = new MyArrayList<E>(endIndex - fromIndex);
for (int i = fromIndex; i < endIndex; i++) {
listTemp.add(this.get(i));
}
return listTemp;
}
@Override
public String toString() {
String str = "[";
for (int i = 0; i < size - 1; i++) {
str += elements[i] + ", ";
}
return str + elements[size - 1] + "]";
}
/*
* 这里需要类内使用的可以用于判定当前容量是否满足添加要求的方法
* 如果满足直接进入添加模式，如果不满足，需要执行grow方法，完成
* 底层数组的扩容问题。
*/
/**
* 每一次添加元素，都需要进行容量判断，如果满足可以进行添加操作
* 不满足需要制定grow方法
*
* @param minCapacity 要求的最小容量
*/
private void ensureCapacity(int minCapacity) {
if (minCapacity > elements.length) {
// 完成一个底层数组的扩容方法
grow(minCapacity);
}
}
/**
* 底层数组的扩容方法，原理是创建新数组，移植数据，保存新数组地址
*
* @param minCapacity 要求的最小容量
*/
private void grow(int minCapacity) {
// 1. 获取原数组容量
int oldCapacity = elements.length;
// 2. 计算得到新数组容量
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 3. 判断新数组容量是否满足要求
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
// 新数组容量是大于允许的最大数组容量
if (newCapacity > MAX_ARRAY_SIZE) {
// 二次判断minCapacity是否小于MAX_ARRAY_SIZE
if (minCapacity < MAX_ARRAY_SIZE) {
// 最小要求是不大于MAX_ARRAY_SIZE，代码可以运行
newCapacity = minCapacity;
} else {
throw new OutOfMemoryError("Overflow MAX_ARRAY_SIZE");
}
}
/*
* 4. 使用数组工具类方法完成操作
* Arrays.copyOf(源数据数组，可以是任意类型，采用泛型约束, 指定的新数组容量);
* a. 根据指定的新数组容量创建对应泛型数据类型的新数组
* b. 从源数据数组中拷贝内容到新数组中
* c. 返回新数组首地址
*/
elements = Arrays.copyOf(elements, newCapacity);
}
}
