java之集合类温故而知新

1 集合体系结构

1.1 集合类的特点

集合是一种提供存储空间可变的存储模型 , 存储的数据容量可以随时发生变化

1.2 单例集合类体系图

由图可见 , Collection 是所有单例集合的父类 ,也可以说是单例集合的顶级接口, 它表示的是一组对象，这些对象也称为Collection的元素。同时JDK不提供Collection任何的直接实现方式，只提供的有子接口的实现如我们常用的List/Set集合；

1.3 双例集合体系图

由图可见 , Map 是所有双例集合的父类，Map是键值对的集合接口，它的实现类主要包括：HashMap,TreeMap,Hashtable以及LinkedHashMap等。

1.4 Collection集合的常用方法

Collection 是所有单例集合的顶级父类，所以 Collection 的方法既是所以单列集合的共有方法。

方法名	说明	介绍	返回值
boolean add(E e)	添加元素	collection.add(“collection”);	true/false
boolean remove(Object o)	从集合中移除指定的元素	collection.remove(“collection”); 或者指定索引 collection.remove(1);	true/false
void clear()	清空集合中的元素	collection.clear();	/
boolean contains(Object o)	判断集合中是否存在指定的元素	collection.contains(“collection”);	true/false
int size()	集合的长度，也就是集合中元素的个数	collection.size();	int

import java.util.ArrayList;
import java.util.Collection;


/**
 * @Author: MyWang
 * @introduce: Collection 集合创建
 * @Date: 2020/9/14 10:34
 */
public class Demo1 {

    public static void main(String[] args) {
        //创建 Collection 集合,使其指向它的子接口
        Collection<String> collection = new ArrayList<String>();
        //添加元素
        collection.add("collection");
        collection.add("List");
        collection.add("ArrayList");
        //遍历输出
        collection.forEach(System.out::print);
        
    }

}

1.5 Map集合：

1.5.1 Map集合的特点

1.Map是一个双列集合，一个元素包含两个值（key与value）。
2.Map集合中的元素，key与value的数据类型可以相同，也可以不同。
3.Map中的元素，key是不可重复的，value是允许重复。
4.Map中的key与value一一对应

import java.util.*;


/**
 * @Author: MyWang
 * @introduce: 集合类温故而知新
 * @Date: 2020/9/14 10:34
 */
public class Demo1 {

    public static void main(String[] args) {

        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //V put(K key, V value) 将指定的值与该映射中的指定键相关联
        map.put("001","Map");
        map.put("002","HashMap");
        map.put("003","LinkedMap");
        map.put("003","LinkedHashMap");

        //输出集合对象
        System.out.println(map);
    }

}

1.5.2 Map集合的基本功能

方法名	说明	介绍	返回值
V put(K key,V value)	添加元素	map.put(“001”,“Map”);	V
V remove(Object key)	根据键删除键值对元素	map.remove(“003”);	V
void clear()	移除所有的键值对元素	map.clear() ;	/
boolean containsKey(Object key)	判断集合是否包含指定的键	map.containsKey(“001”);	true/false
boolean containsValue(Object value)	判断集合是否包含指定的值	map.containsValue(“Map”);	true/false
boolean isEmpty()	判断集合是否为空	map. isEmpty();	true/false
int size()	集合的长度，也就是集合中键值对的个数	map.size();	int

import java.util.*;


/**
 * @Author: MyWang
 * @introduce: 集合类温故而知新
 * @Date: 2020/9/14 10:34
 */
public class Demo1 {

    public static void main(String[] args) {

        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //V put(K key,V value)：添加元素
        map.put("001", "Map");
        map.put("002", "HashMap");
        map.put("003", "LinkedHashMap");

        //V remove(Object key)：根据键删除键值对元素
        System.out.println(map.remove("002"));
        System.out.println(map.remove("004"));

        //void clear()：移除所有的键值对元素
        map.clear();

        //boolean containsKey(Object key)：判断集合是否包含指定的键
        System.out.println(map.containsKey("002"));
        System.out.println(map.containsKey("004"));

        //boolean isEmpty()：判断集合是否为空
        System.out.println(map.isEmpty());

        //int size()：集合的长度，也就是集合中键值对的个数
        System.out.println(map.size());


        //输出集合对象
        System.out.println(map);
    }

}

