集合框架1

概述

由于数组是固定长度的，并且无法存储不同的数据类型，因此就有了集合的诞生。Java 中的集合不是由⼀个类来完成的，⽽是由⼀组接⼝和类构成了⼀个框架体系。⼤致可分为 3 层，最上层是⼀组接⼝，继⽽是接⼝的实现类。java集合主要由collection和map组成。

接口类别

1. Collection：集合框架最基础的接⼝，最顶层的接⼝。
2. List：Collection 的⼦接⼝，存储有序、不唯⼀（元素可重复）的对象，最常⽤的接⼝。
3. Set：Collection 的⼦接⼝，存储⽆序、唯⼀（元素不可重复）的对象。
4. Map：独⽴于 Collection 的另外⼀个接⼝，最顶层的接⼝，存储⼀组键值对象，提供键到值的映射。
5. Iterator：输出集合元素的接⼝，⼀般适⽤于⽆序集合，从前往后输出。
6. ListIterator：Iterator ⼦接⼝，可以双向输出集合中的元素。
7. Enumeration：传统的输出接⼝，已经被 Iterator 取代。
8. SortedSet：Set 的⼦接⼝，可以对集合中的元素进⾏排序。
9. SortedMap：Map 的⼦接⼝，可以对集合中的元素进⾏排序。
10. Queue：队列接⼝。
11. Map.Entry：Map 的内部接⼝，描述 Map 中存储的⼀组键值对元素。

注：collection接口一般不直接使用，仅提供规范。

Collection

List接口

常用方法

T get(int index) 通过下标返回集合中对应位置的元素

T set(int index,T element) 在集合中的指定位置存⼊对象

int indexOf(Object o) 从前向后查找某个对象在集合中的位置

int lastIndexOf(Object o) 从后向前查找某个对象在集合中的位置

ListIterator listIterator() 实例化 ListIterator 接⼝，⽤来遍历 List 集合

List subList(int fromIndex,int toIndex) 通过下标截取 List 集合

Array List

ArrayList 是开发中使⽤频率最⾼的 List 实现类，实现了⻓度可变的数组，在内存中分配连续空间，所以读取快，增删慢。

      ArrayList list = new ArrayList();
        list.add("Hello");
        list.add("World");
        System.out.println("list is :"+list);
        System.out.println("list 长度 为:" + list.size());
        System.out.println("list 是否包含Hello" + list.contains("Hello"));
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

linkedList

linkedList实现先进先出的队列，采用链表的形式实现。链表在内存中的存储空间是不连续的，查询数据只能从第一位开始，但删除数据只需更改前后指针。因此，查询慢，增删快。

        LinkedList linkedList = new LinkedList();
        linkedList.add("Hello");
        linkedList.add("Java");//尾部添加
        System.out.println(linkedList);
        linkedList.offer("javeEE");//最后一个位置添加
        linkedList.push("Spring Boot!");//头部添加
        linkedList.pop();//队列先进先出
        System.out.println(linkedList);

Set

TreeSet

存储有序、唯一的数据，有序是指存储进入TreeSet的数据，都会自动进行升序排序。

 TreeSet treeSet = new TreeSet();
        treeSet.add(2);
        treeSet.add(1);
        treeSet.add(5);
        treeSet.add(3);
        treeSet.add(4);
        System.out.println(treeSet);

Map

键值对进行存储。Map中的键值不能重复，否则会覆盖原数据。

HashMap(非线程安全)

存储⼀组⽆序，key 不可以重复，value 可以重复
的元素。(性能较高)

Map<Integer,String> m1 = new HashMap<Integer, String>();
Map<Integer, String> m2 = new HashMap<Integer, String>();
		m2.put(4, "四");
		m2.put(5, "五");
		
		m1.put(1,"one"); //插入一个元素
		m1.put(2,"two");
		m1.put(3,"three");

		m1.putAll(m2);//插入一个Map中的所有元素
		
		System.out.println(m1.get(1));//根据键值得到元素值
		System.out.println(m1.containsKey(1));//判断是否包含某个键
		System.out.println(m1.containsValue("one"));//判断是否包含某个值

Hashtable（线程安全）

存储⼀组⽆序，key 不可以重复，value 可以重复
的元素。(性能较低)被关键字Synchronized修饰。

  Hashtable hashtable = new Hashtable();
        new Thread(()->{
            hashtable.put(1,"Hello");
        }).start();
        new Thread(()->{
            hashtable.put(2,"World");
        }).start();
        new Thread(()->{
            hashtable.put(3,"Hi");
        }).start();
        new Thread(()->{
            hashtable.put(4,"May");
        }).start();
        new Thread(()->{
            hashtable.put(5,"Day");
        }).start();
        new Thread(()->{
            hashtable.put(6,"!");
        }).start();
        System.out.println(hashtable);

迭代器删除Map元素

for (Iterator<Long> iterator = locationAmountVoHashMap.keySet().iterator(); iterator.hasNext();){
            Long key = iterator.next();
            if(locationAmountVoHashMap.get(key).getAmount()==0)
                iterator.remove();
        }```