Java集合类--List集合,Set集合,Map集合

集合 可以看作一个容器 ,Java中提供了不同的集合类,这些类具有不同的存储对象的方式,同时提供了相应的方法,以便用户对集合进行遍历、添加、删除、查找指定的对象。

1.集合类概述:

集合类类似于数组,与数组不同的是,数组的长度是固定的,集合的长度是可变的数组用来存放基本类型数据,集合用来存放对象的引用。

1.1 常用集合:

1.1.1 List集合

List集合继承了Collection接口

1.1.2 Set集合

List集合继承了Collection接口

1.1.3 Map集合

2.Collection接口

Collection接口是集合类层次结构中的根接口,Collection接口通常不能直接使用,但该接口提供了添加元素,删除元素,管理数据的方法。因为Set和List集合都继承了Collection接口,所以Set集合和List集合都具备这些增删改查方法。

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

java 复制代码
package setclass;

import java.util.*;     //导入java.util包,所有使用集合的实例都要添加该语句

public class Muster {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();   // 实例化集合类对象
        list.add("a");  //向集合中添加数据
        list.add("b");
        list.add("c");
        Iterator<String> it = list.iterator();  //创建list这个集合的迭代器
        while (it.hasNext()) {      //判断是否有下一个元素
            String str = (String) it.next();    //迭代器.next()方法用于获取下一个元素
            System.out.println(str);
        }
    }
}

输出:
        a
        b
        c

iterator的next()方法返回的是Object对象。

3.List集合

List集合包含List接口及List接口的所有实现类。List集合允许元素重复,类似Java数组,可通过索引访问List集合中的元素。

3.1 List接口

List接口因为继承了Collection接口,所以具备Collection接口的所有方法,除此之外,List接口还额外实现了2种非常重要的方法:

3.1.1 get(int index):获取指定索引位置元素

3.1.2 set(int index, object obj):修改集合中指定索引位置处的元素为object;

3.2 List接口的实现类

3.2.1 ArrayList

优点:

ArrayList类实现了可变数组,允许保存所有元素,包括null,并可以根据索引位置对集合进行快速的随机访问;

缺点:

向指定的索引位置插入对象或者删除对象的速度较慢。

ArrayList类实现List接口的语法:
List<E > list = new ArrayList<>();

E可以是Java合法的数据类型,如String;

3.2.2 LinkedList

优点:

LinkedList类采用链表结构保存对象。便于向集合中插入/删除对象,这种LinkedList类效率较高;

缺点:

对于根据索引位置随机访问集合中的对象,LinkedList类实现List集合的效率较低;

LinkedList类实现List接口的语法:
List<E e> list = new LinkedList<>();

E可以是Java合法的数据类型,如String;

java 复制代码
package setclass;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Gather {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();  //创建集合对象
        list.add("a");
        list.add("b");
        list.add("c");
        int i = (int) (Math.random() * list.size());   //根据结合长度获取0~2之间的随机数
        System.out.println("随机获得集合中的元素:" + list.get(i));
        list.remove(2); //将索引为2的位置的元素从集合中移除
        System.out.println("将索引为2位置的元素移除后,集合的元素有:");
        Iterator<String> it = list.iterator();
        int j = 0;
        while (j < list.size()) {
            System.out.println(list.get(j));
            j++;
        }
    }
}

输出:
        随机获得集合中的元素:c
        将索引为2位置的元素移除后,集合的元素有:
        a
        b

4.Set集合

Set集合对象不按特定的方式排序,只是简单地将对象加入集合中,但是Set集合中不能有重复对象;Set集合由Set接口和实现Set接口的实现类组成。Set接口也继承了Collection类,所以实现Set接口的集合类也包含Collection相关的方法。

4.1 Set接口

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

4.2 Set接口的实现类

4.2.1 HashSet

HashSet类实现Set接口,由哈希表(实际上就是一个HashMap实例)支持,不保证Set集合的迭代顺序,此类允许使用null元素。

4.2.2 TreeSet

