一、list 集合常用的方法
LIst：元素存取有序、可以保存重复元素、有下标。可以存储 null 值。
ArrayList：底层数组结构，有 index，查询快
LinkList： 底层链表结构，增删快
添加
//确保此集合包含指定的元素（可选操作）。
Boolean add(E e)
//将指定集合中的所有元素添加到此集合（可选操作）
boolean addAll(Collection<? extends E> c)
//上述 addAll 使用时，需要使用父类 Collection
Collection coll = new ArrayList();
//或者使用 Collections 类
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,...elements);
清除
//从此集合中删除所有元素（可选操作）。
void clear();包含
//如果此集合包含指定的元素，则返回 true
boolean contains(Object o);
//如果此集合包含指定集合中所有的元素，则返回 true
boolean containsAll(Collection<?> c);相等
//将指定的对象与此集合进行比较以获得相等性
boolean equals(Object O);为空
//如果此集合不包含元素，则返回 true
boolean isEmpty();集合中元素个数
//返回此集合中的元素个数
int size();删除
//从该集合中删除指定元素的‘单个实例’（如果存在），首次出现的第一个元素
boolean remove(Object o);
//删除指定集合中包含的所有此集合的元素（可选操作）
boolean removeAll(Collection<?> o);
保留
//仅保留此集合中包含在指定集合中的元素（可选操作）
boolean retainAll(Collection<?> o);遍历
//迭代的过程中不能使用集合本身的增删方法操作集合
//如果迭代具有更多元素，则返回 true 。
boolean hasNext()
//返回迭代中的下一个元素。
E next() 例子：
迭代注意事项：
1、一个 hasNext() 方法，只能对应一个 next() 方法。
2、迭代的过程中不能使用集合本身的增删方法来操作集合。
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "东邪", "西毒", "南帝", "北丐", "中神通");
System.out.println("=======使用iterator======");
for (Iterator<String> it = list.iterator(); it.hasNext();) {
System.out.println(it.next());
}
System.out.println("=======使用forEach======");
for (String value : list) {
System.out.println("value = " + value);
}
System.out.println("=======使用普通for======");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("=======使用特有迭代器======");
for (ListIterator<String> lsitIt = list.listIterator(list.size()); lsitIt.hasPrevious();) {
System.out.println(lsitIt.previous());
}
List 特有方法
//将指定的元素插入此列表中指定的位置（可选操作）
void add(int index,E element);
//将指定集合中的所有元素插入到此列表中的指定位置（可选操作）
boolean addAll(int index,Collection<? extend E> c);
//返回此列表中指定位置的元素
E get(int index);
//返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
int indexOf(Object o);
//返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1
int lastIndexOf(Object o);
//删除该列表中指定位置的元素（可选择操作）
E remove(int index);
//用指定的元素（可选操作）替换此列表中指定位置的元素。
E set(int index,E element);
//返回指定的 fromIndex (含) 和 toIndex 之间的列表部分的视图。‘包头不包尾’
List<E> subList(int fromIndex,int toIndex);
//返回列表中的列表迭代器（按适当的顺序）
ListInterator<E> listIterator();
//从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
ListIterator<E> listIterator(int index);
ArrayList的构造方法
ArrayList() 初始容量为10；自动扩容：按照原容量的1.5倍扩容
java.util.Vector<E> ：从Java 1.2开始，该类改进了List接口，与新的集合实现不同， Vector被同步。'效率低，安全’
//构造一个初始容量为十的空列表
ArrayList();
//构造具有指定初始容量的空列表
ArrayList(int initialCapacity);
//构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
ArrayList(Collection<? extend E> c);LinkedList的构造方法及特有方法
//构造一个空列表
LinkedList();
//构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
LinkedList(Collection<? extends E> c);
//特有成员方法
//在该列表开头插入指定的元素
void addFirst(E e);
//将指定的元素追加到此列表的末尾
void addLast(E e);
//返回此列表中的第一个元素
E getFirst();
//返回此列表中的最后一个元素
E getLast();
//从此列表中删除并返回第一个元素
E removeFirst();
//从此列表中删除并返回最后一个元素
E removeLast();
二、Set 集合常用的方法
Set：元素存取无序、不可以保存重复元素、没有下标。
HashSet：底层是哈希表，存取速度快、元素唯一、线程不同步。
TreeSet：底层是二叉树，可以对 set 集合中的元素进行排序，元素有序、线程不同步。
//不包含重复元素的集合，并且最多只有一个空元素。元素的存取是无序的。'没有下标' 搞清楚不同集合对象无序的原因以及保证对象唯一的原因是什么。
java.util.Set<E>
//该类实现Set接口，底层维护的是'哈希表数据结构'。对集合的迭代顺序不作任何保证，不能保存重复元素。
哈希表数据结构: 底层使用的是数组 + 链表结构 | 数组 + 红黑树结构[JDK8]
java.util.HashSet<E>
//是HashSet的子类，唯一的区别在于此集合可以保证元素的存取顺序。
java.util.LinkedHashSet<E>
//底层维护的是红黑树数据结构，不能保存重复元素，元素有排序[大小顺序]。
java.util.TreeSet<E>
//TreeSet 的构造方法
//构造一个新的，空的树组，根据其元素的自然排序进行排序。
TreeSet();
//构造一个包含指定集合中的元素的新树集，根据其元素的 自然排序进行排序 。
TreeSet(Collection<? extends E> c);
//构造一个新的，空的树集，根据指定的比较器进行排序。
TreeSet（Comparator<? super E> comparator);三、Map 集合的常用方法
保存
//将指定的值与该映射中的指定键相关联。如果key存在，则后面保存的数据覆盖前面保存的数据
V put(K key,V value);
//如果指定的键尚未与值关联（或映射到 null）将其与给定值相关联并返回 null，否则返回当前值。
default V putIfAbsent(K key,V value);
删除
//通过key删除一组对象，并返回对应的value，如果key不存在则返回null
V remove(Object key);
//只有当key和value是一组对象时【映射关系】，才能用于删除当前一组对象。
default boolean remove(Object key,Object value);
替换
//通过 key 替换对应的 value 并返回，如果 key 不存在则返回 null
default V replace(K key,V value);
//当 key 和 oldValue 是一组对象时，使用 newValue 替换 oldValue
default boolean replace(K key,V oldValue,V newValue);获取
//通过key获取对应的value，如果key不存在则返回null
V get(Object key);
//通过key获取对应的value，如果key不存在，返回defaultValue
default V getOrDefault(Object key,V defaultValue);
//返回此集合中键值对映射的数量
int size();包含
//如果此映射包含指定的映射，则返回 true
boolean containsKey(Object key)
//如果此映射将一个或多个键映射到指定的值，则返回 true
boolean containsValue(Object value);
//如果此映射不包含键值映射，则返回 true
boolean isEmpty();Map包含泛型
HahsMap:
java.util.HashMap<K,V> : 底层维护哈希表结构。'当key是自定义的对象时，重写hashCode() 和 equals() 方法。
map的遍历
方式一：Collection<V> values() 返回map集合中的所有value值，保存到Collection集合中'遍历map集合的value值
方式二：Set<K> keySet•() 返回map集合中的所有key值，保存到Set集合中。'用于通过key获取对应的value遍历Map集合。
方式三：Set<Map.Entry<K,V>> entrySet•() 返回Map集合中的键值对对象到Set集合中。'用于遍历Map集合操作
K getKey() 返回Entry对象中封装的key值。
V getValue() 返回Entry对象中封装的value值。
/*
Collection<V> values() 返回此地图中包含的值的Collection视图。
1. 调用values方法，获取值的视图
2. 遍历值的视图
*/
for(String value : map.values()){}
/*
Set<K> keySet() 返回此地图中包含的键的Set视图。
1. 调用keySet方法，获取键的视图
2. 遍历键的视图
3. 通过键获取value
*/
for(String key : map.KeySet()){}
/*
Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图。
java.util.Map.Entry<K,V> : 键值对对象【将map集合中的键和值封装之后产生的新的对象】
成员方法
K getKey() 返回与此条目相对应的键。
V getValue() 返回与此条目相对应的值。
1. 调用entrySet方法，获取键值对视图
2. 遍历键值对视图 --> entry对象
3. 通过entry对象调用 getKey 和 getValue 方法获取键和值
*/
for(Map.Entry<String,String> entry : entries){}//map 遍历的例子
HashMap<String,String> map = new HashMap<>();
map.put("1","111");
map.put("2","222");
map.put("3","333");
map.put("4","444");
//通过 Collection<V> value 返回此地图中包含的 Collection 视图
for(String value : map.values()){
System.out.println("value = " + value);
}
//通过 Set<K> KeySet() 返回地图中包含的键的Set 视图
for(String key : map.keySet()){
String value = map.get(key);
System.out.println(key + "=" + value);
}
//通过 Set<Map.Entry<K,V>> entrySer() 返回此地图中包含的映射的 Set 视图
for(Map.Entry<String,String> entry : map.entrySet()){
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "=" + value);
}