1.5.3 Map集合的获取功能

方法名	说明	介绍	返回值
V get(Object key)	根据键获取值	map.get(“001”);	V
Set keySet()	获取所有键的集合	map.keySet();	Set
Collection values()	获取所有值的集合	map.values();	Collection
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合	map.entrySet();	Set<Map.Entry<K,V>>

		//创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("001", "Map");
        map.put("002", "HashMap");
        map.put("003", "LinkedHashMap");

        //V get(Object key):根据键获取值
        System.out.println(map.get("001"));
        System.out.println(map.get("002"));

        //Set<K> keySet():获取所有键的集合
        Set<String> keySet = map.keySet();
        keySet.forEach( System.out::println);

        //Collection<V> values():获取所有值的集合
        Collection<String> values = map.values();
        values.forEach( System.out::println);

        //Set<Map.Entry<K,V>>   entrySet():获取所有键值对的集合
        Set<Map.Entry<String, String>> entries = map.entrySet();
        entries.forEach( System.out::println);

4 数据结构

2.1 数据结构之栈和队列

栈结构：

• 先进后出，相当于双向管道，左边进右边出。

队列结构:

• 先进先出，相当于单向管道，从哪进从哪处，先进来的在下面等后进来的先出去才能出去。

2.2 数据结构之数组和链表

数组结构:

• 数组查询元素：知道第一个按顺序遍历。
• 数组增加元素：如果需要给index为10的位置添加，则从index为11的位置开始所有元素往后移。
• 数组删除元素：如果需要删除index为10的位置，则从index为11的位置开始所有元素往前移。
  总结：数组里的元素是连续的，所以数组查询快、增删慢。

队列结构:

• 链表查找：当同时读取所有元素时，链表的效率很高，读第一个，读第二个，以此类推。但当你需要跳跃，链表的效率就很低了，每次都必须从第一个开始往后一个一个查找。
• 链表增加元素：只需要修改它前面的那个元素指向的堆的地址就可以了。
• 链表删除元素：只需要将前一个元素指向的堆的地址更改即可。
  总结：链表的每个元素都存储了下一个元素的地址，从而使得一系列的随机的内存地址串在了一起，只要有足够的内存空间，就能为链表分配内存。所以链表查询慢、增删快。

3 List集合

3.1 List集合概述和特点

List集合概述:

• List集合石有序集合也被称之为序列，用户可以精确控制集合中每个元素的插入位置同时用户可以通过正整数索引访问元素，并搜素列表中的元素。
• 与Set集合不同，List集合允许有相同的元素存在，即重复的数据。
  总结刚刚所说，List集合的特点可以总结为：1.有序 ，2.有索引，3.可重复。

3.2 List集合的特有方法

方法名	说明	介绍	返回值
void add(int index,E element)	在此集合中的指定位置插入指定的元素	list.add(0 , “list”);	/
E remove(int index)	删除指定索引处的元素，返回被删除的元素	list.remove(1);	E
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素	list.set(0 , “String”);	E
E get(int index)	返回指定索引处的元素	list.get(0);	E

3.3 List集合子类的特点

3.3.1 ArrayList集合

1. ArrayList是基于数组实现，是一个动态的数组队列。但是它和Java中的数组又不一样，它的容量可以自动增长，类似于C语言中动态申请内存，动态增长内存。
2. ArrayList的初始化容量 = 10 ，最大容量不会超过 MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8！
3. ArrayList实现java.io.Serializable的方式。当写入到输出流时，先写入“容量”，再依次写入“每一个元素”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。
4. ArrayList基于数组实现，可以通过下标索引直接查找到指定位置的元素，因此查找效率高，但每次插入或删除元素，就要大量地移动元素，插入删除元素的效率低。
5. ArrayList集中中允许有unll 的存在

3.3.2 LinkedList集合