TreeSet不仅实现了Set接口,还实现了java.utl.SortedSet接口,因此TreeSet实现的Set集合在遍历时按照自然顺序递增排序,也开一按照指定比较器递增排序。

|----------------------------------------|--------------------------------------------------------|
| 方法 | 功能描述 |
| first() | 返回此Set集合中第一个(最低)元素 |
| last() | 返回此Set集合中最后一个(最高)元素 |
| comparator() | 返回对此Set集合中元素进行排序的比较器,如果此Set使用自然排序,则返回null |
| headSet(E toElement) | 返回一个新的Set集合,新集合是toElement(不包含)之前的所有对象 |
| tailSet(E fromElement) | 返回一个新的Set集合,新集合是fromElement(包含)之后的所有对象 |
| subSet(E fromElement, E toElement) | 返回一个新的Set集合,新集合是fromElementn(包含)到toElement(不包含)之间的所有对象 |
[TreeSet类增加的方法]

java 复制代码
package setclass;

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

public class updateStu implements Comparable<Object> {   //创建类,实现Comparator接口
    String name;
    long id;

    public updateStu(String name, int id) {      //构造方法
        this.name = name;
        this.id = id;
    }

    public int compareTo(Object o) {
        updateStu up_stu = (updateStu) o;
        int result = id > up_stu.id ? 1 : (id == up_stu.id ? 0 : -1);   //对比两个对象id大小
        return result;
    }

    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) {
        updateStu stu1 = new updateStu("春田1", 101);
        updateStu stu2 = new updateStu("春田2", 102);
        updateStu stu3 = new updateStu("春田3", 103);
        updateStu stu4 = new updateStu("春田4", 104);

        TreeSet<updateStu> tree = new TreeSet<>();
        tree.add(stu1);
        tree.add(stu2);
        tree.add(stu3);
        tree.add(stu4);

        Iterator<updateStu> it = tree.iterator();       //Set集合中所有对象的迭代器
        System.out.println("TreeSet集合中的所有元素:");
        while (it.hasNext()) {
            updateStu up_stu = (updateStu) it.next();
            System.out.println(up_stu.getId() + " " + up_stu.getName());
        }

        it = tree.headSet(stu3).iterator();    //截取stu2对象之前的所有对象集合
        System.out.println("截取前面的部分集合:");
        while (it.hasNext()) {
            updateStu up_stu = (updateStu) it.next();
            System.out.println(up_stu.getId() + " " + up_stu.getName());
        }

        it = tree.subSet(stu1, stu3).iterator();
        System.out.println("截取中间部分的集合:");
        while (it.hasNext()) {
            updateStu up_stu3 = (updateStu) it.next();
            System.out.println(up_stu3.getId() + " " + up_stu3.getName());
        }
    }
}

输出:
        TreeSet集合中的所有元素:
        101 春田1
        102 春田2
        103 春田3
        104 春田4
        截取前面的部分集合:
        101 春田1
        102 春田2
        截取中间部分的集合:
        101 春田1
        102 春田2

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

5.Map集合

Map集合提供的是key-value的映射关系,Map中不能包含相同的key,可以有相同的value,Map集合包含Map接口以及Map接口的所有实现类。

Map结合中允许值对象时null,而且允许多个。

5.1 Map接口

|-------------------------------|--------------------------------------------|
| 方法 | 功能描述 |
| put(K key, V value) | 向集合中添加指定的key-value的映射关系 |
| get(Object key) | 获取key的对象,如果存在指定的key对象,则返回该key对象的值,否则返回null |
| containsKey(Object key) | 如果此集合包含指定key的映射关系,则返回true,否则返回false |
| containsValue(Object key) | 如果此集合包含指定value的映射关系,则返回true,否则返回false |
| keySet() | 返回此集合中所有key对象形成的Set集合 |
| valueSet() | 返回该集合中所有值对象形成的Collection集合 |
[Map接口中的常用方法]

java 复制代码
package mapclass;

import java.util.*;

public class UpdateStu {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();  //创建map实例
        map.put("01", "春田1");
        map.put("02", "春田2");

