JavaSE 集合类(Collection接口，List接口，Map接口）

集合类就好比一个容器，比如说数组就是一个可以存放数据的容器，但是数组的长度是不可变的，集合类的长度却是可变的。常用的集合有Map集合,Set集合，List集合。
List与set继承collection接口

Collection接口

Collection接口通常不能直接使用，但该接口提供了添加元素，删除元素，管理数据的方法。List接口和Set接口都继承了Collection接口，所以他们能实现Collection的方法。I
构成Collection的单位称为元素。
Collection常用方法如下

方法	功能
add(E e)	将指定的对象加到该集合中
remove(Object o)	将指定对象从该集合中移除
isEmpty()	返回boolean值，用于判断当前集合是否为空
iterator()	返回在此Collection的元素上的迭代器。用于遍历集合
size()	返回Int值，获取该集合中元素的个数

利用iterator 遍历集合

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

public class Test {
    public static void main(String[] args) {
        Collection<String> list=new ArrayList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        Iterator<String> it=list.iterator();
        while (it.hasNext()){     //判断是否有下一个元素
              String str=(String)it.next();    //获取元素    Iterator 的next()方法返回的是Object
            System.out.println(str);
        }
    }
}

List集合

List集合包括List接口以及List接口的所有实现类
List集合中的元素允许重复，各元素的顺序就是对象插入的顺序。可以通过使用索引来访问集合中的元素。

(1)List接口

List接口包含Collection接口的所有方法,此外还有两个重要方法
get(int index):获取指定索引位置的元素
set(int index,Object obj):将集合中指定索引位置的对象修改为指定的对象

(2)List接口的实现类

List接口的常用实现类有ArrayList与LInkedList
ArrayList类：实现了可变数组，允许保存所有的元素，包括null，并可以根据索引位置对集合进行快速的随机访问，缺点是向指定的索引位置插入对象或删除对象比较慢
LinkedList类：采用链表结构保存对象。这种结构的优点是便于向集合中插入和删除对象，但对于随机访问集合中的对象效率比较低
两个类的差异有点像C语言的链表顺序结构和链式结构的差异
使用List集合时通常声明为List类型，然后通过不同的类实例化集合

List<E> list=new ArrayList<>();

List<E> list=new LInkedList<>();

Set集合

Set集合中的对象不按特定的方式排序，Set集合中不能有重复对象。
Set集合由Set接口和Set接口的实现类组成。
Set接口继承了Collection接口，因此包含Collection接口的所有方法
Set接口常用的实现类有HashSet类与TreeSet类
HashSet类实现Set接口，由哈希表（实际上是一个HashMap实例）支持。他不保证Set的迭代顺序，特别是它不保证该顺序一直不变。此类允许使用null元素
TreeSet类不仅实现了Set接口，还实现了java.until.SortedSet接口，因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增顺序，也可以按照比较器递增排序，就是可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序
TreeSet增加方法

方法	功能描述
first()	返回此Set中当前第一个(最低)元素
last()	返回此Set中当前最后一个（最高）元素
comparator()	返回此Set中的元素进行排序的比较器。如果此Set使用自然排序，则返回null
headSet(E e)	返回一个新的Set集合，新集合是e(不包含）之前的所有对象
subSet(E f,E e)	返回一个新的集合，是从f（包含）到e（不包含）之间的所有对象
tailSet(E e)	返回一个新的集合，是从e（包含）之后的所有对象

package com.pkg;


import sun.reflect.generics.tree.Tree;

import java.util.Iterator;
import java.util.TreeSet;

public class Test implements Comparable<Object>{
    String name;
    long id;
    public Test(String name,long id){
        this.name=name;
        this.id=id;
    }
    @Override
    public int compareTo(Object o) {  //比较此对象与指定对象的顺序，如果该对象大于，等于或小于指定对象，分别返回正整数，0，或负整数
        Test t=(Test)o;
        return id>t.id?1:(id==t.id?0:-1);
    }
    public String getName(){
        return name;
    }
    public void SetName(String name){
        this.name=name;
    }
    public long getId(){
        return id;
    }
    public void setId(long id){
        this.id=id;
    }
    public static void main(String[] args) {
        Test t1=new Test("小明",01011);
        Test t2=new Test("小华",01021);
        Test t3=new Test("李明",01051);
        Test t4=new Test("张三",01012);
        TreeSet<Test> tree=new TreeSet<>();
        tree.add(t1);
        tree.add(t2);
        tree.add(t3);
        tree.add(t4);
        Iterator<Test> it=tree.iterator();
        System.out.println("集合中所有元素:");
        while (it.hasNext()){
             Test t=(Test) it.next();
            System.out.println(t.getId()+" "+t.getName());
        }
        it=tree.headSet(t2).iterator();
        System.out.println("截取前面的元素");
        while (it.hasNext()){
            Test t=(Test) it.next();
            System.out.println(t.getId()+" "+t.getName());
          //  System.out.println(((Test)it.next()).getId()+" "+((Test)it.next()).getName());  别这么写
        }
        it=tree.subSet(t2,t3).iterator();
        System.out.println("截取中间的元素");
        while (it.hasNext()){
            Test t=(Test) it.next();
            System.out.println(t.getId()+" "+t.getName());
        }
    }
}
输出结果：（按照id大小排序）
521 小明
522 张三
529 小华
553 李明
截取前面的元素
521 小明
522 张三
截取中间的元素
529 小华

Map集合

Map集合没有继承Collection接口，其提供key到value的映射。Map中不能包含相同的key，每个key只能映射一个value.key还决定了存储对象在影射中的存储位置，但不是由key对象本身决定的，是通过散列进行处理，产生一个散列码的整数值。散列码通常用作一个偏移量，该偏移量对应分配给映射的内存区域的起始位置，从而决定存储对象在映射中的存储位置。
Map集合包括Map接口以及Map接口的所有实现类

(1)Map接口

方法	功能
put(K key,V value	向集合中添加指定key与value的映射关系
containsKey(Object key)	如果集合中包含指定key大的映射关系，则返回true
containsValue(Object value)	如果此映射将将一个或多个key映射到指定值，则返回true
get(Object key)	返回key对应的对应值，否则返回null
keySet()	返回该集合中所有key对象形成的Set集合
values()	返回该集合中所有值对象形成的Collection集合

import java.util.*;

public class Test {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();
        map.put("01","小明");
        map.put("02","小李");
        map.put("03","小华");
        Set<String> set=map.keySet();
        Iterator<String> it=set.iterator();
        System.out.println("key集合所有元素");
        while (it.hasNext()){
            String s=(String)it.next();
            System.out.println(s);
        }
        Collection<String> collection=map.values();
        it=collection.iterator();
        System.out.println("values集合所有元素");
        while (it.hasNext()){
            String s=(String)it.next();
            System.out.println(s);
        }
    }
}
输出结果:
key集合所有元素
01
02
03
values集合所有元素
小明
小李
小华

Map接口所实现的类

Map接口实现的类有HashMap和TreeMap.建议使用HashMap类实现Map接口
HashMap类实现的Map集合添加和删除的效率更高.HashMap是基于哈希表的Map接口实现，HashMap通过哈希码对其内部的映射关系进行快速查找，而TreeMap中的映射关系存在一定的顺序，
HashMap类允许使用null值和null键，但必须保证键的唯一性。
TreeMap类不允许键对象是null
有一个putAll()方法可以将HashMap类直接添加进TreeMap

Map<K key,V value> map=new HashMap<>();
TreeMap<K key,V value> treeMap=new TreeMap<>();
treemap.putAll(map); 

来源：CSDN

作者：ReverieZH

链接：https://blog.csdn.net/weixin_44035017/article/details/101016595