Java集合

集合框架基本显示：

详细一点的：

集合特点介绍：

集合的特性

Collection集合
Collection方法：

-添加
boolean add(E e)  添加一个元素 
boolean addAll(Collection<? extends E> c)  添加一整个集合的元素
-删除
void clear()  删除集合中所有元素
boolean remove(Object o)  移除指定元素
boolean removeAll(Collection<?> c)  移除一个集合的所有元素（移除一个还是移除所有返回true呢？）
-判断
boolean contains(Object o)  判断集合中是否包含指定的元素
boolean containsAll(Collection<?> c) 判断集合中是否包含指定集合的元素（一个还是所有？）
boolean isEmpty()  判断集合是否为空  
-获取
Iterator<E> iterator() 获取集合的迭代器对象  单独讲  
int size()  获取集合的长度，就是集合中元素的个数
-交集
boolean retainAll(Collection<?> c)  两个集合都有的元素，返回值反的是什么？
-转换	
Object[] toArray() 

• List接口
  特点：

  1. 有序的集合（存取顺序）
  2. 允许存储重复的元素
  3. 有索引

  特有方法：

  void add(int index, E element)  将指定元素添加到集合的指定位置
  E get(int index)  根据集合的索引获取集合的值
  ListIterator<E> listIterator() 
  E remove(int index)  移除集合中指定位置的元素
  E set(int index, E element)  用指定元素替换集合指定位置的元素
  

  • Vector集合
    特点：
    1.底层数据结构是数组， 查询快 增删慢
    2.线程安全，效率低。
  • ArrayList集合
    特点：
    1.底层数据结构是数组， 查询快 增删慢
    2.线程不安全，效率高。
  • LinkedList集合
    特点：
    1.底层数据结构是链表 查询慢， 增删快
    2.线程不安全，效率高。
    3.里边包含了大量的操作首尾元素的方法

    特有功能
    增加
    void addFirst(E e) 
    void addLast(E e) 
    获取
    E getFirst() 
    E getLast() 
    移除
    E removeFirst() 
    E removeLast() 
    判断
    boolean offer(E e)  
    boolean offerFirst(E e) 
    boolean offerLast(E e) 
    检索但删除
    E poll() //检索并删除此列表的头
    E pollFirst()  
    E pollLast() 
    检索但不删除
    E peek()  //检索但不删除此列表的头
    E peekFirst() 
    E peekLast()   
    

• Set接口
  特点：

  1. 无序的集合（存取顺序）
  2. 不许存储重复的元素
  3. 没有索引
  • TreeSet集合
    特点：排序和唯一
  • HashSet集合
    特点：
    1.无序
    2.它不能保证在一段时间内保持不变
    3.这个类允许null元素
    4.查询速度快
    它是如何保证元素唯一的由哈希表（实际为HashMap实例）需要重写：
    hashCode() //返回的是逻辑地址，重写后返回多少就是多少
    equals()
  • LinkedHashSet集合(是hashset的子类)
    特点：
    1.哈希表和链表实现的Set接口，具有可预测的迭代次序
    2.元素有序唯一
    3.由链保证有序（存取顺序），由哈希表保证唯一

Map集合
特点：
1.双列集合，每个元素包含一个键，一个值，
键是唯一的

 特有方法：
 添加
	V put(K key, V value) 添加元素。其实还有一个功能。
		如果键是第一次存储，就是添加。 返回null
		如果键不是第一次存储，就会把键之前对应的值替换，返回的是替换掉的值
	void putAll(Map<? extends K,? extends V> m)   添加指定集合的元素
删除
	V remove(Object key)  根据键删除键值对  返回被移除的值
	default boolean remove(Object key, Object value)  根据指定的键值对 移除 键值对
	void clear()  移除集合中所有的键值对 
判断
	boolean containsKey(Object key) 判断集合中是否包含指定的键 
	boolean containsValue(Object value) 判断集合中是否包含指定的值
	boolean isEmpty()  判断集合是否为空 
获取
	Set<Map.Entry<K,V>> entrySet() 
	V get(Object key) 根据键获取值
	Set<K> keySet()  获取集合中所有键的集合
	int size() 返回此集合中键值映射的数量。  
	Collection<V> values() 获取集合中所有值的集合
替换
	default V replace(K key, V value)  通过键替换值  
	default boolean replace(K key, V oldValue, V newValue)  通过键替换值 

• HashMap
  特点：
  底层是哈希表，查询速度快
  线程不安全
  键-无序的集合，允许键和值为null
  速度快

