集合的体系
集合可以存储任意类型的数据对象，集合长度可变。
Collection是单例集合的根接口，List，Set是其子接口。
List的特点是元素有序，可重复，Set的特点是元素无序，不可重复。
Collection
Collection中的API
public static void demo() {
Collection<String> collection = new ArrayList();
collection.add("Demo"); //添加一个元素，类型为Object
collection.addAll(null); //添加一个Collection集合
collection.clear(); //清空集合
collection.remove("Demo"); //删除集合中的某个元素
collection.removeAll(null); //删除一个集合中的所有相同元素
collection.retainAll(null);//保留交集元素，删除其他元素
collection.isEmpty();//判断集合是不是为空
collection.contains("Demo");//判断集合是否包含这个元素
collection.containsAll(null);//判断集合中时候包含指定集合中的所有元素
collection.iterator();//迭代器
collection.size();//返回集合大小
}
List
List的特点是集合中的元素有序，可重复，可以通过索引来访问集合中的指定元素。
List的有序是指：元素的存入顺序和取出顺序一致，因为List集合中的元素是以线性的顺序存储的。
ArrayList
ArrayList底层维护了一个Object数组，使用无参的构造函数时默认Object数组容量是10，当长度不够用时自动增长0.5倍。
由于底层实现使用的是数组方式，在增加或删除指定位置的元素时都会创建新的数组，效率低，不适合做大量的增删操作，但其是线性数据结构，可以通过索引来访问元素，查找效率高。
Vector
- Vector底层也是维护了一个Object数组，实现与ArrayList一样，但它是线程安全的，安全的同时意味着效率低。
LinkedList
- LinkedList内部维护的结构是一个双向循环链表，对于元素的操作，增删快，查找慢。
List提供的API
public static void demo() {
ArrayList<String> list = new ArrayList<>();
list.add(0,"Demo");//将元素插入指定索引处
list.addAll(1,list);//将集合插入指定索引处
list.get(0);//获取指定索引处的元素
list.set(0,"Changed");//修改指定索引处元素数据
list.remove(1);//删除指定索引出元素
list.indexOf("Demo");//返回该元素在集合中的位置索引
list.lastIndexOf("Demo");//返回该元素在集合中最后一次出现的位置索引
//Linked
LinkedList<String> linkedList = new LinkedList<>();
linkedList.addFirst("First");
linkedList.addLast("Last");
linkedList.removeFirst();
linkedList.removeLast();
linkedList.getFirst();
linkedList.getLast();
}
Set
Set的特点是集合中的元素无序，不重复。
Set的无序是指：添加元素的顺序与取出元素的顺序不一致。
HashSet
添加元素时，HashSet会先调用元素的hashCode()的方法获得元素的哈希值，然后通过元素的哈希值经过位移等运算，算出该元素在哈希表中的存储位置。
如果算出的元素存储位置，目前没有任何元素存储，那么该元素可以直接存储到该位置。
如果算出的元素存储位置，目前有元素存在，那么还会调用该元素的equals()方法与该位置的元素再比较一次，如果返回true，那么该元素与这个位置上的元素就视为重复元素不允许添加，否则允许添加。
注意细节
hashCode()每次都调用，equals()只在比较的时候调用一次。
hashCode()默认情况下是内存地址，String类重写了Object的hashCode()，如果两个字符串的内容一致，返回的hashCode码一定也一致。
public class Run {
public static void main(String[] args) {
test();
}
public static void test() {
HashSet<User> hashSet = new HashSet<>();
hashSet.add(new User(1, "Test1"));
hashSet.add(new User(1, "Test2"));
hashSet.add(new User(1, "Test3"));
System.out.println(hashSet);
}
}
class User {
int id;
String name;
public User(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return id + ":" + name;
}
@Override
public int hashCode() {
return this.id;
}
@Override
public boolean equals(Object obj) {
User user = (User) obj;
return this.id == user.id;
}
}
TreeSet
内部采用平衡二叉树来存储元素，二叉树结构可以保证TreeSet集合中没有重复的元素，并且可以对其内元素进行排序。
TreeSet注意事项
添加元素的时候，如果元素本身具备了自然顺序的特性，那么就按照元素自然顺序的特性进行存储。
如果不具备自然顺序的特性，那么该元素所属的类必须要实现Comparable接口，把元素比较规则定义在compareTo()方法。
class Test<T> implements Comparable<T> {
@Override
public int compareTo(T o) {
// 返回负整数，零或正整数，根据此对象是小于，等于还是大于指定对象
return 0;
}
}
在比较元素的时候，如果compareTo()返回为0，就被视为重复元素，不允许添加。
添加元素时，如果元素本身不具备自然顺序的特性，而元素所属的类也没有实现Comparable接口，必须要在TreeSet的时候传入一个比较器。
class Test<T> implements Comparator<T> {
@Override
public int compare(T o1, T o2) {
return 0;
}
}
- 往TreeSet添加元素的时候，如果元素本身不具备自然顺序的特性，而元素所属的类已经实现了Comparable接口，在创建TreeSet对象的时候也传入了比较器，那么是以比较器的比较规则优先使用，推荐使用比较器Comparator。
Map集合
public static void demo() {
Map<String, String> map = new HashMap<>();
for (int i = 1; i <= 3; i++)
map.put("Key" + i, "Value" + i);
map.get("Key1"); //获取数据
map.containsKey("Key1"); //是否包含这个Key
map.containsValue("Value1"); //是否包含这个Value
for (Map.Entry<String, String> item : map.entrySet()) {
System.out.println(item.getKey() + ":" + item.getValue());
}
}
Collections集合工具类
public static void main(String[] args) throws Exception {
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("Test1");
linkedList.add("Test3");
linkedList.add("Test2");
linkedList.add("Test4");
//升序排列
Collections.sort(linkedList);
//倒序排序
Collections.reverse(linkedList);
//随机排序
Collections.shuffle(linkedList);
//折半查找
Collections.binarySearch(linkedList, "Test1");
//复制集合
// Collections.copy(dest, src);
System.out.println(linkedList);
}
迭代器
迭代器的作用就是抓取集合的元素。
Iterator
hasNext() 是否有下一个元素可遍历，如果有元素可以遍历返回true否则返回false。
next() 获取当前指针指向的元素并返回当前的元素，然后指针向下移动一个单位。
add() 方法会跳过指针，不会出现死循环，remove() 移除迭代器返回的最后一个元素。
在迭代器迭代元素的过程中，不允许使用集合对象来改变集合中的元素个数，如果需要添加或删除只能使用迭代器提供的方法，使用for循环来修改不会有这些问题。
public static <T> void test(ArrayList<T> list) {
Iterator<T> iterator = list.iterator();
while (iterator.hasNext()) {
// iterator.remove();
System.out.println(iterator.next());
}
}
ListIterator
ListIterator为Iterator的子类
public static <T> void test(ArrayList<T> list) {
ListIterator<T> listIterator = list.listIterator(list.size());
// hasPrevious 是否有上一个元素
while (listIterator.hasPrevious()) {
// add() 把当前元素插入当前指针指向的位置上
// listIterator.add();
// 替换迭代器最后一次返回的元素
// listIterator.set();
// previous先将指针上移，再取出元素
System.err.println(listIterator.previous());
}
}
增强for循环
简化迭代器的书写格式（增强for循环的底层还是使用迭代器实现的)。
//格式
for(目标变量类型 变量名:遍历的集合/数组){
}
增强for注意事项
底层的实现依旧是迭代器，所以使用增强for循环的过程中，不准使用集合对象对集合的元素个数进行修改。
使用迭代器遍历集合元素时，可以删除集合元素，而增强for循环遍历集合元素时，不能使用迭代器remove()删除元素。
//自定一个类使用增强for循环
class MyList implements Iterable<String>{
Object[] arr = new Object[10];
int index = 0 ; //当前的指针
public void add(Object o){
arr[index++] = o; // 1
}
public int size(){
return index;
}
@Override
public Iterator<String> iterator() {
return new Iterator<String>() {
int cursor = 0;
@Override
public boolean hasNext() {
return cursor<index;
}
@Override
public String next() {
return (String) arr[cursor++];
}
@Override
public void remove() {
}
};
}
}
