java day14 set集合（HashSet、TreeSet、Queue）

最新推荐文章于 2022-08-15 13:31:53 发布
最新推荐文章于 2022-08-15 13:31:53 发布
阅读量146 收藏
点赞数
分类专栏： java学习日记 文章标签： 队列 数据结构 queue java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43642864/article/details/110496295
版权

1、Collections工具类

集合工具类，定义了除了存取以外的集合常用方法。

方法描述
sort升序排序（元素类型必须实现Comparable接口）
addAll将所有指定元素添加到指定 collection 中。
max根据元素的自然顺序，返回给定 collection 的最大元素。
min根据指定比较器产生的顺序，返回给定 collection 的最小元素。

代码示例：

package Day14_set.collections;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

/**
 * @author wzy
 * @version 1.0
 * @date 0003 2020-12-03 18:51
 */
public class Demo01 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");

        System.out.println(list);

        //通过工具类进行多个数据添加
        Collections.addAll(list,"1","2","3","4");
        System.out.println(list);

        String[] strs = {"wzy","p","ljd"};
        Collections.addAll(list,strs);
        System.out.println(list);

        for (int i=0;i<strs.length;i++){
            list.add(strs[i]);
        }
        System.out.println(list);

    }
}

代码示例2：

package Day14_set.collections;

import java.util.ArrayList;
import java.util.Collections;

/**
 * @author wzy
 * @version 1.0
 * @date 0003 2020-12-03 19:03
 */
public class Demo02 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,656,1000);
        System.out.println(list);

        //将集合中的对象存储到数组中，再通过Collections.sort进行排序，在存储到list集合中
        Collections.sort(list);
        System.out.println(list);
    }
}

2、Set接口