• LinkedHashMap(是HashMap的子类)
  特点：
  底层是哈希表+链表
  键-有序的集合

• HashTable
  特点：
  底层是哈希表，查询速度快
  线程安全
  键-无序的集合，不允许键和值为null
  速度慢

• TreeMap
  特点：键-唯一排序

  注意：在JDK9之后，在List，Set，Map接口里增加了一个静态方法of，可以给集合一次添加多个元素；of方法只适用于List，Set，Map接口，不适用于接口的实现类；of方法返回的是一个不可改变的集合；Set，Map接口添加的时候不能有重复的元素

遍历集合

• List集合遍历

1. 迭代器遍历
   Iterator iterator() 获取集合的迭代器对象
   boolean hasNext() 判断是否仍有元素
   E next() 返回迭代的下一个元素
   迭代器的使用步骤：
   1.使用集合中的iterator获取迭代器对象，需要使用iterator的实现类对象
   2.使用hasNext() 判断是否仍有元素
   3.使用next() 返回迭代的下一个元素

   Iterator<String> it = list.iterator();
       while (it.hasNext()) {
           String next = it.next();
           System.out.println(next);
       }
   

   或者使用ListIterator listIterator() 迭代器进行遍历
2. 增强for（foreach）遍历

   for (String s : list) {
           System.out.println(s);
       }
   

3. for循环+get(index)遍历，get方法是List集合固有方法

   for (int i = 0; i < list.size(); i++) {
           String s = list.get(i);
           System.out.println(s);
       }
   

• Set集合遍历方法
  1.迭代器遍历
  Iterator iterator() 获取集合的迭代器对象
  boolean hasNext() 判断是否仍有元素
  E next() 返回迭代的下一个元素
  2.增强for（foreach）遍历
• Map集合遍历方法
  1.通过keySet遍历key，返回的是key的一个set集合
  map.keySet()返回的是所有key的值
  遍历set集合，通过map.get(key)得到每个key对应value的值
  • Set集合遍历有迭代器遍历和增强for

  // 迭代器
          Iterator<String> it = set.iterator();
          // 迭代器遍历set集合
          while (it.hasNext()) {
              String key = it.next();
              Integer value = map.get(key);
              System.out.println(key + ":" + value);
          }
         
          // 增强for遍历set集合
          for (String key : set) {
              System.out.println(key+":"+map.get(key));
          }
  

  2.Map.Entry:在Map接口中有一个内部接口Entry，用来记录键与值；通过entrySet方法返回的是一个关于Entry的Set集合；遍历Set集合，得到，Entry对象，通过Entry中的getkey()和getvalue()方法来获取

  Set<Map.Entry<String, Integer>> set1 = map.entrySet();
   // 迭代器遍历set集合
   Iterator<Map.Entry<String, Integer>> it1 = set1.iterator();
   while (it1.hasNext()) {
       Map.Entry<String, Integer> entry = it1.next();
       System.out.println(entry.getKey() + ":" + entry.getValue());
   }
   // 增强for遍历set集合
   for (Map.Entry<String, Integer> entry : set1) {
       System.out.println(entry.getKey()+":"+entry.getValue());
   }
  

Collection集合的工具类Collections

1. 概述
   针对集合进行操作的工具类，方便我们使用。都是静态的方法
2. Collections成员方法（需要掌握的方法）

static <T> boolean addAll(Collection<T> c, T... elements)添加元素
static <T>  sort(List<T> list) 排序  默认是自然排序，升序
static <T> void sort​(List<T> list, Comparator<? super T> c) 根据指定的比较器引起的顺序对指定的列表进行排序。  
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)  二分查找
static void reverse(List<?> list) 反转
static void shuffle(List<?> list) 随机排列集合中的元素
static T <T extends Object & Comparable<? super T>> max(Collection<? extends T> coll)  最大值

使用集合存储数据

1. HashSet和 HashMap等具有元素唯一性的时候(集合存储自定义对象)：
   必须重写equals和hashCode方法，确保元素唯一
2. Set集合自定义对象排序
   1.实现Comparable接口，重写compareTo方法
   排序规则：
   return 0表示相同
   自己(this)-参数：升序，反之倒序
   2.实现Comparator接口，重写compare方法
   排序规则：
   第一个参数-第二个参数：升序，反之倒序
   区别：
   Comparable:自己(this)和参数比较，需要实现comparable接口，重写compareTo方法
   Comparator：相当于找一个第三方裁判来比较俩个
   3.存储自定义对象