1. LinkedList的实现是基于双向循环链表，实现的 List和Deque 接口。实现所有可选的列表操作，并允许所有元素（包括null）。
2. LinkedList是非线程安全的，只在单线程下适合使用。
3. LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆。
4. 由于是基于列表的，LinkedList的没有扩容方法！默认加入元素是尾部自动扩容。
5. LinkedList还实现了栈和队列的操作方法，因此也可以作为栈、队列和双端队列来使用。
6. LinkedList是基于链表实现的，因此插入删除效率高，查找效率低。

4 Set集合

4.1 Set集合概述和特点

1. 元素存取无序。
2. 没有索引、只能通过迭代器或增强for循环遍历。
3. 不能存储重复元素，当有重复元素的时候，后加入的元素会把前面的元素替换掉。

4.2 哈希值

哈希值简介：

• 哈希值是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值。

如何获取哈希值：

• Object类中的public int hashCode()：返回对象的哈希码值。

哈希值的特点：

• 同一个对象多次调用hashCode()方法返回的哈希值是相同的。
• 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

		//创建集合对象
        Set<String> set = new HashSet<String>();
        //添加元素
        set.add("Set");
        
        System.out.println("集合set的哈希值: " + set.hashCode());

4.3 HashSet集合概述和特点

4.3.1 HashSet集合的特点:

• 底层数据结构是哈希表。
• 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致。
• 没有带索引的方法，所以不能使用普通for循环遍历。
• 由于是Set集合，所以是不包含重复元素的集合。

4.3.2 HashSet集合保证元素唯一性源码分析（不包含重复元素）

1. 根据对象的哈希值计算存储位置:
   如果当前位置没有元素则直接存入。
   如果当前位置有元素存在，则进入第二步。
2. 当前元素的元素和已经存在的元素比较哈希值
   如果哈希值不同，则将当前元素进行存储。
   如果哈希值相同，则进入第三步。
3. 通过equals()方法比较两个元素的内容
   如果内容不相同，则将当前元素进行存储。
   如果内容相同，则不存储当前元素。

4.4 LinkedHashSet集合概述和特点

LinkedHashSet 概述：
- 哈希表和链表实现的Set接口，具有可预测的迭代次序。
- 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的。
- 由哈希表保证元素唯一，也就是说没有重复的元素。

		  //创建集合对象
          LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
  
          //添加元素
          linkedHashSet.add("hello");
          linkedHashSet.add("world");
          linkedHashSet.add("java");
          //添加重复元素
          linkedHashSet.add("world");
          
          //遍历
          linkedHashSet.forEach(System.out::println);

4.5 TreeSet集合概述和特点

TreeSet集合概述：

• 元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
  1. TreeSet()：根据其元素的自然排序进行排序
  2. TreeSet(Comparator comparator) ：根据指定的比较器进行排序
• 没有带索引的方法，所以不能使用普通for循环遍历
• 由于是Set集合，所以不包含重复元素的集合

public class TreeSetDemo01 {
      public static void main(String[] args) {
          //创建集合对象
          TreeSet<Integer> ts = new TreeSet<Integer>();
          //添加元素
          ts.add(10);
          ts.add(40);
          ts.add(30);
          ts.add(50);
          ts.add(20);
          ts.add(30);
  
         //遍历
          ts .forEach(System.out::println);
      }
  }

5 Collections集合工具类

5.1 Collections类常用方法

Collections 是针对集合操作的工具类。

5.2 Collections类常用方法

方法名	说明	介绍	返回值
public static void sort(List list)	将指定的列表按升序排序	Collections.sort(list);	/
public static void reverse(List<?> list)	反转指定列表中元素的顺序	Collections.reverse(list);	/
public static void shuffle(List<?> list)	使用默认的随机源随机排列指定的列表	Collections.shuffle(list);	/

		//创建集合对象
        List<Integer> list = new ArrayList<Integer>();

        //添加元素
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);

        //public static <T extends Comparable<? super T>> void sort(List<T> list)：将指定的列表按升序排序
        Collections.sort(list);
        System.out.println(list);

        //public static void reverse(List<?> list)：反转指定列表中元素的顺序
        Collections.reverse(list);
        System.out.println(list);

        //public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表
        Collections.shuffle(list);
        System.out.println(list);