集合

集合

• 集合又被称为容器

• 集合与数组的区别：

数组的长度是固定的； 用来存放基本类型的数据

集合的长度是可变的；用来存放对象的引用

常用的集合有：

List集合、Set集合、Map集合，其中List 和 Set 继承了 COllection (Collection 接口是层次结构中的根接口，构成 Collection 的单位称为元素)

继承关系图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2NGIH5sJ-1618404892769)(C:\Users\34747\Desktop\屏幕截图\屏幕截图 2021-04-14 092828.png)]

Collection

• Collection 接口的常用方法

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

例：

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();  //实例化集合类对象
        list.add("jiang");  //add 添加对象
        list.add("zi");
        list.add("wen");
        Iterator<String> it = list.iterator();  //创建迭代器
        while(it.hasNext()){                    //判断是否有下一个元素
            String str = (String) it.next();    //获取集合中的元素
            System.out.println(str);
        }
    }
输出结果：jiang
         zi
         wen

List集合

• List 集合包括 List接口以及 List接口的所有实现类。List集合中的元素允许重复，各元素的顺序就是对象插入的顺序。
• 和数组一样，用户可以通过索引(下标)来访问集合中的元素

get(int index) ：获得指定下标位置的元素

set(int index ,Object obj):将集合中指定下标位置的对象修改为指定对象

• List接口的实现类

ArrayList 类实现了可变的数组，允许保存所有元素，包括null，并可以根据索引位置对集合进行快速的随机访问；缺点是向指定的索引位置插入对象或删除对象的速度较慢

LinkedList 类采用链表结构保存对象。这种结构的优点是便于向集合中插入和删除对象，需要向集合中插入或删除对象时，使用LinkedList类实现List集合的效率较高；对于随机访问集合中的对象时，使用LinkedList 类实现List集合的效率较低

• 分别通过ArrayList 、LinkedList 类实例化集合：

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

List<E> list2 = new LinkedList<>();

//创建Gather类，在main方法中创建集合对象，通过Math类的random()方法随机获取集合中的某个元素，然后移除索引是'2'的元素，最后便利数组
public class Gather {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();    //创建集合对象
        list.add("j");     //add 添加对象
        list.add("Z");
        list.add("w");
        int i = (int)(Math.random()*list.size());       //获得下标0~2之间的随机数字a
        System.out.println("随机获取的元素: "+ list.get(i));
        list.remove(2);                     //remove: 删除指定下标的对象
        System.out.println("将索引是'2'的元素删除后数组的元素为：");
        for (int j = 0; j < list.size(); j++) {    //循环遍历集合
            System.out.println(list.get(j));
        }
    }
}

与数组相同，索引从0开始

---

---

Set集合

• Set 集合中的对象不按特定的方式排序，只是简单的把对象加入集合中，但是Set集合不能出现重复的对象。
• Set 集合由Set接口和Set接口的实现类组成。Set接口继承了Collection接口，因此包含Collection接口的所有方法

Set接口常用的实现类有HashSet类和TreeSet类

• HashSet类实现Set接口，由哈希表（实际上是一个HashMap实例）支持。他不保证Set的迭代顺序，特别是他不保证该顺序一直不变（无序）。此类允许使用null元素

• TreeSet类不仅实现了Set接口，还实现了java.util.SortedSet接口，因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序，也可以按照指定比较器递增排序（自动排序）

• TreeSet 类增加的方法

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

例：

//创建类UpdateStu，实现Comparable 接口，重写该接口中的compareTo()方法。在主方法中创建UpdateStu对象，创建集合，并将UpdateStu对象添加到集合中。遍历该集合中的所有元素，并且通过 headSet()和subSet()方法获得相应的集合

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

public class UpdateStu implements Comparable<Object>{  //创建类实现Comparable 接口


    String name;
    Long id;

    public UpdateStu(String name,Long id){  //构造方法
        this.id = id;
        this.name = name;
    }
    public int compareTo(Object o){
        UpdateStu upstu = (UpdateStu) o;
        int result = id>upstu.id ? 1 :(id == upstu.id ? 0 : -1);   //参照代码说明
        return result;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public Long getld(){
        return id;
    }
    public void setld(long id){
        this.id = id;
    }


    public static void main(String[] args) {
        UpdateStu stu1 = new UpdateStu("李同学", 01011L);     //创建 UpdateStu 对象
        UpdateStu stu2 = new UpdateStu("陈同学", 01021L);
        UpdateStu stu3 = new UpdateStu("王同学", 01051L);
        UpdateStu stu4 = new UpdateStu("马同学", 01012L);
        TreeSet<UpdateStu> tree = new TreeSet<>();
        tree.add(stu1);                    //add 向集合添加对象
        tree.add(stu2);
        tree.add(stu3);
        tree.add(stu4);
        Iterator<UpdateStu> it = tree.iterator();      //Set 集合中的所有对象的迭代器
        System.out.println("Set中的所有元素：");
        while(it.hasNext()){                            //遍历集合
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getld()+" "+stu.getName());
        }
        it = tree.headSet(stu2).iterator();               //截取排在stu2对象之前的对象
        System.out.println("截取前面部分的集合：");
        while(it.hasNext()){                         //遍历集合 
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getld()+" "+stu.getName());
        }
        it = tree.subSet(stu2,stu3).iterator();         //截取排在stu2和stu3之间的对象
        System.out.println("截取中间部分的集合：");
        while(it.hasNext()){                           //遍历集合
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getld()+" "+stu.getName());
        }
    }
}
输出结果：
Set中的所有元素：
521 李同学
522 马同学
529 陈同学
553 王同学
截取前面部分的集合：
521 李同学
522 马同学
截取中间部分的集合：
529 陈同学

