集合
迭代器： **next()**的方法：返回列表中的下一个元素，并且前进光标位置。
数组和集合的区别：
数组的长度是固定的，集合长度不固定
数组存储基本类型和引用类型，集合只能存储引用类型。
位置：java.util.*;
Collection集合
删除remove()：如果集合里有重复的对象，只能删除第一个匹配的。
遍历集合：
//第一种遍历增强For循环
for (Object o : collection) {
System.out.println(o);
}
//第二种遍历 迭代器遍历
Iterator iterator = collection.iterator();
while (iterator.hasNext()){
Object obj=iterator.next();
System.out.println(obj);
iterator.remove();//删除iterator中的元素
//如果用集合的删除
//collection.remove(obj);
}迭代遍历不能使用集合的删除方法，因为会出现并发错误。出现的异常为java.util.ConcurrentModificationException
Iterator iterator = collection.iterator();
while (iterator.hasNext()){
Object obj=iterator.next();
System.out.println(obj);
//iterator.remove();
//如果用集合的删除
collection.remove(obj);
}
//答案：
Exception in thread "main" java.util.ConcurrentModificationException如果集合中添加的是对象，如果删除集合的对象，要重写对象所属类的equals()方法。也最好把toString()方法也重写。
List
List 遍历：
1.增强for循环
2.for循环
3.Iterator迭代器
4.ListIterator迭代器
List 接口提供了ListIterator迭代器
//列表迭代器
ListIterator listIterator = list.listIterator();
//从前往后输出
while(listIterator.hasNext()){
System.out.println("第"+listIterator.nextIndex()+"位置"+listIterator.next());
}从后向前输出，参数不用减一，源码中减1.
//列表迭代器
ListIterator listIterator = list.listIterator(list.size());//这个是list的元素的个数。而不是size-1。
//从后往前输出
while(listIterator.hasPrevious()){
System.out.println("第"+listIterator.previousIndex()+"位置"+listIterator.previous());
}//源码
public E previous() {
checkForComodification();
int i = cursor - 1；这里减的一
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData[lastRet = i];
}
ArrayList
特点：有序 有下标 可重复
存储结构：数组
Vetor
使用和ArrayList()差不多，可以根据api 使用。
但是他多了一个枚举。
枚举器
Vector vector=new Vector();
//添加元素
vector.add("西瓜");
vector.add("香蕉2");
vector.add("香蕉3");
vector.add("香蕉4");
vector.add("香蕉5");
//枚举器
Enumeration elements = vector.elements();
while(elements.hasMoreElements()){
System.out.println(elements.nextElement());
}LinkedList
双向链表，增删快，查询慢
有序，有下标，可以重复
源码：
1构造方法没有任何操作，size=0,表示元素个数
first表示头节点，last 表示最后一个节点
2.静态内部类Node, 属性item:数据,next:下一个元素，prev：上一个元素。
3.add()方法，每添加一个节点，first属性指向第一个元素，last属性指向最后一个元素，中间节点指向它的前驱后继。第一个元素没有前驱，最后一个元素没有后继。
ArrayList的存储结构是数组，LinkedList存储结构是双向链表。
ArrayList的查找遍历比较快，插入和删除相对较慢，因为使用了本地的方法优化，并不一定比LinkedList慢。
LinkedList的插入和删除比较快，查找遍历较慢。
Stack
是一个实现类，Stack stack=new Stack();其实用linkedList也可以实现
stack.push();进栈
stack.pop();出栈
每次进栈长度加一，出栈减一，长度是变得，所以出栈遍历时，要增加一个变量记录长度。
Queue
是一个接口，可以用LinkedList来实现。Queue queue=new LinkedList();
queue.offer();进队列
queue.poll();出队列
遍历时也和栈一样，增加一个记录长度的变量。
泛型
Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
<T,K,V,E> T,K,V,E称为类型占位符，表示一个引用类型。
泛型类：
不能使用泛型实例化对象。
不能使用泛型作为重载方法的参数。
jdk1.7之后实例化泛型对象省略类型
class Student<T>{}
Student<String> student=new Student<>();泛型的好处：
1.提高代码的重复利用性。
2.防止类型转换异常，提高代码的安全性。
泛型接口：
不能声明静态常量，可以声明抽象方法。
public interface USB<T>{
T t();
}
实现类既可以时泛型也可以不是泛型。
class KeyBoard<T> implements USB<T>{
}泛型方法：
在返回值的前面加<>
比如：
public static <T> T show(T t){
System.out.println(t);
return t;
}
String hah = Generic2.show("hah");
Integer show = Generic2.show(19);
Student show1 = Generic2.show(new Student("11", 12));泛型类作为参数时泛型类做参数要加?
**泛型的上限和下限
？表示任何类型
上限< ？extends T> 比如 ？extends Student 只识别Student或者是Student的子类。
下限< ？ super T> 比如？super Student 只识别Student或者是Student的父类。
public static void main(String[] args) {
Generic<Integer>generic=new Generic<>();
show(generic);
Generic<Double>generic1=new Generic<>();
show(generic1);
Generic<Student>generic2=new Generic<>();
show(generic2);
Generic<String>generic3=new Generic<>();
show(generic3);
}
public static void show(Generic<? > generic){
generic.show();
}如果加了？extends Student ,其他的都会报错，因为只能是Student或者是Student的子类。
如果加了？super Student ,其他的都会报错，因为只能是Student或者是Student的父类。
Collections工具类（集合的各种方法）
概念：集合工具类，定义了除了存取以外的集合常用方法。
根据api可以查出所有的方法
ArrayList<Integer> lis=new ArrayList<>();
lis.add(10);
lis.add(11);
lis.add(13);
lis.add(5);
lis.add(20);
lis.add(2);
System.out.println("---------sort 排序-----------");
Collections.sort(lis);
System.out.println(lis.toString());
System.out.println("------binarySearch 二分查找---------");
int i = Collections.binarySearch(lis, 20);
System.out.println(i);
System.out.println("--------shuffle 打乱方法----------");
Collections.shuffle(lis);
System.out.println(lis.toString());
System.out.println("-----------reverse 反转元素------------");
Collections.reverse(lis);
System.out.println(lis);
System.out.println("------------最大值max最小值min-----------");
System.out.println(Collections.max(lis));
System.out.println(Collections.min(lis));
System.out.println("----------frequency 查找元素出现的次数-------");
System.out.println(Collections.frequency(lis, 20));
System.out.println("----------copy 复制元素----------");
ArrayList<Integer> arrayList=new ArrayList<>();
for (int i1 = 0; i1 < lis.size(); i1++) {
arrayList.add(0);
}
Collections.copy(arrayList, lis);
System.out.println(arrayList.toString());
集合和数组的相互转换。
1.数组转换集合
String[] str={"轩轩","轩儿","哈哈"};
List<String> arrayList= Arrays.asList(str);但是不能执行修改arrayList长度的操作，会出UnsupportedOperationException 不支持操作异常。但是允许修改操作。
2.集合转换数组
ArrayList<String> arrayList1=new ArrayList<>();
arrayList1.add("西瓜");
arrayList1.add("东瓜");
arrayList1.add("南瓜");
arrayList1.add("北瓜");
String[] str1= arrayList1.toArray(new String[0]);
System.out.println(Arrays.toString(str1));toArray()中的数组的长度可以是0，也可以是任意值，最好是0-arrayList1.size(),如果大于arrayList.size(),字符串数组也就变长了，输出是后面会是null.