Collection 中的简单命令

一、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);
}