JavaSE进阶系列(八)、Set接口、Collections

最新推荐文章于 2024-05-16 10:23:10 发布
最新推荐文章于 2024-05-16 10:23:10 发布
阅读量118 收藏
点赞数
分类专栏： Java编程技术 文章标签： java set
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52596258/article/details/114356975
版权

第四章 Set接口

java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口，它与 Collection 接口中的方法基本一致，并没有对 Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。与 List 接口不同的是， Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

Set 集合有多个子类，这里我们介绍其中的 java.util.HashSet 、 java.util.LinkedHashSet 这两个集合。
tips:Set集合取出元素的方式可以采用：迭代器、增强for。

4.1 HashSet集合介绍

java.util.HashSet 是 Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。 java.util.HashSet 底层的实现其实是一个 java.util.HashMap 支持，由于我们暂时还未学习，先做了解。

HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于： hashCode 与 equals 方法。

我们先来使用一下Set集合存储，看下现象，再进行原理的讲解:

public class HashSetDemo {
    public static void main(String[] args) {
        //创建 Set集合
        HashSet<String> set = new HashSet<String>();
        //添加元素
        set.add(new String("cba"));
        set.add("abc");
        set.add("bac");
        set.add("cba");
        //遍历
        for (String name : set) {
        		System.out.println(name);
        }
    }
}

输出结果如下，说明集合中不能存储重复元素：

cba
abc
bac

tips:根据结果我们发现字符串"cba"只存储了一个，也就是说重复的元素set集合不存储。

4.2 HashSet集合存储数据的结构（哈希表）

什么是哈希表呢？

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。

但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。

在这里插入图片描述

看到这张图就有人要问了，这个是怎么存储的呢？
为了方便大家的理解我们结合一个存储流程图来说明一下：

在这里插入图片描述

总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲保证HashSet集合元素的唯一，

其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，

就必须复写hashCode和equals方法建立属于当前对象的比较方式。

4.3 HashSet**存储自定义类型元素

**给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

创建自定义Student类

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

public class HashSetDemo2 {
        public static void main(String[] args) {
            //创建集合对象 该集合中存储 Student类型对象
            HashSet<Student> stuSet = new HashSet<Student>();
            //存储
            Student stu = new Student("于谦", 43);
            stuSet.add(stu);
            stuSet.add(new Student("郭德纲", 44));
            stuSet.add(new Student("于谦", 43));
            stuSet.add(new Student("郭麒麟", 23));
            stuSet.add(stu);
            for (Student stu2 : stuSet) {
              System.out.println(stu2);
            }
        }
}

执行结果：

Student [name=郭德纲, age=44]
Student [name=于谦, age=43]
Student [name=郭麒麟, age=23]

4.4linkedHashSet

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？
在HashSet下面有一个子类 java.util.LinkedHashSet ，它是链表和哈希表组合的一个数据存储结构。

演示代码如下:

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<String>();
        set.add("bbb");
        set.add("aaa");
        set.add("abc");
        set.add("bbc");
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
        		System.out.println(it.next());
        }
    }
} 

结果：
  bbb
  aaa
  abc
  bbc

4.5 可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格
式：

修饰符 返回值类型 方法名(参数类型... 形参名){ }

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){ }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。
JDK1.5以后。出现了简化操作。… 用在参数上，称之为可变参数。

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

代码演示：

public class ChangeArgs {
    public static void main(String[] args) {
        int[] arr = { 1, 4, 62, 431, 2 };
        int sum = getSum(arr);
        System.out.println(sum);
        // 6 7 2 12 2121
        // 求 这几个元素和 6 7 2 12 2121
        int sum2 = getSum(6, 7, 2, 12, 2121);
        		System.out.println(sum2);
     } 
  			/**
        完成数组 所有元素的求和 原始写法
        public static int getSum(int[] arr){
        int sum = 0;
        for(int a : arr){
        sum += a;
        } r
        eturn sum;
        }
        */
        //可变参数写法
        public static int getSum(int... arr) {
          int sum = 0;
          for (int a : arr) {
          sum += a;
       		} 
          return sum;
    		}
}

