集合的方法
为什么引用集合？
1、数组可以用来存储多个对象，但是对于对象的增删改操作确实是非常麻烦的
2、数组和集合的区别
长度：数组的长度固定不变的
集合长度是可以根据实际需要改变
内容：数组存储的是同一种类型的元素
集合可以存储不同类型的元素
数据类型：数组可以存储基本数据类型，也可以存储引用数据类型
集合只能存储引用类型
注意：虽然集合不能存储基本数据类型，但是可以存储基本数据类型的包装类类型
2、数组和集合的区别
长度：数组的长度固定不变的
集合长度是可以根据实际需要改变
内容：数组存储的是同一种类型的元素
集合可以存储不同类型的元素
数据类型：数组可以存储基本数据类型，也可以存储引用数据类型
集合只能存储引用类型
注意：虽然集合不能存储基本数据类型，但是可以存储基本数据类型的包装类类型
集合的设计：因为集合有很多增删查改的方法，而且集合是一套框架，既然是框架，那么每一种集合处理增加删除修改遍历的方式不一样。
* Collection的特点
* 1.部分集合是有序的，部分集合是无序的，这里的有序指的是存储有序
* 2.部分集合是可排序的，部分集合是不可排序
* 3.部分集合是可重复的，部分集合是不可重复，唯一的
集合的特点:
1.长度可变的
2.能够存储任意的引用类型
3.具备很多对对象进行增删查改的方法
4.集合也能够存储基本类型的包装类类型，更加扩展了int的一些功能
集合的功能方法：
* 1.添加功能
* boolean add(Object obj)
* boolean addAll(Collection c)
* 2.删除功能
* void clear()
* boolean remove(Object o)
* boolean removeAll(Collection<?> c)
remove方法依赖于next（）、previous（）方法才能使用，否者报错。
* 3.修改功能
set（index，new一个新的对象，替换指定位置的对象 ）
* 4.遍历功能
* Object[] toArray()
* Iterator<E> iterator()
* <T> T[] toArray(T[] a)
增强for --------格式for(元素数据类型 变量 : 数组或者集合) {。。。} //简化遍历，但无法获取数组或者集合的索引，可能出现并发修改异常
boolean hasNext(); 判断是否有下一个元素
E next(); 获取下一个元素，并且指针指向下一个元素的位置
迭代器的原理：在获取迭代器的时候，会创建一个集合的副本，同时创建一个指针指向迭代器迭代集合的起始位置。
* 5.判断功能
* boolean contains(Object o)
* boolean containsAll(Collection<?> c)
* boolean isEmpty()
* 6.其他功能
* boolean retainAll(Collection<?> c)
* 7.获取集合长度的功能
* int size()
List接口
List list = new ArrayList();
特点： 1、集合是有序的（存储有序）
2、有索引，方便查找和修改
3、List集合可重复
4、允许存储null值
所有方法：
* 1.添加功能
* boolean add(Object obj)
* boolean addAll(Collection c)
* void add(int index, E element)
* boolean addAll(int index, Collection<? extends E> c)
* 2.删除功能
* void clear()
* boolean remove(Object o)
* boolean removeAll(Collection<?> c)
* Object remove(int index)
* boolean remove(Object o)
List list = new ArrayList();
特点： 1、集合是有序的（存储有序）
2、有索引，方便查找和修改
3、List集合可重复
4、允许存储null值
所有方法：
* 1.添加功能
* boolean add(Object obj)
* boolean addAll(Collection c)
* void add(int index, E element)
* boolean addAll(int index, Collection<? extends E> c)
* 2.删除功能
* void clear()
* boolean remove(Object o)
* boolean removeAll(Collection<?> c)
* Object remove(int index)
* boolean remove(Object o)
* 3.修改功能
* Object set(int index, E element)
* 4.遍历功能
* Object[] toArray()
* Iterator<E> iterator()
* <T> T[] toArray(T[] a)
* ListIterator<E> listIterator()
* ListIterator<E> listIterator(int index)
* 5.判断功能
* boolean contains(Object o)
* boolean containsAll(Collection<?> c)
* boolean isEmpty()
* 6.其他功能
* boolean retainAll(Collection<?> c)
* 7.获取集合长度的功能
* int size()
* 8.获取功能
* int indexOf(Object o)
* Object get(int index)
* int lastIndexOf(Object o)
* List subList(int fromIndex, int toIndex)
* Object set(int index, E element)
* 4.遍历功能
* Object[] toArray()
* Iterator<E> iterator()
* <T> T[] toArray(T[] a)
* ListIterator<E> listIterator()
* ListIterator<E> listIterator(int index)
* 5.判断功能
* boolean contains(Object o)
* boolean containsAll(Collection<?> c)
* boolean isEmpty()
* 6.其他功能
* boolean retainAll(Collection<?> c)
* 7.获取集合长度的功能
* int size()
* 8.获取功能
* int indexOf(Object o)
* Object get(int index)
* int lastIndexOf(Object o)
* List subList(int fromIndex, int toIndex)
ListIterator接口是List特有的迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。
ListIterator lit = list.listlterator();
ListIterator lit = list.listlterator();
void add(E e) 将指定的元素插入列表（可选操作）。
boolean hasNext() 返回 true如果遍历正向列表，列表迭代器有多个元素。
boolean hasPrevious() 返回 true如果遍历反向列表，列表迭代器有多个元素。
E next() 返回列表中的下一个元素，并且前进光标位置。
int nextIndex() 返回随后调用 next()返回的元素的索引。
E previous() 返回列表中的上一个元素，并向后移动光标位置。
int previousIndex() 返回由后续调用 previous()返回的元素的索引。
void remove() 从列表中删除由 next()或 previous()返回的最后一个元素（可选操作）。
void set(E e) 用 指定的元素替换由 next()或 previous()返回的最后一个元素（可选操作）。
* 数据结构: 数据的存储方式
* 和集合相关的数据结构: 数组 栈 队列 链表 哈希表 二叉树
* 和集合相关的数据结构: 数组 栈 队列 链表 哈希表 二叉树
ArrayList方法
ArrayList list = new ArrayList();
底层数据结构是数组，插入和移除性能较差，线程安全，效率低
ArrayList list = new ArrayList();
底层数据结构是数组，插入和移除性能较差，线程安全，效率低
boolean add(E e) 将指定的元素追加到此列表的末尾。
void add(int index, E element) 在此列表中的指定位置插入指定的元素。
boolean addAll(Collection<? extends E> c) 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
boolean addAll(int index, Collection<? extends E> c) 将指定集合中的所有元素插入到此列表中，从指定的位置开始。
void clear() 从列表中删除所有元素。
Object clone() 返回此 ArrayList实例的浅拷贝。
boolean contains(Object o) 如果此列表包含指定的元素，则返回 true 。
void ensureCapacity(int minCapacity) 如果需要，增加此 ArrayList实例的容量，以确保它可以至少保存最小容量参数指定的元素数。
void forEach(Consumer<? super E> action) 对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。
E get(int index) 返回此列表中指定位置的元素。
int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
boolean isEmpty() 如果此列表不包含元素，则返回 true 。
Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
ListIterator<E> listIterator() 返回列表中的列表迭代器（按适当的顺序）。
ListIterator<E> listIterator(int index) 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
E remove(int index) 删除该列表中指定位置的元素。
boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
boolean removeAll(Collection<?> c) 从此列表中删除指定集合中包含的所有元素。
boolean removeIf(Predicate<? super E> filter) 删除满足给定谓词的此集合的所有元素。
protected void removeRange(int fromIndex, int toIndex) 从这个列表中删除所有索引在 fromIndex （含）和 toIndex之间的元素。
void replaceAll(UnaryOperator<E> operator) 将该列表的每个元素替换为将该运算符应用于该元素的结果。
boolean retainAll(Collection<?> c) 仅保留此列表中包含在指定集合中的元素。
E set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
int size() 返回此列表中的元素数。
void sort(Comparator<? super E> c) 使用提供的 Comparator对此列表进行排序以比较元素。
Spliterator<E> spliterator() 在此列表中的元素上创建late-binding和故障快速 Spliterator 。
List<E> subList(int fromIndex, int toIndex) 返回此列表中指定的 fromIndex （包括）和 toIndex之间的独占视图。
Object[] toArray() 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
<T> T[] toArray(T[] a) 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。
void trimToSize() 修改这个 ArrayList实例的容量是列表的当前大小。
Vector特有的功能
Vector vector = new Vector();
类似于ArrayList，底层数据结构是数组，插入和移除性能较差，线程安全，效率低。
Vector vector = new Vector();
类似于ArrayList，底层数据结构是数组，插入和移除性能较差，线程安全，效率低。
void addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加1。
E elementAt(int index) 返回指定索引处的组件 。
Enumeration<E> elements() 返回此向量的组件的枚举。
E elementAt(int index) 返回指定索引处的组件 。
Enumeration<E> elements() 返回此向量的组件的枚举。
* LinkedList
LinkedList list = new LinkedList();
* 特点
* 1.底层数据结构是链表
* 2.链表的特点有序，查询和修改效率低，增加和删除效率高
* 3.可以存储null值
* 4.线程不安全
* 5.允许重复
* 6.不可排序
* 特点
* 1.底层数据结构是链表
* 2.链表的特点有序，查询和修改效率低，增加和删除效率高
* 3.可以存储null值
* 4.线程不安全
* 5.允许重复
* 6.不可排序
Linkedlist特有的方法
void addFirst(E e) 在该列表开头插入指定的元素。
void addLast(E e) 将指定的元素追加到此列表的末尾
E getFirst() 返回此列表中的第一个元素。
E getLast() 返回此列表中的最后一个元素。
E removeFirst() 从此列表中删除并返回第一个元素。
E removeLast() 从此列表中删除并返回最后一个元素。
* Stack类
Stack stack = new Stack();
* 方法:
* boolean empty() 测试堆栈是否为空。
E peek() 查看堆栈顶部的对象，但不从堆栈中移除它。
E pop() 移除堆栈顶部的对象，并作为此函数的值返回该对象。
E push(E item) 把项压入堆栈顶部。
int search(Object o) 返回对象在堆栈中的位置，以 1 为基数。
Stack stack = new Stack();
* 方法:
* boolean empty() 测试堆栈是否为空。
E peek() 查看堆栈顶部的对象，但不从堆栈中移除它。
E pop() 移除堆栈顶部的对象，并作为此函数的值返回该对象。
E push(E item) 把项压入堆栈顶部。
int search(Object o) 返回对象在堆栈中的位置，以 1 为基数。
泛型的概念: 在编译时期就确定的类型的一种技术
泛型是一种参数化类型，在JDK1.5之后引入的新特性，是一种将引用类型当做参数传递的参数化类型，在编译时期就已经确定了集合存储的元素类型
泛型是一种参数化类型，在JDK1.5之后引入的新特性，是一种将引用类型当做参数传递的参数化类型，在编译时期就已经确定了集合存储的元素类型
* 格式:
* <数据类型> 这里的类型必须是引用类型
* 泛型一般用于集合
* <数据类型> 这里的类型必须是引用类型
* 泛型一般用于集合
* 泛型的好处:
* 1.提高了程序的安全性
* 2.消除了黄色警告线
* 3.在编译时期将类型确定，减少不必要的强转代码
泛型根据放置的位置不同分为------泛型类、泛型方法、泛型接口
* 泛型通配符
* ? : 表示任意类型
* ? extends E : 向下限定符 E或者E的子类
* ? super E : 向上限定符 E或者E的父类
*
* 泛型限定符的应用
* boolean addAll(Collection<? extends E> c)
* ? extends E : 向下限定符 E或者E的子类
* ? super E : 向上限定符 E或者E的父类
*
* 泛型限定符的应用
* boolean addAll(Collection<? extends E> c)
Set接口：一个不包含重复元素的 collection。
Set集合特点：集合元素不重复、存储无序
Set<String> set = new HashSet<String>();
Set集合特点：集合元素不重复、存储无序
Set<String> set = new HashSet<String>();
HashSet类概述
HashSet<Integer> hs = new HashSet<Integer>();
此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
此类允许使用null元素。
HashSet保证元素唯一。
底层数据结构是哈希表，哈希表依赖于哈希值存储
添加元素时保证元素唯一，本质底层依赖两个方法：
int hashCode()
boolean equals(Object obj)
HashSet<Integer> hs = new HashSet<Integer>();
此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
此类允许使用null元素。
HashSet保证元素唯一。
底层数据结构是哈希表，哈希表依赖于哈希值存储
添加元素时保证元素唯一，本质底层依赖两个方法：
int hashCode()
boolean equals(Object obj)
TreeSet类概述
基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，
或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，
或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
排序方式完全取决于使用的构造方法。（当调用的是无参构造时是自然排序，调用有参构造时是比较器排序）
使用元素的自然顺序对元素进行排序（自然排序）
TreeSet<Student> ts = new TreeSet<Student>() ；
根据创建 set 时提供的 Comparator 进行排序（比较器排序）
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>()；
使用元素的自然顺序对元素进行排序（自然排序）
TreeSet<Student> ts = new TreeSet<Student>() ；
根据创建 set 时提供的 Comparator 进行排序（比较器排序）
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>()；
LinkedHashSet类概述：具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现、由链表保证元素有序、由哈希表保证元素唯一
LinkedHashSet<引用类型> s = new LinkedHashSet<>();
LinkedHashSet<引用类型> s = new LinkedHashSet<>();
Map集合
Map<String, String> map = new HashMap<String, String>();
Map集合提供了集合之间一种映射关系，让集合和集合之间产生关系
Map<String, String> map = new HashMap<String, String>();
Map集合提供了集合之间一种映射关系，让集合和集合之间产生关系
* Map集合的特点
* 1.能够存储唯一的列的数据(唯一，不可重复) Set
* 2.能够存储可以重复的数据(可重复) List
* 3.值的顺序取决于键的顺序
* 4.键和值都是可以存储null元素的
一个映射不能包含重复的键。每个键最多只能映射到一个值。
* 常用功能
* 1.添加功能
* V put(K key, V value)
* void putAll(Map<? extends K,? extends V> m)
* 2.删除功能
* V remove(Object key)
* void clear()
* 3.遍历功能
* Set<K> keySet()
* Collection<V> values()
* Set<Map.Entry<K,V>> entrySet()
* 4.获取功能
* V get(Object key)
* 5.判断功能
* boolean containsKey(Object key)
* boolean containsValue(Object value)
* boolean isEmpty()
* 6.修改功能
* V put(K key, V value)
* void putAll(Map<? extends K,? extends V> m)
* 7.长度功能
* int size()
* 1.添加功能
* V put(K key, V value)
* void putAll(Map<? extends K,? extends V> m)
* 2.删除功能
* V remove(Object key)
* void clear()
* 3.遍历功能
* Set<K> keySet()
* Collection<V> values()
* Set<Map.Entry<K,V>> entrySet()
* 4.获取功能
* V get(Object key)
* 5.判断功能
* boolean containsKey(Object key)
* boolean containsValue(Object value)
* boolean isEmpty()
* 6.修改功能
* V put(K key, V value)
* void putAll(Map<? extends K,? extends V> m)
* 7.长度功能
* int size()
