List集合的特有功能
void add(int index; E element) :在指定索引处添加元素
E remove(int index) :移除指定元素的索引，返回被移除的元素
E get(int index) :获取指定索引处的元素
E set(int index,E element) :更改指定元素的索引，返回那个被替换的元素
List集合的遍历
1）用迭代器
ListIterator<String> li = list.listIterator();
while(li.hasNext()){
System.out.println(li.next());
}
逆向遍历： boolean hasPrevious() 如果以逆向遍历列表列表迭代器有多个元素，则返回 true。
E previous() 返回列表中的前一个元素。
2）List集合特有的遍历方法(通过size()和get()方法)
A:存储String类型的遍历
ArrayList<String> al = new ArrayList();
for(int i = 0; i < al.size();i++){
System.out.println(al.get(i));
}
B：存储对象的遍历
ArrayList<Student> students = new ArrayList<>();
Student s1 = new Student("柴小力", 20, "女");
Student s2 = new Student("李四乱", 20, "男");
students.add(s1);
students.add(s2);
for (int j = 0;j < students.size();j++){
Student s = students.get(j);
System.out.println(s.getName()+"-"+s.getAge()+"-"+s.getSex());
}
ListIteragor的功能
ListIterator 继承自Iterator 可以使用Iterator中的方法
特有功能：
boolean hasPrevious(): 是否存在前一个元素
E previous(): 返回列表中的前一个元素
并发修改异常的问题
ArrayList<String> st = new ArrayList<>();
st.add("Hello");
st.add("World");
ListIterator<String> stl = st.listIterator();
System.out.println(st);
while (stl.hasNext()){
String next = stl.next();
if("World".equals(next)){
st.add("javaee");
}
}
System.out.println(st);
这时会出现异常警告：ConcurrentModificationException
原因：原因是我们的迭代依赖于集合 当我们往集合中添加好了元素之后 获取迭代器 ，那么迭代器已经知道了集合的元素个数，这个时候你在遍历的时候又突然想给 集合里面加一个元素（用的是集合的add方法） 那迭代器不同意 就报错了。
解决方法： 1.用ListIterator迭代器遍历 用迭代器自带的add方法添加元素
2. 使用for循环遍历集合 添加元素
List的三个子类的特点
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
ArrayList类
底层数据结构是数组，查询快，增删慢，线程不安全，效率高 可以存储重复元素
int indexOf (Object o)返回此列表中指定元素的第一个出现的索引，或 - 如果此列表 不包含元素，或 - 1。
void sort (Comparator < ? super E > c)分类列表使用提供的 Comparator比较元素。
List<E> subList ( int fromIndex, int toIndex)返回一个视图之间的指定 fromIndex，包容， 和 toIndex这份名单的部分，独家。
Object[] toArray () 返回一个数组，包含在这个列表中的所有元素在适当的顺序（从 第一 个到最后一个元素）
Vector类
可以实现可增长的对象数组 , Vector 是同步的。
底层数据结构是数组，查询快，增删慢，线程安全，效率低。
特有功能：
public void addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加 1。
public E elementAt(int index) 返回指定索引处的组件。
public Enumeration elements() 返回此向量的组件的枚举。
LinkedList类
此实现不是同步的。
底层数据结构是链表，查询慢，增删快，线程不安全，效率高
特有功能
public void addFirst(E e)及addLast(E e) 将指定元素插入此列表的开头/结尾
public E getFirst()及getLast() 返回此列表的第一个/最后一个元素
public E removeFirst()及public E removeLast() 移除并返回此列表的第一/最后一个元素
泛型
是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的 类型。
格式：<数据类型> 这里的数据类型只能是引用数据类型
好处
(1): 把运行时期的问题提前到了编译期间
(2): 避免了强制类型转换
(3):优化了程序设计，解决了黄色警告线
注意：泛型只在编译期有效 但在运行期就擦除了
泛型类：
把泛型定义在类上
格式: public class 类名<泛型类型1,…>
注意: 泛型类型必须是引用类型
泛型方法：
把泛型定义在方法上
格式: public <泛型类型> 返回类型 方法名(泛型类型 变量名)
泛型接口：
把泛型定义在接口上
格式: public interface 接口名<泛型类型>
泛型接口的子类:
第一种情况: 就是在定义子类的时候我们已经可以明确数据类型了
第二种情况: 就是在定义子类的时候我们还不知道到底使用神马数据类型.这个时候我们就需要将这个子类也定义成泛型。
泛型高级之通配符
泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E : 向下限定，E及其子类
? super E: 向上限定，E及其父类
增强for循环
格式： for(数据类型 变量名:数组或者Collection集合){
}
eg: ArrayList<Integer> integers = new ArrayList<>();
for(Integer num : integers){
System.out.println(num);
}
可变参数
格式: 修饰符 返回值类型 方法名(数据类型… 变量名){}
eg: public static void main(String[] args) {
addNum(1,2,3,4,5);
}
public static int addNum(int... a) {
int sum = 0;
for (int num: a){
sum+=num;
}
}