存入TreeSet类实现的Set集合必须实现Comparable接口，该接口中的compareTo()方法比较此对象与指定对象的顺序。如果该对象小于、等于、或大于指定对象，则分别返回负整数、0、或正整数。

---

---

Map集合

• Map 集合没有继承Collection接口，其提供的是key到value的映射。Map中不能包含相同的key，每个key只能映射一个value。key还决定了存储对象在映射中的存储位置，但不是由key对象本身决定的，而是通过一种“散列技术”进行处理，产生一个散列码的整数值。

• 散列码通常用作一个偏移量，该偏移量对应分配给映射的内存区域的起始位置，从而确定存储对象在映射中的存储位置。

• Map接口

Map接口提供了将key映射到值得对象。一个映射不能包含重复得key，每个key最多只能映射到一个值。

• 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集合

例：

//创建类，在主方法中创建map集合，并获取集合中所有key对象的集合和所有values值得集合

public class MapTest<S, S1> {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();     //创建Map实例
        map.put("01","李同学");      //put 向集合中添加元素
        map.put("02","魏同学");
        Set<String> set = map.keySet();     //构建Map集合中所有key对象的集合
        Iterator<String> it = set.iterator();  //创建集合迭代器
        System.out.println("key集合中的元素：");
        while(it.hasNext()){                //遍历集合
            System.out.println(it.next());
        }
        Collection<String> coll = map.values();   //构建Map集合中所有values 值的集合
        it = coll.iterator();
        System.out.println("value中的元素：");
        while(it.hasNext()){         //遍历集合
            System.out.println(it.next());
        }
    }
}

输出结果：
key集合中的元素：
01
02
value中的元素：
李同学
魏同学

Map集合中允许值对象是null，而且没有个数限制。例如，可以通过"map.put(“05”,null);" 来向集合中添加对象

• Map接口的实现类

Map接口常用得实现类有 HashMap 和 TreeMap。建议使用 HashMap 类实现Map集合，因为由 HashMap 类实现的 Map 集合添加和删除映射关系效率更高

• HashMap 是基于哈希表的Map接口的实现，HashMap通过哈希码对其内部的映射关系进行快速查找

• 而TreeMap 中的映射关系存在一定的顺序，如果希望Map集合中的对象也存在一定的顺序，应该使用TreeMap类实现Map集合

• HashMap 类是基于哈希表的Map接口的实现，此实现提供所有可选的映射操作，并允许使用null值和null键，但必须保证键的唯一性。HashMap 通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序，特别是它不保证该顺序一直不变（无序）

• TreeMap 类不仅实现了Map接口，还实现了java.util.SortedMap 接口，因此，集合中的映射具有既定的映射顺序。但在添加、删除、定位映射关系时，TreeMap 类比 HashMap 类性能较差。由于TreeMap 类实现的Map集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是null

例：

//创建Emp类
public class Emp {
    private String e_id;
    private String e_name;
    public Emp(String e_id,String e_name){
        this.e_id = e_id;
        this.e_name = e_name;
    }
   //get、set方法
    public String getE_id() {
        return e_id;
    }

    public void setE_id(String e_id) {
        this.e_id = e_id;
    }

    public String getE_name() {
        return e_name;
    }

    public void setE_name(String e_name) {
        this.e_name = e_name;
    }
}

//创建一个用于测试的主类。先创建一个Map集合，并添加集合对象。分别遍历由HashMap类与TreeMap类实现的Map集合
import java.util.*;

public class MapText {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();          //由HashMap 实现的 Map集合

        Emp emp = new Emp("315","张三");       //创建Emp对象
        Emp emp2 = new Emp("512","李四");
        Emp emp3 = new Emp("853","王一");
        Emp emp4 = new Emp("125","赵六");
        Emp emp5 = new Emp("341","黄七");

        map.put(emp4.getE_id(),emp4.getE_name());           //将对象添加到集合中
        map.put(emp5.getE_id(),emp5.getE_name());
        map.put(emp.getE_id(),emp.getE_name());
        map.put(emp2.getE_id(),emp2.getE_name());
        map.put(emp3.getE_id(),emp3.getE_name());

        Set<String> set = map.keySet();                     //获取Map集合中的Key对象集合
        Iterator<String> it = set.iterator();
        System.out.println("HashMap 类实现的Map集合，无序：");
        while(it.hasNext()){                                 //遍历Map集合
            String str = (String) it.next();
            String name = (String) map.get(str);
            System.out.println(str+" "+ name);
        }
        TreeMap<String,String> treemap = new TreeMap<>();         //创建TreeMap 集合对象
        treemap.putAll(map);                                        //向集合添加对象
        Iterator<String> iter = treemap.keySet().iterator();
        System.out.println("TreeMap 类实现的Map集合，键对象升序：");
        while(iter.hasNext()){                               //遍历集合
            String str = (String) iter.next();              //获取集合中所有key对象
            String name = (String) treemap.get(str);        //获取集合中所有values值
            System.out.println(str + " "+ name);
        }
    }
}
输出结果：
HashMap 类实现的Map集合，无序：
341 黄七
125 赵六
512 李四
853 王一
315 张三
TreeMap 类实现的Map集合，键对象升序：
125 赵六
315 张三
341 黄七
512 李四
853 王一