tips: 上述add方法在同一个类中，只能存在一个。因为会发生调用的不确定性
注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末
尾位置。`

第五章 Collections

5.1 常用功能

  • java.utils.Collections 是集合工具类，用来对集合进行操作。部分方法如下：

  • public static boolean addAll(Collection c, T… elements) :往集合中添加一些元素。

  • public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。

  • public static void sort(List list) :将集合中元素按照默认规则排序。

  • public static void sort(List list，Comparator<? super T> ) :将集合中元素按照指定规则排序。

    代码演示：

public class CollectionsDemo {
    public static void main(String[] args) {
      ArrayList<Integer> list = new ArrayList<Integer>();
      //原来写法
      //list.add(12);
      //list.add(14);
      //list.add(15);
      //list.add(1000);
      //采用工具类 完成 往集合中添加元素
      Collections.addAll(list, 5, 222, 1，2);
      System.out.println(list);
      //排序方法
      Collections.sort(list);
      System.out.println(list);
    }
} 
结果：
[5, 222, 1, 2]
[1, 2, 5, 222]

代码演示之后 ，发现我们的集合按照顺序进行了排列，可是这样的顺序是采用默认的顺序，如果想要指定顺序那该怎么办呢？

我们发现还有个方法没有讲， public static void sort(List list，Comparator<? super T> ) :将集合中元素按照指定规则排序。接下来讲解一下指定规则的排列。

**5.2 Comparator****比较器

**我们还是先研究这个方法public static void sort(List list) :将集合中元素按照默认规则排序。不过这次存储的是字符串类型。

public class CollectionsDemo2 {
    public static void main(String[] args) {
      ArrayList<String> list = new ArrayList<String>();
      list.add("cba");
      list.add("aba");
      list.add("sba");
      list.add("nba");
      //排序方法
      Collections.sort(list);
      System.out.println(list);
    }
}

结果：

[aba, cba, nba, sba]

我们使用的是默认的规则完成字符串的排序，那么默认规则是怎么定义出来的呢？

说到排序了，简单的说就是两个对象之间比较大小，那么在JAVA中提供了两种比较实现的方式，一种是比较死板的采用 java.lang.Comparable 接口去实现，一种是灵活的当我需要做排序的时候在去选择的java.util.Comparator 接口完成。

那么我们采用的 public static void sort(List list) 这个方法完成的排序，实际上要求了被排序的类型需要实现Comparable接口完成比较的功能，在String类型上如下：

public final class String implements java.io.Serializable,Comparable<String>,CharSequence {

String类实现了这个接口，并完成了比较规则的定义，但是这样就把这种规则写死了，那比如我想要字符串按照第一个字符降序排列，那么这样就要修改String的源代码，这是不可能的了，那么这个时候我们可以使用public static void sort(List list，Comparator<? super T> ) 方法灵活的完成，这个里面就涉及到了Comparator这个接口，位于位java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较器具有可比性！顾名思义就是做排序的，通俗地讲需要比较两个对象谁排在前谁排在后，那么比较的方法就是：

  • public int compare(String o1, String o2) ：比较其两个参数的顺序。

两个对象比较的结果有三种：大于，等于，小于。
如果要按照升序排序， 则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数） 如果要按照
降序排序 则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）

操作如下:

public class CollectionsDemo3 {
  public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<String>();
    list.add("cba");
    list.add("aba");
    list.add("sba");
    list.add("nba");
    //排序方法 按照第一个单词的降序
    Collections.sort(list, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o2.charAt(0) ‐ o1.charAt(0);
        }
    });
    System.out.println(list);
  }
}

结果如下：

[sba, nba, cba, aba]

5.3 简述Comparable和Comparator两个接口的区别。

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

5.4 练习

创建一个学生类，存储到ArrayList集合中完成指定排序操作。
Student 初始类

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

测试类：

public class Demo {
  public static void main(String[] args) {
    // 创建四个学生对象 存储到集合中
    ArrayList<Student> list = new ArrayList<Student>();
    list.add(new Student("rose",18));
    list.add(new Student("jack",16));
    list.add(new Student("abc",16));
    list.add(new Student("ace",17));
    list.add(new Student("mark",16));
    /*
    让学生 按照年龄排序 升序
    */
    // Collections.sort(list);//要求 该list中元素类型 必须实现比较器Comparable接口
    for (Student student : list) {
    	System.out.println(student);
    }
  }
}

发现，当我们调用Collections.sort()方法的时候 程序报错了。
原因：如果想要集合中的元素完成排序，那么必须要实现比较器Comparable接口。
于是我们就完成了Student类的一个实现，如下：

public class Student implements Comparable<Student>{
  ....
  @Override
  public int compareTo(Student o) {
  	return this.age‐o.age;//升序
  }
}

再次测试，代码就ok了：

Student{name='jack', age=16}
Student{name='abc', age=16}
Student{name='mark', age=16}
Student{name='ace', age=17}
Student{name='rose', age=18}

5.5 扩展

如果在使用的时候，想要独立的定义规则去使用 可以采用Collections.sort(List list,Comparetor c)方式，自己定义
规则：

Collections.sort(list, new Comparator<Student>() {
  @Override
  public int compare(Student o1, Student o2) {
 		 return o2.getAge()‐o1.getAge();//以学生的年龄降序
  }
});

效果：

Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='jack', age=16}
Student{name='abc', age=16}
Student{name='mark', age=16}

如果想要规则更多一些，可以参考下面代码：

Collections.sort(list, new Comparator<Student>() {
  @Override
  public int compare(Student o1, Student o2) {
    // 年龄降序
    int result = o2.getAge()‐o1.getAge();//年龄降序
    if(result==0){
      //第一个规则判断完了 下一个规则 姓名的首字母 升序
    result = o1.getName().charAt(0)‐o2.getName().charAt(0);
    } 
    return result;
  }
});

效果如下：

Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='abc', age=16}
Student{name='jack', age=16}
Student{name='mark', age=16}
一宿君
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
JavaSE进阶-03-常用类.pdf
09-10
2020动力节点老杜javaSE进阶班-常用类03教材，希望各位想学习和巩固javaSE的下载学习。楼主最近也在学习这个，配合视频感觉蛮好的。。。。。。
dljd javaSE进阶教材
03-28
dljd javaSE进阶教材
1.4 Set集合：HashSet和TreeSet类
you can you up up up的博客
09-10 414
Set 集合 无序的，不能包含重复的对象 Set 集合类似于一个罐子，程序可以依次把多个对象“丢进”Set 集合，而 Set 集合通常不能记住元素的添加顺序。 也就是说 Set 集合中的对象不按特定的方式排序，只是简单地把对象加入集合-------无序。 Set 集合中不能包含重复的对象，并且最多只允许包含一个 null 元素---------不能重复元素。 Set 实现了 Collection 接口，它主要有两个常用的实现类：HashSet 类和 TreeSet类。 HashSet 类 HashSet
Java数据结构之HashSet
qq_45596525的博客
05-03 254
set接口简介 Set接口中的元素是无序的 , 并且会以某种规则保证存入的元素不会重复出现 分为HashSet 和 TreeSet 两个具体实现 HashSet 顾名思义 , 它是由hash值确定元素在容器中的存储位置的 , 下面我们介绍一下 什么是hash? hash 即散列 是分散排布的 , 由hash函数确定排序的规则 什么是hash函数? 一般形式 F(KEY) , 是关键字key与记录...
Set接口及实现类
Luis
06-12 577
1. 概述 Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。 特点 不允许存储重复的元素 没有索引,没有带索引的方法,也不能使用普通的for循环遍历 Set集合取出元素的方式可以采用：迭代器、增强for。普通for不行！ Set集合有多个子类，这里我们介绍其中的HashSet、LinkedHashSet这两个集合。 2. HashSet集合 java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。java.ut
Java---集合（2）
hzyao的博客
08-11 163
1.Set集合 1.1 概述和特点 Set集合的特点 元素存取无序 没有索引、只能通过迭代器或增强for循环遍历 不能存储重复元素 1.2哈希值 哈希值简介 是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值 如何获取哈希值 Object类中的public int hashCode()：返回对象的哈希码值 哈希值的特点 同一个对象多次调用hashCode()方...
Java 之 Set 接口
a804847944的博客
08-31 102
一、概述 　　java.util.Set 接口继承 collection 接口，它与 Collection 接口中的方法基本一致，并没有对 Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。 　　Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。 　　Set 集合不是同步的，多线程的。 　　特点：查询速度快，不重复，没有索...
JavaSE进阶-02-数组.pdf
09-10
2020动力节点老杜javaSE进阶班-数组02教材，希望各位想学习和巩固javaSE的下载学习。楼主最近也在学习这个，配合视频感觉蛮好的。。。。。。
JavaSE进阶-05-集合.pdf
09-10
2020动力节点老杜javaSE进阶班-集合05教材，希望各位想学习和巩固javaSE的下载学习。楼主最近也在学习这个，配合视频感觉蛮好的。。。。。。
JAVASE进阶.xmind
07-31
JAVASE进阶.xmind
Set接口
XWH_Vinku的博客
07-27 98
Set接口 java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口，它与 Collection 接口中的方法基本一致，并没有对 Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。与 List 接口不同的是， Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。 Set集合取出元素的方式可以采用：迭代器、增强for。 Set 接口也是 Collection 的子接口，与 List 接口最大
如何存储一个没有重复元素的数组(Set接口的详细使用方法)
m0_55749088的博客
04-01 1451
如何存储一个没有重复元素的数组(Set接口的详细使用方法)
深入了解——Java集合中Collection的子接口——Set接口（HashSet、TreeSet集合）详细--很详细--及其详细
girls的博客
06-04 518
首先说明一点： Set接口中的方法和Collection接口中的方法完全一致，不增不减 说明：Set接口和List接口一样，同样继承自Collection接口。 特点：Set接口中的元素无序，并且都会以某种规则保证存入的元素不出现重复。 Set接口主要实现： HashSet：根据对象的哈希值来确定元素在集合中的存储的位置，因此具有良好的存取和查找性能 TreeSet:以二叉树的方式来存储元素，它可以实现对集合中的元素进行排序 HashSet集合 说明：HashSet是Set接口的一个实现类，它所存
2021-10-29 迈向程序猿的第十七步
qq_48654729的博客
10-29 174
目录 一.Collections工具类 二.Set实现类HashSet 2.1 HashSet存储原理 2.2 hashSet验证原理 三. Set实现类LinkedHashSet 3.1 LinkedHashSet使用特点 四. Set实现类TreeSet 4.1 TreeSet的使用特点 4.2 存储原理分析 一.Collections工具类 主要是为List集合服务，进行相关的List功能处理 //注意： Collection与Collections要区分开 //扩展了解.
jdk8新特性----Lambda表达式
w_t_y_y的博客
05-11 416
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 89
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 336
本文主要提供用java实现的拼图小游戏源代码。
我想给我有关JAVASe系列的博客起一个好听的名字
03-09
关于给您的JAVA SE系列博客起一个好听的名字，我建议您可以考虑以下几个方面：1. 突出JAVA SE系列的特点和优势；2. 突出您的个人特色和风格；3. 突出博客的主题和定位。根据这些方面，您可以考虑一些名字，比如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一宿君

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值