Java集合框架

jule_zhou

已于 2022-08-13 13:26:54 修改

阅读量302

点赞数 1

分类专栏： # Java 后端文章标签： java jvm 数据结构

于 2022-08-06 10:51:27 首次发布

本文链接：https://blog.csdn.net/jule_zhou/article/details/126179156

版权

后端同时被 2 个专栏收录

37 篇文章 0 订阅

订阅专栏

Java

30 篇文章 1 订阅

订阅专栏

一、Java集合框架包含的内容

Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中
在这里插入图片描述
图示中List与Set继承于Collection，Map较为特殊Map是没有继承Collection接口的，Map提供key到value的映射

二、关于Collection与Map

List与Set继承于Collection接口

Map是没有继承Collection接口的

三、关于List与Set的异同

方法名	是否唯一	是否有序
List	不唯一	有序
Set	唯一	无序
Collection	不唯一	无序

List内存储图示（其内部有序，但是不需要保证是否为唯一的值）

在这里插入图片描述
如果有相同的序号的值写入，则直接覆盖

Set内存储图示（其内部无需，但是值唯一）

在这里插入图片描述
如果有相同的值存入，将会直接覆盖

1、关于List

（一）、关于List的分支

List接口的部分方法

方法名	说明
boolean add(Object o)	在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o)	在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
int size()	返回列表中的元素个数
Object get(int index)	返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
boolean contains(Object o)	判断列表中是否存在指定元素
boolean remove(Object o)	从列表中删除元素
Object remove(int index)	从列表中删除指定位置元素，起始索引位置从0开始

（二）、关于List的分支的ArrayList

创建ArrayList的基本语法1（该方法存在弊端，使用其中数据时需要进行强制数据类型转换）

// 创建ArrayList对象
List a = new ArrayList();
// 向ArrayList对象中添加参数
a.add("树木");
// 强制转换数据，然后进行赋值
String s = (String)a;

创建ArrayList的基本语法2（该方法通过范型集合的方式，可以避免后期使用强制类型转换的问题）

// 创建ArrayList对象
List<String> a = new ArrayList<>();
// 向ArrayList对象中添加参数
a.add("树木");
// 直接赋值
String s = a;

（三）、ArrayList实现add、 size、 get、 contains、 remove

代码示例
类源码：

package com.bdqn.ready;
/**
 * @authorDesc 收获源于是每一分的努力
 * @author Jule_zhou
 * @date 2022-08-05 17:15:16
 * @version
 * @description
 */