        Set<String> set = map.keySet(); //构建所有key对象的集合
        Iterator<String> it = set.iterator();   //构建集合迭代器
        System.out.println("key集合中的元素:");
        while (it.hasNext()) {
            String stu = it.next();
            System.out.println(stu);
        }

        Collection<String> coll = map.values(); //构建Map集合中所有values值的集合
        it = coll.iterator();
        System.out.println("value集合中的元素:");
        while (it.hasNext()) {
            String stu = it.next();
            System.out.println(stu);
        }
    }
}

输出:
        key集合中的元素:
        01
        02
        value集合中的元素:
        春田1
        春田2

5.2 Map接口的实现类

Map接口的实现类有HashMap和TreeMap。

5.2.1 HashMap

HashMap类是基于hash表的Map接口实现,HashMap通过哈希码对其内部的映射关系进行快速查找,并允许使用null键和null值,但是必须保证键的唯一性。

优点:

HashMap类实现的Map集合添加和删除映射关系效率更高;

缺点:

此类不保证映射的顺序;

5.2.2 TreeMap

TreeMap类不仅实现了Map接口,还实现了java.util.SortedMap接口,因此,集合中的映射关系具有顺序。

优点:

集合中的映射关系具有顺序;

缺点:

在添加、删除、定位映射关系时,效率较低,且不允许键为null;

java 复制代码
package mapclass;

import java.util.*;

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

        Emp emp = new Emp("105", "春田1");     //创建Mmp对象
        Emp emp1 = new Emp("103", "春田2");
        Emp emp2 = new Emp("101", "春田3");
        Emp emp3 = new Emp("102", "春田4");
        Emp emp4 = new Emp("104", "春田5");

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

        Set<String> key_set = map.keySet();     //获取Map集合中的所有Key对象集合
        Iterator<String> it = key_set.iterator();       //获取keyset集合对象迭代器
        while (it.hasNext()) {
            String key_str = (String) it.next();
            String name = (String) map.get(key_str);     //通过key获取Map对象value
            System.out.println(key_str + " " + name);
        }

        TreeMap<String, String> tree_map = new TreeMap<>();  //创建TreeMap集合对象
        tree_map.putAll(map);       //将集合对象map添加到TreeMap集合对象中
        Iterator<String> iter = tree_map.keySet().iterator();
        System.out.println("TreeMap类实现的Map集合,键对象升序:");
        while (iter.hasNext()) {
            String key_treemap_str = (String) iter.next();
            String name = tree_map.get(key_treemap_str);
            System.out.println(key_treemap_str + " " + name);
        }

    }
}

输出:
        101 春田3
        102 春田4
        103 春田2
        104 春田5
        105 春田1
        TreeMap类实现的Map集合,键对象升序:
        101 春田3
        102 春田4
        103 春田2
        104 春田5
        105 春田1
相关推荐
tellmewhoisi7 分钟前
java8 List常用基本操作(去重,排序,转换等)
java·list
love530love8 分钟前
命令行创建 UV 环境及本地化实战演示—— 基于《Python 多版本与开发环境治理架构设计》的最佳实践
开发语言·人工智能·windows·python·conda·uv
陪我一起学编程30 分钟前
MySQL创建普通用户并为其分配相关权限的操作步骤
开发语言·数据库·后端·mysql·oracle
麦子邪32 分钟前
C语言中奇技淫巧04-仅对指定函数启用编译优化
linux·c语言·开发语言
都叫我大帅哥37 分钟前
TOGAF应用架构阶段全解析:从理论到Java代码实战
java
Amagi.1 小时前
Java设计模式-建造者模式
java·设计模式·建造者模式
破刺不会编程1 小时前
linux线程概念和控制
linux·运维·服务器·开发语言·c++
EmpressBoost1 小时前
谷粒商城170缓存序列化报错
java·spring·缓存
henreash1 小时前
NLua和C#交互
开发语言·c#·交互
fouryears_234171 小时前
@PathVariable与@RequestParam的区别
java·spring·mvc·springboot