Java集合框架【二容器[LinkedList容器类、Set接口]】

已于 2022-11-23 14:23:09 修改
阅读量295 收藏
点赞数
分类专栏： # java进阶 文章标签： java
于 2022-11-23 14:07:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yang2330648064/article/details/127993320
版权

文章目录

一 LinkedList容器类

  • LinkedList底层用双向链表实现的存储。
  • 特点：查询效率低，增删效率高，线程不安全双向链表也叫双链表，是链表的一种，它的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点。所以，从双向链表中的任意一个节点开始，都可以很方便地找到所有节点。
    在这里插入图片描述
class Node<E> {
	E item;
	Node<E> next;
	Node<E> prev;
}

1.1 LinkedList的使用(List接口)

  • Linked实现了List接口，所以LinkedList是具备List的存储特征的【有序、可重复】
public class LInkedListTest {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("a");
        for(String s :list) {
            System.out.println(s);
        }
    }
}

在这里插入图片描述

1.2 Linked的使用(非List标准)

方法说明
void addFirst(E e）将指定元素插入到开头
void add Last(E e）将指定元素插入到结尾
getFirst(）返回此列表的第一个元素
getLast(）返回此列表的最后一个元素
removeFirst()移除此列表中的第一个元素，并返回这个元素
removeLast(）移除此列表中的最后一个元素，并返回这个元素
E pop(）从此列表所表示的堆栈处弹出一个元素，等效于removeFirst
voidpush(E e）将元素推入此列表所表示的堆栈这个等效于addFisrt(E e）
booleanisEmpty(）判断列表是否包含元素，如果不包含元素则返回true

1.4 LinkedList源码分析

  • 节点类
private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

二 Set接口

  • Set接口继承自Collection，Set接口中没有新增方法，方法和Collection保持完全一致。我们在前面通过List学习的方法，在Set中仍然适用。因此，学习Set的使用将没有任何难度。

2.1 Set接口特点

  • Set特点：无序、不可重复。无序指Set中的元素没有索引，我们只能遍历查找；不可重复指不允许加入重复的元素。更确切地讲，新元素如果和Set中某个元素通过equals()方法对比为true，则只能保留一个。
  • Set常用的实现类有：HashSet、TreeSet等。

2.2 HashSet容器类

  • Hashset是一个没有重复元素的集合，不保证元素的顺序。而且HashSet允许有null元素。HashSet是采用哈希算法实现，底层实际是用HashMap实现的（HashSet本质就是一个简化版的HashMap），因此，查询效率和增删效率都比较高。

2.2.1 Hash算法原理

  • Hash算法也称之为散列算法
    在这里插入图片描述

2.2.2 HashSet的例子

/**
 * @author 缘友一世
 * date 2022/11/23-9:03
 */
public class HashSetTest {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("a");
        set.add("d");
        set.add("b");
        set.add("a");
        //获取元素,在set容器中没有索引，没有对应的get方法。
        for(String s:set) {
            System.out.println(s);
        }
        boolean flag = set.remove("d");
        System.out.println(flag);
        for(String s:set) {
            System.out.println(s);
        }
        System.out.println(set.size());
    }
}

在这里插入图片描述

2.2.3 HashSet存储特征分析

  • Hashset是一个不保证元素的顺序且没有重复元素的集合，是线程不安全的。Hashset允许有null元素
    1. 无序：
      • 在HashSet中底层是使用HashMap存储元素的。
      • HashMap底层使用的是数组与链表实现元素的存储。
      • 元素在数组中存放时，并不是有序存放的也不是随机存放的，而是对元素的哈希值进行运算决定元素在数组中的位置。
    2. 不重复：
      • 当两个元素的哈希值进行运算后得到相同的在数组中的位置时，会调用元素的equals()方法判断两个元素是否相同。如果元素相同则不会添加该元素，如果不相同则会使用单向链表保存该元素。
/**
 * @author 缘友一世
 * date 2022/11/23-9:11
 */
public class Users {
    private String userName;
    private int userAge;

    public Users() {
    }

    public Users(String userName, int userAge) {
        this.userName = userName;
        this.userAge = userAge;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getUserAge() {
        return userAge;
    }

    public void setUserAge(int userAge) {
        this.userAge = userAge;
    }

    @Override
    public int hashCode() {
        int result=userName !=null ? userName.hashCode():0;
        result=31*result+userAge;
        return result;
    }

    @Override
    public boolean equals(Object o) {
        if(this==o) return true;
        if(o==null || getClass()!=o.getClass()) return false;
        Users users = (Users) o;
        if(userAge!=users.userAge) return false;
        return userName!=null ? userName.equals(users.userName):false;
    }

    @Override
    public String toString() {
        return "Users{" +
                "userName='" + userName + '\'' +
                ", userAge=" + userAge +
                '}';
    }
}

class Test {
    public static void main(String[] args) {
        HashSet<Users> set1 = new HashSet<>();
        Users aaa = new Users("aaa", 19);
        Users bbb = new Users("aaa", 19);
        set1.add(aaa);
        set1.add(bbb);
        for(Users user:set1) {
            System.out.println(user);
        }

    }
}

在这里插入图片描述

2.3 TreeSet容器类

  • TreeSet是一个可以对元素进行排序的容器。底层实际是用TreeMap实现的，***内部维持了一个简化版的TreeMap，通过key来存储Set的元素。***TreeSet内部需要对存储的元素进行排序，因此，我们需要给定排序规则。
  • 排序规则实现方式
    • 通过元素自身实现比较规则
    • 通过比较器指定比较规则
/**
 * @author 缘友一世
 * date 2022/11/23-9:30
 */
public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<String> set = new TreeSet<>();
        set.add("c");
        set.add("a");
        set.add("b");
        set.add("1");
        for(String str:set) {
            System.out.println(str);
        }
    }
}

在这里插入图片描述
在这里插入图片描述

2.4 通过元素自身实现比较规则

  • 在元素自身实现比较规则时，需要实现Comparable接口中的compareTo方法，该方法中用素定义比较规则。TreeSet通过调用该方法来完成对元素的排序处理。
/**
 * @author 缘友一世
 * date 2022/11/23-12:53
 */
public class SortTest {
    public static void main(String[] args) {
        TreeSet<Users2> set1 = new TreeSet<>();
        Users2 aaa = new Users2("aaa", 19);
        Users2 ccc = new Users2("ccc", 17);
        Users2 bbb = new Users2("bbb", 19);
        set1.add(aaa);
        set1.add(bbb);
        set1.add(ccc);
        for(Users2 user:set1) {
            System.out.println(user);
        }
    }
}
class Users2 implements Comparable<Users2> {

    private String userName;
    private int userAge;

    public Users2() {
    }

    public Users2(String userName, int userAge) {
        this.userName = userName;
        this.userAge = userAge;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getUserAge() {
        return userAge;
    }

    public void setUserAge(int userAge) {
        this.userAge = userAge;
    }

    @Override
    public int hashCode() {
        int result=userName !=null ? userName.hashCode():0;
        result=31*result+userAge;
        return result;
    }



    @Override
    public boolean equals(Object o) {
        if(this==o) return true;
        if(o==null || getClass()!=o.getClass()) return false;
        Users2 users = (Users2) o;
        if(userAge!=users.userAge) return false;
        return userName!=null ? userName.equals(users.userName):false;
    }

    @Override
    public String toString() {
        return "Users{" +
                "userName='" + userName + '\'' +
                ", userAge=" + userAge +
                '}';
    }

    @Override
    public int compareTo(Users2 o) {
        if(this.userAge>o.getUserAge()) {
            return 1;
        }
        if(this.userAge==o.getUserAge()) {
            return this.userName.compareTo(o.getUserName());
        }
        return -1;
    }
}

在这里插入图片描述

2.5 通过比较器实现比较规则

  • 通过比较器定义比较规则时，我们需要单独创建一个比较器，比较器需要实现Comparator接口中的compare方法来定义比较规则。
  • 在实例化TreeSet时将比较器对象交给TreeSet来完成元素的排序处理。此时元素自身就不需要实现比较规则了。

/**
 * @author 缘友一世
 * date 2022/11/23-13:24
 */
class Test {
    public static void main(String[]args){
        TreeSet<student> set = new TreeSet<>(new ComparatorTest());
        student ooo = new student("ooo", 18);
        student aaa = new student("aaa", 22);
        student sss = new student("sss", 22);
        set.add(ooo);
        set.add(aaa);
        set.add(sss);
        for(student x:set) {
            System.out.println(x);
        }
    }
}
public class ComparatorTest implements Comparator<student> {
    //定义比较规则

    @Override
    public int compare(student o1, student o2) {
        if(o1.getAge()>o2.getAge()) {//升序
            return 1;
        }else if(o1.getAge()==o2.getAge()) {
            return o1.getName().compareTo(o2.getName());
        }
        return -1;
    }
}
class student {
    private  String name;
    private int age;

    public student() {
    }

    public student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        student student = (student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

在这里插入图片描述

三 单例集合使用例子

  • 生成1-10之间的随机数(1-10),将不重复的10个随机数放到容器中

List实现

/**
 * @author 缘友一世
 * date 2022/11/23-13:36
 */
public class SetDemo {
  public static void main(String[] args) {
  ArrayList<Integer> list = new ArrayList<>();
        while(true) {
            int num=(int)(Math.random()*10+1);
            if(!list.contains(num)) {
                list.add(num);
            }
            if(list.size()==10) {
                break;
            }
        }
        for(Integer x:list) {
            System.out.println(x);
        }
    }
}

在这里插入图片描述

Set实现

/**
 * @author 缘友一世
 * date 2022/11/23-13:36
 */
public class SetDemo {
    public static void main(String[] args) {
        HashSet<Integer> set = new HashSet<>();
        while(true) {
            //set容器是不允许有重复元素的，所以不需要
            int num=(int)(Math.random()*10+1);
            set.add(num);
            if(set.size()==10) {
                break;
            }
        }
        for(Integer i:set) {
            System.out.println(i);
        }
    }
}

在这里插入图片描述

缘友一世
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LinkedList实现List一些方法
04-06
NULL 博文链接：https://zhglhy.iteye.com/blog/1559038
LinkedList和Set
qq_41027523的博客
05-17 545
LinkedList和Set 1. LinkedList 1.1 LinkedList概述 底层存储数据是一个双向链表结构 自行车链子 就是一个生活中链表结构，环环相扣，替换，拆除非常方便 1.2 LinkedList需要了解的方法 LinkedList使用的方法都是从List接口实现而来的方法，需要了解的是LinkedList特有方法： boolean addFirst(E e); 在当前链表开始位置加元素 boolean addLast(E e); 在当前链表末尾添加元素 E g
Java集合容器
Keep It Simple Stupid
03-16 610
Java集合容器知识整理总结
LinkedList,set和排序总结
biguo_的博客
01-19 1616
1.Linkedlist 1.1概述 Linkedlist:底层是双向链表，因为不是连续存储，只是能找到下一个元素的地址，所以进行添加删除操作效率较高。但查询效率较低，因为只能从第一个挨个找。 1.2基本使用 public static void main(String[] args){ LinkedList list =new LinkedList(); //添加到尾部 list.add(1); list.add(12); list.add(15); list.add(18); list.add(3);
Linkedlist与set
weixin_52492446的博客
05-07 228
05-07学习笔记一：linkedlist集合类注意：增删改查（获取集合元素的方式）1.tostring2.for循环3.增强for循环4.迭代器1.默认为升序2.排序1.升序：2.降序：3.自定义排序二：hashSet重点：set与linkedList 一：linkedlist集合类 注意： List list=new LinkedList(); 增 list.add(a); a为加入集合的数据 删 .clear();删除全部 对象名.remove(值);删除单个数据 改 查（获取集合元素的方式） 1
Java集合框架总结
08-16
Java集合框架汇总 1．集合框架结构图 1 2．两种特殊的Java容器类List和Set分析 2 3. Collection 接口： 2 4．Iterator 接口： 3 5．List接口： 3 5.1 LinkedList类： 5 5.2 ArrayList类: 5 6．Set接口： 5 7．Map...
Java 基础核心总结 +经典算法大全.rar
11-08
集合框架总览 -、Iterator Iterable ListIterator 二、Map 和 Collection 接口Map 集合体系详解 HashMap LinkedHashMap TreeMap WeakHashMap Hashtable Collection 集合体系详解 Set 接口 AbstractSet 抽象类...
Java常见面试题208道.docx
05-17
面试题包括以下十九部分：Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql...
Java面试宝典-经典
03-28
1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？ 7 2、Java有没有goto? 7 3、说说&和&&的区别。 8 4、在JAVA中如何跳出当前的多重嵌套循环？ 8 5、switch语句能否作用在byte上，能否作用在...
Java服务器端开发面试.doc
06-07
同步容器类，并发容器类之间的区别 几个重要的数据结构，需要了解详细，最好能看过关键代码， copyOnWrite容器， ConcurrentHashMap 信号量， CountDownLatch, CyclicBarrier等类的使用 还有一些Future框架等等(这块...
java 集合中List（ArrayList和LinkedList），set以及Map的实现
emmmsuperdan的博客
09-01 6237
Map只能存放键值对,如果采用keyset这种方法去那key值，那么因为keyset是一个Set集合，输出将会是无序的; 可以采用Pair集合存放键值对，采用这样key和value都能有序的输出; List（可加入null元素）： 首先List是一个接口，里面定义了很多抽象方法： ArrayList，LinkedList，Vector等等继承了它，说下ArrayList实现...
数组的特点，数组的使用，链表的特点，set和list的区别，arrayList，linkedList，的常用方法，set，hashset，
boss_way的博客
10-26 1760
数组的特点： 数组的长度一旦定义则不能改变 数组中的元素都有整数索引 数组只能存储同一类型的元素 数组即可以存储基本数据类型，又可以存储引用数据类型 数组的使用： 获取元素。通过索引获取，arr[2]; 添加元素（在元素3后面添加一个新元素8）：要先创建新的数组，长度为原先的数组长度+1；遍历原先的数组，并将要添加的元素插入到新的数组当中 当碰到元素3的时候，在元素3后面添加新的
java day027 集合之LinkedList与Set
bandersnatch的博客
05-17 159
java day027 LinkedList与Set 1.LinkedList概述 LinkedList的底层存储数据结构是一个双向链表结构 2.LinkedList需要了解的方法 boolean addFirst(E e); 首插法，在表头添加元素 boolean addLast(E e); 尾插法，在表尾添加元素 E getFirst(); 获取第一个节点Node数据 E getLast(); 获取最后一个节点Node数据 E removeFirst(); 删除第一个节点 E removeLast();
集合知识点总结02
HaiZhiXinShan的专栏
05-17 740
6、list体系结构： |--ArrayList:低层数据结构是数组，不同步，有别于vector,替代了它，也是可  延长数组，百分之五十，提升了空间的效率。查询很快，增删很慢。
19.基于LinkedList实现set
cl723401的博客
03-26 401
package com.cl.set; public class LinkedListSet<E> implements Set<E> { private LinkedList<E> list; public LinkedListSet() { list = new LinkedList<>(); } ...
List中的set方法和add方法
热门推荐
Alibert的专栏
08-31 3万+
public class TestList {public static void main(String[] args){   List l1 = new LinkedList();   for(int i=0; i    l1.add("a"+i);   }   System.out.println(l1);   l1.add(3,"a100");   System.out
C#(C Sharp)学习笔记_类【十五】
最新发布
追求细节，成就完美
05-01 551
类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
链表刷题集
yajunjiao的专栏
04-30 934
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
java集合框架的容器图存储
06-13
Java集合框架中的集合容器可以分为三类：List、Set和Map。 List是有序的集合容器，允许重复元素，常用的实现类有ArrayList、LinkedList和Vector。 Set是不允许重复元素的集合容器，常用的实现类有HashSet、TreeSet和LinkedHashSet。 Map是一种键值对映射的集合容器，每个键只能对应一个值，常用的实现类有HashMap、TreeMap和LinkedHashMap。 以下是Java集合框架容器的存储结构示意图： ``` List +---------+ | | | Element | | | +---------+ | | | Element | | | +---------+ | | | Element | | | +---------+ Set +---------+ | | | Element | | | +---------+ | | | Element | | | +---------+ | | | Element | | | +---------+ Map +---------+ | | | Key | | | +---------+ | | | Value | | | +---------+ | | | Key | | | +---------+ | | | Value | | | +---------+ | | | Key | | | +---------+ | | | Value | | | +---------+ ``` List和Set都是一维的容器，Map是二维的容器，它将键值对映射到一个二维空间中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值