public class Pet {
    /**
     * 名字
     */
    private String name;
    /**
     * 年龄
     */
    private int age;
    /**
     * @description 有参构造
     * @author Jule_zhou
     * @date 2022-08-05 17:16:58
     * @param name
     * @param age
     * @return {@link null}
     */
    public Pet(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /**
     * @description 无参构造
     * @author Jule_zhou
     * @date 2022-08-05 17:17:09
     * @param
     * @return {@link null}
     */
    public Pet() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

测试类源码：

package com.bdqn.ready;

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

/**
 * @authorDesc 收获源于是每一分的努力
 * @author Jule_zhou
 * @date 2022-08-05 17:17:39
 * @version
 * @description 测试类
 */
public class Test {
    public static void main(String[] args) {
        // 创建多个宠物
        Pet pet1 = new Pet("小虎",5);
        Pet pet2 = new Pet("小黄",7);
        Pet pet3 = new Pet("小志",9);
        Pet pet4 = new Pet("小黑",2);
        // 创建ArrayList对象
        List<Pet> petList = new ArrayList<>();
        System.out.println("------------向ArrayList中添加值------------");
        // 向ArrayList中添加值
        petList.add(pet1);
        petList.add(pet2);
        petList.add(pet3);
        petList.add(pet4);
        // 查看添加结果
        petList.forEach(pet -> System.out.println("宠物的名字：" + pet.getName() + "\t宠物的年龄：" + pet.getAge()));
        // 输出结果
        /*
            宠物的名字：小虎	宠物的年龄：5
            宠物的名字：小黄	宠物的年龄：7
            宠物的名字：小志	宠物的年龄：9
            宠物的名字：小黑	宠物的年龄：2
         */
        System.out.println("------------根据索引位置添加值------------");
        // 根据索引位置添加值
        petList.add(2,pet4);
        // 查看添加结果
        petList.forEach(pet -> System.out.println("宠物的名字：" + pet.getName() + "\t宠物的年龄：" + pet.getAge()));
        // 输出结果
        /*
            宠物的名字：小虎	宠物的年龄：5
            宠物的名字：小黄	宠物的年龄：7
            宠物的名字：小黑	宠物的年龄：2
            宠物的名字：小志	宠物的年龄：9
            宠物的名字：小黑	宠物的年龄：2
         */
        System.out.println("------------返回列表中的元素个数------------");
        // 返回列表中的元素个数
        System.out.println("列表中的元素个数为：" + petList.size());
        // 输出结果
        /*
            列表中的元素个数为：5
         */
        System.out.println("------------判断列表中是否存在指定元素------------");
        // 判断列表中是否存在指定元素
        System.out.println("是否存在\"" + petList.get(1) + "\"这个元素：" + petList.contains(petList.get(1)));
        // 输出结果
        /*
            是否存在"com.bdqn.ready.Pet@6d311334"这个元素：true
         */
        System.out.println("------------从列表中删除元素------------");
        // 从列表中删除元素(根据对象删除)
        petList.remove(petList.get(1));
        // 查看结果
        petList.forEach(pet -> System.out.println("宠物的名字：" + pet.getName() + "\t宠物的年龄：" + pet.getAge()));
        // 输出结果
        /*
            宠物的名字：小虎	宠物的年龄：5
            宠物的名字：小黑	宠物的年龄：2
            宠物的名字：小志	宠物的年龄：9
            宠物的名字：小黑	宠物的年龄：2
         */
        System.out.println("------------从列表中删除元素(根据索引位置删除)------------");
        // 从列表中删除元素(根据索引位置删除)
        petList.remove(1);
        // 查看结果
        petList.forEach(pet -> System.out.println("宠物的名字：" + pet.getName() + "\t宠物的年龄：" + pet.getAge()));
        // 输出结果
        /*
            宠物的名字：小虎	宠物的年龄：5
            宠物的名字：小志	宠物的年龄：9
            宠物的名字：小黑	宠物的年龄：2
         */
    }
}

（四）、ArrayList拓展

ArrayList的默认长度为10

（五）、LinkedList的特殊方法

方法名	说明
void addFirst(Object o)	在列表的首部添加元素
void addLast(Object o)	在列表的末尾添加元素
Object getFirst()	返回列表中的第一个元素
Object getLast()	返回列表中的最后一个元素
Object removeFirst()	删除并返回列表中的第一个元素
Object removeLast()	删除并返回列表中的最后一个元素

（六）、LinkedList的部分方法代码实现

类源码

package com.bdqn.day11.practice3;
/**
 * @authorDesc 收获源于是每一分的努力
 * @author Jule_zhou
 * @date 2022-08-04 15:42:07
 * @version
 * @description 新闻类
 */
public class News {
    /**
     * 新闻
     */
    private String news;
    public News(){}

    public News(String news) {
        this.news = news;
    }

    public String getNews() {
        return news;
    }

    public void setNews(String news) {
        this.news = news;
    }
}

测试类源码

package com.bdqn.day11.practice3;

import java.util.LinkedList;

/**
 * @authorDesc 收获源于是每一分的努力
 * @author Jule_zhou
 * @date 2022-08-04 15:42:27
 * @version
 * @description 测试类
 */
public class Test {
    public static void main(String[] args) {
        News news0 = new News("头条和末条新闻已添加");
        News news2 = new News("华为麒麟最强芯片980问世");
        News news3 = new News("看看上海怎样垃圾分类");
        News news4 = new News("2019河南本科一批平行志愿正式开挡");
        News news5 = new News("美国一意孤行要加中国关税");
        System.out.println(news0.getNews());

        System.out.println();

        System.out.println("头条的新闻标题为：" + news2.getNews());
        System.out.println("排在最后的新闻标题为：" + news5.getNews());
        System.out.println();
        // 创建LinkedList对象
        LinkedList<News> newsList = new LinkedList<>();
        // 向LinkedList对象中添加值
        newsList.add(news2);
        newsList.add(news3);
        newsList.add(news4);
        newsList.add(news5);

        System.out.println("删除的头条新闻标题为：" + newsList.getFirst().getNews());
        newsList.remove(newsList.getFirst());
        System.out.println("删除的末条新闻标题为：" + newsList.getLast().getNews());
        newsList.remove(newsList.getLast());
        System.out.println("删除后剩余的新闻条数：" + newsList.size());
        System.out.println();
        System.out.println("遍历所有新闻标题：");
        newsList.forEach(news -> System.out.println("新闻标题名称：" + news.getNews()));
    }
}

输出结果：

头条和末条新闻已添加

头条的新闻标题为：华为麒麟最强芯片980问世
排在最后的新闻标题为：美国一意孤行要加中国关税

删除的头条新闻标题为：华为麒麟最强芯片980问世
删除的末条新闻标题为：美国一意孤行要加中国关税
删除后剩余的新闻条数：2

遍历所有新闻标题：
新闻标题名称：看看上海怎样垃圾分类
新闻标题名称：2019河南本科一批平行志愿正式开挡

（七）、ArrayList与LinkedList对比

	ArrayList	LinkedList
存储方式的区别	ArrayList实现了长度可变的数组，在内存中分配连续的空间。	LinkedList采用链表存储方式。
使用场合的区别	ArrayList遍历元素和随机访问元素的效率比较高，插入、删除、修改操作频繁时性能低下。	LinkedList插入、删除、修改元素时效率较高，查找效率较低。

2、关于Set

（一）、Set的分支结构

Set 接口存储一组唯一，无序的对象

（二）、Set的分支结构之HashSet的特点

集合内的元素是无序排列且不允许重复。
HashSet集合的查找效率高。
允许集合元素值为null。

（三）、Set接口方法说明

方法名	说明
boolean add(Object o)	如果Set中尚未包含指定元素o,则添加指定元素o
void clear()	从Set中移除所有元素
int size()	返回Set中的元素个数
boolean isEmpty()	如果Set不包含任何元素，则返回true
boolean contains(Object o)	如果Set包含指定元素o，则返回true
boolean remove(Object o)	如果Set包含指定元素o，则将其移除。

（四）、HashSet接口的代码说明

// 1、创建四个狗狗对象
Dog ououDog = new Dog("欧欧", "雪娜瑞");
Dog yayaDog = new Dog("亚亚", "拉布拉多");
Dog meimeiDog = new Dog("美美", "雪娜瑞");
Dog feifeiDog = new Dog("菲菲", "拉布拉多");
// 2、创建HashSet集合对象并把四个狗狗对象放入其中
Set dogs = new HashSet();
dogs.add(ououDog);
dogs.add(yayaDog);
dogs.add(meimeiDog);
dogs.add(feifeiDog);
// 3、输出集合中狗狗的数量
System.out.println("共计有" + dogs.size() + "条狗狗");
System.out.println("美美是否存在："+dogs.contains(meimeiDog));
dogs.remove(meimeiDog);
System.out.println("美美对象已经删除");
System.out.println("删除后，还有" + dogs.size() + "条狗狗");
System.out.println("集合是否为空：" + dogs.isEmpty());

四、关于Map

1、Map的分支结构

2、Map的简单介绍

Map接口存储一组键值对象，提供key到value的映射
Map接口常用的实现类HashMap

3、HashMap类的特点

不保证映射的顺序，特别是不保证顺序恒久不变（无序，且不为恒定）
数据添加到HashMap集合后，所有数据的数据类型将转换为Object类型，所以从其中获取数据时需要进行强制类型转换。（数据类型为Object，获取数据需要强转）

4、Map存储示意图

在这里插入图片描述

5、Map接口的常用方法（不是所有的方法）

方法名	说明
Object put(Object key, Object val)	以“键-值对”的方式进行存储
Object get (Object key)	根据键返回相关联的值，如果不存在指定的键，返回null
Object remove (Object key)	删除由指定的键映射的“键-值对”
int size()	返回元素个数
Set keySet ()	返回键的集合
Collection values ()	返回值的集合
boolean containsKey (Object key)	如果存在由指定的键映射的“键-值对”，返回true

6、HashMap方法的使用

package com.bdqn.day12.practice1;
/**
 * @authorDesc 收获源于是每一分的努力
 * @author Jule_zhou
 * @date 2022-08-05 14:43:43
 * @version
 * @description 宠物类
 */
public class Pets {
    /**
     * 名字
     */
    private String name;

    /**
     * 种类
     */
    private String type;

    public Pets() {
    }

    public Pets(String name, String type) {
        this.name = name;
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

测试类

package com.bdqn.day12.practice1;

import java.util.HashMap;
import java.util.Map;
/**
 * @authorDesc 收获源于是每一分的努力
 * @author Jule_zhou
 * @date 2022-08-05 14:43:54
 * @version
 * @description 测试类
 */
public class Test {
    public static void main(String[] args) {
        Pets pet1 = new Pets("欧欧","雪纳瑞");
        Pets pet2 = new Pets("佩佩","藏獒");
        Pets pet3 = new Pets("欢欢","二哈");
        Pets pet4 = new Pets("豆豆","柴犬");
        // 创建HashMap对象
        Map<String,Pets> petsMap = new HashMap<>(16);
        petsMap.put(pet1.getName(),pet1);
        petsMap.put(pet2.getName(),pet2);
        petsMap.put(pet3.getName(),pet3);
        petsMap.put(pet4.getName(),pet4);
        // 返回键的集合
        System.out.println("Map中存在的Key：" + petsMap.keySet());
        // 返回值的集合
        System.out.println("Map中存在的value：" + petsMap.values());

        System.out.println("循环遍历：");
        petsMap.forEach((String name,Pets pet)-> System.out.println(name + "\t\t" + pet.getType()));

        System.out.println("Map中存在指定对象，对象信息如下：");
        // get(key)根据键返回相关联的值，如果不存在指定的键，返回null
        System.out.println("欧欧\t\t" + petsMap.get("欧欧").getType());
    }
}

五、Collections集合操作工具类

1、Collections简介及特性

Collections类是Java提供的一个集合操作工具类。
Collections类定义了一系列用于操作集合的静态方法，用于实现对集合元素的排序、查找和替换等操作。
Collections和Collection是不同的，前者是集合的操作类，后者是集合接口

2、Collections的常用方法（不是所有的方法）

方法	作用
sort()	排序
binarySearch()	查找
max()\min()	查找最大\最小值

3、Collections的方法使用

实现一个类的对象之间比较大小，该类要实现Comparable<T>接口

重写 public int compareTo(T o)方法。
如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

4、Collections中compareTo复写的使用

类文件

package com.bdqn.ready;
/**
 * @authorDesc 收获源于是每一分的努力
 * @author Jule_zhou
 * @date 2022-08-05 17:15:16
 * @version
 * @description
 */
public class Pet implements Comparable {
    /**
     * 年龄
     */
    private int age;

    public Pet() {
    }

    public Pet(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    /**
     * 复写
     * @description
     * @author Jule_zhou
     * @date 2022-08-06 10:41:39
     * @param o
     * @return {@link int}
     */
    @Override
    public int compareTo(Object o) {
        int i = (int) o;
        if (i < this.age){
            return -1;
        } else if (i > this.age) {
            return 1;
        }
        return 0;
    }
}

测试类文件

package com.bdqn.ready;
/**
 * @authorDesc 收获源于是每一分的努力
 * @author Jule_zhou
 * @date 2022-08-06 10:06:29
 * @version
 * @description
 */
public class Test extends Pet{
    public static void main(String[] args) {
        Pet pet1 = new Pet(1);
        Pet pet2 = new Pet(5);
        // 返回值为1
        System.out.println(pet1.compareTo(pet2.getAge()));
    }
}