2.1 set接口

  • 特点：无序、无下标、元素不可重复。
  • 方法：全部继承自Collection中的方法。
  • 使用foreach循环遍历： for(数据类型 局部变量 : 集合名){ //循环内部的局部变量，代表当次循环从集合中取出的对象 }

使用set接口存储数据：

public class Demo1 {
	public static void main(String[] args) {
		//创建集合
		Set<String> set=new HashSet<>();
		//1添加数据
		set.add("小米");
		set.add("苹果");
		set.add("华为");
		//set.add("华为");
		System.out.println("数据个数:"+set.size());
		System.out.println(set.toString());
		//2删除数据
//		set.remove("小米");
//		System.out.println(set.toString());
		//3遍历 【重点】
		//3.1使用增强for
		System.out.println("-----增强for-------");
		for (String string : set) {
			System.out.println(string);
		}
		//3.2使用迭代器
		System.out.println("-----使用迭代器------");
		Iterator<String> it=set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//4判断
		System.out.println(set.contains("华为"));
		System.out.println(set.isEmpty());
	}
}

3、Set实现类

3.1 TreeSet

set:无序不可重复的集合

  • TreeSet:无序不可重复的集合，不可以存储null对象
  • 存储Integer类型数据会自动从小到大排序
  • 存储自定义数据对象 需要实现 自然排序或者比较器，否则会报类型异常

自然排序：

  • 存储的对象需要事先Comparable接口,重写compareTo()方法，在
  • compareTo()实现比较规则
  • compareTo返回正数则在节点的右边，返回负数则在节点的左边,返回0则不存储

比较器：

  • 在实例化TreeSet集合的时候，通过构造方法传递Compareator实现类的对象
  • 并重写compare()，根据compare()中的规则进行排序

代码示例：

package Day14_set.treeSet;

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

/**
 * @author wzy
 * @version 1.0
 * @date 0003 2020-12-03 19:16

set:无序不可重复的集合
    TreeSet:无序不可重复的集合，不可以存储null对象
    存储Integer类型数据会自动从小到大排序
    存储自定义数据对象  需要实现  自然排序或者比较器，否则会报类型异常

自然排序：
存储的对象需要事先Comparable接口,重写compareTo()方法，在
compareTo()实现比较规则
compareTo返回正数则在节点的右边，返回负数则在节点的左边,返回0则不存储

比较器：
在实例化TreeSet集合的时候，通过构造方法传递Compareator实现类的对象
并重写compare()，根据compare()中的规则进行排序


    当实体类无法修改时，使用比较器进行排序，反之则使用自然排序。
 *
 *          ctrl+alt+b  罗列方法实现的类
 *
 *
 *
 */
public class Demo01 {
    public static void main(String[] args) {
        TreeSet<Integer> set = new TreeSet<>();
        //添加
        set.add(10);
        set.add(62);
        set.add(80);
        set.add(101);
        set.add(1);
        set.add(7);
        set.add(98);
        System.out.println(set);

        //迭代器
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        System.out.println(set);
        //删除
        set.remove(98);
        System.out.println(set);

        //lambda表达式
        set.forEach(item-> System.out.println(item));

        //修改  先删除，再添加
        set.remove(100);
        set.add(101);
        System.out.println(set);

        //lambda表达式
        set.forEach(i-> System.out.println(i));

    }
}

代码示例2：

存储数据对象

  1. 建立User.java类
  2. 建立Demo02.java实现类类
package Day14_set.entity;

/**
 * @author wzy
 * @version 1.0
 * @date 0003 2020-12-03 19:43
 */
public class User  implements Comparable<User>{
    private int id;

    public User(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                '}';
    }


    @Override
    public int compareTo(User o) {
        return o.id-this.id;
    }
}


package Day14_set.treeSet;

import Day14_set.entity.User;

import java.util.TreeSet;

/**
 * @author wzy
 * @version 1.0
 * @date 0003 2020-12-03 19:43
 *
 */
public class Demo02 {
    public static void main(String[] args) {
        TreeSet<User> set = new TreeSet<>();
        set.add(new User(1));
        set.add(new User(2));
        set.add(new User(3));
        set.add(new User(5));
        set.add(new User(10));
        set.add(new User(1));

        set.forEach(i-> System.out.println(i));
        System.out.println(set);
    }
}

代码示例3

  1. 使用TreeSet存储数据
  2. 重写compare()方法
  1. 建立 Animal.java
  2. 建立 MyComparator.java
  3. 建立 Demo04.java
package Day14_set.entity;

/**
 * @author wzy
 * @version 1.0
 * @date 0003 2020-12-03 15:09
 */
public class Animal {
    private int id;
    private String name;
    private int age;

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



    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 String toString() {
        return "Animal{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}


package Day14_set.treeSet;

import Day14_set.entity.Animal;

import java.util.Comparator;

/**
 * @author wzy
 * @version 1.0
 * @date 0003 2020-12-03 15:08
 */
public class MyComparator implements Comparator<Animal> {
    //第一个参数是要存储的对象
    //第二个参数是已存储的对象
    @Override
    public int compare(Animal o1, Animal o2) {
        if (o1.getId()!=o2.getId()){
            return o2.getId()-o1.getId();
        }
        return o1.getAge()-o2.getAge();
    }
}


package Day14_set.treeSet;

import Day14_set.entity.Animal;

import java.util.TreeSet;

/**
 * @author wzy
 * @version 1.0
 * @date 0003 2020-12-03 15:08
 */
public class Demo04 {
    public static void main(String[] args) {
        /**
         * 首先按id进行从大到小排序，如果id相等则按年龄进行从小到大排序
         */
        TreeSet<Animal> set = new TreeSet<>(new MyComparator());

        set.add(new Animal(1,"wzy",18));
        set.add(new Animal(1,"wzy",17));
        set.add(new Animal(1,"wzy",16));
        set.add(new Animal(2,"wzy",20));
        set.add(new Animal(2,"wzy",21));
        set.add(new Animal(3,"wzy",21));
        set.add(new Animal(4,"wzy",91));

        set.forEach(item->{
            System.out.println(item.getId()+":"+item.getAge());
        });
    }
}

3.2 HashSet

HashSet:无序不可重复集合

  • JDk1.7 hash表（不可变数组）+链表
  • JDk1.8 hash表（可变数组）+链表+红黑树
  • hash表中的元素超过当前容量的负载因子，则会发生数组扩容机制容量扩展为原来的两倍
  • 如果链表中的元素超过8个，则会转变为红黑树（平衡二叉树）

代码示例：

package Day14_set.hashset;

import java.util.HashSet;

/**
 * @author wzy
 * @version 1.0
 * @date 0003 2020-12-03 19:08
 */
public class Demo01 {
    /**
     HashSet:无序不可重复集合
     JDk1.7 hash表（不可变数组）+链表
     JDk1.8 hash表（可变数组）+链表+红黑树
     
     hash表中的元素超过当前容量的负载因子，则会发生数组扩容机制
     容量扩展为原来的两倍
     果链表中的元素超过8个，则会转变为红黑树（平衡二叉树）
     
     * @param args
     */
    public static void main(String[] args) {
        HashSet<Integer> list = new HashSet<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(4);
        list.forEach(item-> System.out.println(item));
    }
}

3.3 Queue

Queue：线性队列

  • 特点：先进先出，用完即删
    队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。

  • LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。

package Day14_set.queue;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @author wzy
 * @version 1.0
 * @date 0003 2020-12-03 16:50
 */
public class Demo01 {
    /**
     * Queue：线性队列
     * 特点：先进先出，用完即删
     * 作业：研究Queue队列的呃poll()方法如何先进先出，用完即删的效果
     * @param args
     */
    public static void main(String[] args) {
        Queue<Object> queue = new LinkedList<>();
        for (int i=1;i<=10;i++){
            queue.offer(i);
        }

        System.out.println(queue);
        System.out.println(queue.size());
        System.out.println(queue.poll());
        System.out.println(queue.size());
        System.out.println(queue);
    }

}
集合（Set）---HashSet和TreeSet
qq_38424588的博客
06-29 235
一、Set接口： ①无序 ②不包含重复元素 ③没有索引，不能使用for循环遍历元素 ④最多只包含一个null元素 二、HashSet：:此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。 1.构造方法： 2.HashSet是如何保证元素唯一性： 所以主要依赖于hashcode（）和equals（）方法来实现，...
JAVA＜集合框架＞④--Set集合接口、HashSet、TreeSet
weixin_42875313的博客
04-09 479
1.集合的概念 2.Collection接口 3.List接口与实现类 4.泛型和工具类 5.Set接口与实现类 6.Map接口与实现类 5.Set接口与实现类： (1)Set子接口 -特点：无序、无下标、元素不可重复. -方法：全部继承自Collection方法. (2)Set实现类 -HashSet【重点】 -基于HashCode计算元素存放位置. -当存入元素的哈希码相同时,会调用equals进行确认，如结果为true，则拒绝后者存入. -TreeSet -基于排列顺序实现元素不重...
java队列以及hashset hashmapd总结
iteye_2415的博客
07-19 160
[size=large]队列以及hashset hashmapd总结 队列是有序的，但是hashset和hashmap都是不保证其有序的，hashset相当于一个集合，hashmap则是一个映射。Hashset要存的数据若在hashset里面已经存在的话，则不会被存进去了，但是hashmap却不一样，若关键字相同，还是会存进去，即原来的映射被新的调换了。因此其关键字所对应的value可以改变。 ...
Set集合-TreeSet，HashSet
fxh0607的博客
01-23 106
Set集合 概述 ​ 一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。 HashSet HashSet存储字符串并遍历 public class HashSetDemo { public static void main(String[] args) { HashSet<Integer> hashSet = new HashSet
JAVA基础——集合框架（三）Set集合，HashSet ，LinkedSet，TreeSet集合的介绍及原理
Mr_GYF的博客
09-22 731
一、 Set集合概述及特点 因为Set集合的API方法和Collection集合一模一样。故没有没有它的特殊的方法。 所以我们只要学它的两个子类，一个HashSet和另外一个TreeSet 二、 HashSet存储字符串并遍历 实现Set接口，由哈希表（实际是一个hashmap对象）支持，它不保证set的迭代顺序；特别是它不保证该顺序恒久不变。此类允许下使用null元素。 案例： HashSet<String> hashSet =new HashSet<String>(); b
Java集合
lpf11214的博客
03-28 1312
集合的概述
Java编程：深入理解List和Set集合
List和Set都是Java集合框架的一部分，它们提供了存储和管理对象的方式，但各自有不同的特点和使用场景。 List是一个有序的集合，允许有重复元素，并且支持索引访问。在Java中，最常见的List实现是ArrayList和...
Day28_Java集合
weixin_45014721的博客
08-29 390
我觉得还是和底层数据结构有关！HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 (n - 1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就按照相应的方法插入。如果只重写了equals方法，而不重写hashcode的方法，会造成hashcode的值不同，而equals()方法判断出来的结果为true。
黑马毕向东Java课程笔记（day14-1——14-11）:集合类（集合框架）——集合类分类与特点+List集合接口及其子类
LKJgdut的博客
09-05 313
1、集合类特点   为什么出现集合类？ 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。   数组和集合类同是容器，有何不同？ 数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。 数组中可以存储基本数据类型，集合只能存储对象。   集合类的特点 集合只用于存储对象，集合长度是可变的，集合可以存储不同类...
java基础day05-集合（Collection、数据结构、List、泛型深入）
qq_49431764的博客
08-15 454
java基础day05-集合（Collection、数据结构、List、泛型深入）
Java HashSet简介及代码演示
HarrisJayce的博客
11-06 255
List Set Map 数据结构: 数据存储的常用结构 栈 队列 数组 链表 红黑树 栈 : stack,又称堆栈,它是运算受限的线性表, 它的限制主要体现在仅允许在标的的一段进行插入和删除操作 不允许在其他任何位置进行添加.查找.删除等操作 它的存取有以下特点: 1.先进后出(存进去的元素,要在它的后面的元素依次取出后,才能取出该元素) 类似弹夹 2.栈的入口,出口都在栈的最顶端 有两个名词需要注意: 压栈:就是存元素,把元素存储到的栈的最顶端,栈中已有的元素依次向栈底方向移动一个位置 弹栈:就是取元
1.4 Set集合：HashSet和TreeSet类
you can you up up up的博客
09-10 475
Set 集合 无序的，不能包含重复的对象 Set 集合类似于一个罐子，程序可以依次把多个对象“丢进”Set 集合，而 Set 集合通常不能记住元素的添加顺序。 也就是说 Set 集合中的对象不按特定的方式排序，只是简单地把对象加入集合-------无序。 Set 集合中不能包含重复的对象，并且最多只允许包含一个 null 元素---------不能重复元素。 Set 实现了 Collection 接口，它主要有两个常用的实现类：HashSet 类和 TreeSet类。 HashSet 类 HashSet
Set--HashSet&&TreeSet
XiaoFanMi的博客
01-09 286
Set Set不能存储重复元素 HashSet HashSet无序存储 public class HashSetDemo { public static void main(String[] args) { HashSet h = new HashSet(); h.add("a"); h.add("b"); h.add("a"); h.add("w"); h.add("s"); h.ad
java集合中hashSet与TreeSet学习总结
kedor的博客
02-12 509
集合hashSet与TreeSet（仅就成员元素为自定义类型）总结如下： 1、hashSet 为保证hashSet集合中的自定义成员元素的唯一性（或不可重复性），自定义成员元素所属的类一定要重写Object类中hashCode（）方法及equals（）方法。 为什么要这么作呢？ 我们试想：怎么判断两个元素相等呢？答案是利用equals方法。可是，假如我们集合中的元素已经有1000个了，那么
java集合系列——Set之HashSet和TreeSet介绍（十）
dengwan3818的博客
01-09 100
一.Set的简介Set是一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素。对 e1 和 e2，并且最多包含一个为 null 的元素。 Set的类关系图： 1.继承于Collection接口，具有增删查改的方法！ 2.AbstractCollection抽象类，实现了Collection接口，并实现了里...
Java集合基础：HashSet和TreeSet介绍
Java Punk
07-15 452
目录 Set集合简介： 1、Set集合及常用方法 2、HashSet集合 2.1、HashSet基本操作 2.2、HashSet元素添加分析 3、TreeSet 3.1、TreeSet基本操作 Set集合简介： 我们先上一个框架图，连接下set集合与Collection的关系： Set继承于Collection接口，是一个不允许出现重复元素，并且无序的集合，主要有HashS...
java集合Set的应用（HashSet、Tree…
The Art Of Java ...
09-18 940
集合存放的都是对象的引用。 Collection:  |——List  |--Set   |--HashSet:无序、无角标、不能存重复的元素；底层采用哈希表数据结构，通过哈希值来确定元素的位置，保证元素的唯一性是通过hashCoode方法        和equals方法来完成的。当哈希值不相同时，不需要判断equals方法，只要当哈希值相同的，菜判断equals方法，equals放回fals
集合源码学习(八):HashSet和TreeSet
anLA_的专栏
10-17 356
何为Set？Set定义如下：public interface Set<E> extends Collection<E>如上代码，在Set只是简单的继承自Collection，但是在jdk代码解释中表明Set集合有以下特征。 只有一个元素 不允许重复 在Java中，Set集合的典型实现有HashSet和TreeSet，他们分别是基于HashMap和TreeMap实现的，关于这两个的分析，可以看我写过的
java集合类（五）HashSet与TreeSet应用实例
xiaotian15的专栏
04-26 595
（1）HashSet(散列表)应用（里面不能有相同的元素，当元素为对象时，需重写hashCode与equals方法）  import java.util.*; public class text1 {     public static void ptintElements(Collection c)     {         Iterator i=c.iterator();
Java集合框架：HashSet与TreeSet对比解析
"这篇文档主要讨论了Java编程中两种重要的集合类：HashSet和TreeSet，它们都是基于Set接口实现的，但各有不同的特性和使用场景。HashSet是通过哈希表（HashMap实例）来存储元素，不保证元素的排序，允许插入null元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值