Java学习之路(八)：Set

时间  2019-11-24
标签 java 学习 之路 set 栏目 Java 繁體版
原文   原文链接

Set集合概述以及特色：

  • set 是一个不包含重复元素的collection
  • set只是一个接口，通常使用它的子类HashSet，LinkedHashSet，TreeSet

HashSet

  • 此类是Set接口的实现类，有哈希表支持
  • 它不保证set的迭代顺序，特别是不保证顺序的恒久不变
  • 此类容许使用null元素

咱们通常使用HashSet来去重：java

  • 咱们须要重写累的hashCode（）和equals（）方法

HashSet去重的依据：面试

　　首先会比较hashCode()，若是不同则存进去，若是同样的话，调用equals（）方法进行比较，若是返回True就不存储，false存储数组

面试题：为何自动生成hashCode的时候有个31的数？less

31是一个质数，质数是能被1和本身自己整除的数，没有公约数

31刚恰好，既不大也不小

31这个数好算，2的五次方-1，至关于向左移5位-1
答案

案例：产生10个1-20之间的随机数要求随机数不能重复dom

package l1;

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class Demo01 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Set<Integer> set = new HashSet<Integer>();
        Random rd = new Random();
        while(set.size()!=10){
            int r = rd.nextInt(21);  //生成1-20之间的随机数
            if(r!=0){
                set.add(r);
            }
        }
        System.out.println(set);
        
        
    }

}

 案例：从键盘读取一行输入，去掉重复字符并打印ide

package l2;

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Demo2 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一行内容");
        String line = sc.nextLine();
        
        //将字符串转化为字符数组
        char[] ch = line.toCharArray();
        
        Set<Character> set = new HashSet<Character>();
        for(char a:ch){
            set.add(a);
        }
        
        System.out.println(set);
    }

}

 

 案例：使用HashSet（）过滤List集合中的重复的元素函数

package l3;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Demo3 {

    public static void main(String[] args) {
        List<String> li = new ArrayList<String>();
        li.add("A");
        li.add("B");
        li.add("A");
        li.add("A");
        Set<String> set = new HashSet<String>();
        set.addAll(li);
        System.out.println(set);

    }

}

 

 LinkedHashSet的概述和使用

  • LinkedHashSet是一个具备可预知迭代顺序的Set接口
  • 内部实现是使用哈希表和连接列表
  • LinkedHashSet的特色是能够保证怎么存就怎么取
  • LinkedHashSet是set集合中惟一一个能保证怎么存就怎么取的集合对象
  • LinkedHashSet是HashSet的子类，因此也是保证元素惟一的，实现原理和HashSet同样

TreeSet的概述和使用 

  • TreeSet是一个能够用于排序的集合、
  • TreeSet给予TreeMap的NavigableSet实现
  • TreeSet的排序方法有两种：
    • 使用元素的天然顺序Comparable对元素进行排序
    • 使用构造方法的Comparator进行排序

使用TreeSet 存储自定义对象：ui

注意：使用TreeSet存储自定义对象是会出现异常：xxxx cannot be cast to java.lang.Comparablethis

  • 若是想用TreeSet存储自定义对象，这个对象必需要实现Comparable接口
  • 此接口强行堆实现它的每一个类的对象进行排序
  • 这种排序被称为天然排序，类的compareTo方法被成为它的天然比较方法
  • 当compareTo方法返回0的时候，集合只会保留一个元素
  • 当compareTo方法返回正数的时候，集合怎么存就怎么取
  • 当compareTo方法返回负数的时候，集合会倒序存储

TreeSet存储自定义对象并遍历

package lesson0001;

import java.util.Set;
import java.util.TreeSet;

public class Demo1 {

    public static void main(String[] args) {

        Set<Student> set = new TreeSet<Student>();
        set.add(new Student(1,"n1"));
        set.add(new Student(2,"n2"));
        set.add(new Student(3,"n3"));
        for(Student std:set){
            System.out.println(std);
        }
    }

}

class Student implements Comparable{
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    @Override
    public int compareTo(Object arg0) {
        return 1;
    }
}

 

以上是最简单的一个例子，而后呢，咱们如今须要实现：spa

　　TreeSet存储自定义对象而且遍历，并且要按照姓名长度，字母，年龄顺序排序

  • 经过比较字符串的compareTo比较大小
  • 排序按照unicode码的大小进行排序
  • 防止名字相同，但年龄不一样的Bug
package lesson0002;

import java.util.Set;
import java.util.TreeSet;

public class Demo1 {

    public static void main(String[] args) {

        Set<Student> set = new TreeSet<Student>();
        set.add(new Student(1,"aaaa"));
        set.add(new Student(5,"aaaa"));
        set.add(new Student(2,"aaaa"));
        set.add(new Student(1,"aaa"));
        set.add(new Student(1,"aa"));
        for(Student std:set){
            System.out.println(std);
        }
        
    }

}
main代码 
package lesson0002;

public class Student implements Comparable<Student> {
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    

    public Student(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public int compareTo(Student o) {
        int length = this.name.length() - o.name.length();
        int num = length == 0?this.name.compareTo(o.name):length;
        return num == 0?this.age-o.age:num;
    }
    @Override
    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    }
    

    
}
Student类

 

TreeSet除了这种自定义排序意外还能够定义一种自定义排序：比较器（Comparator）

package lesson0003;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

//比较器排序


public class Demo1 {

    public static void main(String[] args) {

        Set<String> set = new TreeSet<String>(new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                
                int num = o1.compareTo(o2);//默认的从小到大
                num = num==0?1:num;  //若是相同返回1，即保存同名的元素
                return num;
            }
        });
        
        
        set.add("aaa");
        set.add("bbb");
        set.add("ccc");
        set.add("aaa");
        set.add("aa");
        for(String s:set){
            System.out.println(s);
        }
    }

}

 

TreeSet的总结

TreeSet是用来排序的，能够指定一个顺序，对象存入以后会按照指定的顺序排序

TreeSet的排序方式有两种：

  • 天然排序
  • 比较器顺序

天然顺序：

  1. TreeSet类的add方法会把存入的对象提高为Comparable类型
  2. 调用对象的compareTo方法进行比较
  3. 根据compareTo方法返回的结果进行一个存储

比较器顺序：

  1. 建立TreeSet的时候能够定制一个Comparator
  2. 若是传入了Comparator的子类对象，那么TreeSet就会按照比较器的规则比较
  3. add方法内部会调用Comparator接口中的compare方法排序
  4. 调用的对象是compare方法的第一个参数，集合中的对象是compare方法的第二个参数

天然排序和比较器排序的区别：

  • TreeSet构造函数什么都不传，默认按照类中的Comparable的排序
  • TreeSet若是传入Comparator，就优先按照Comparator（即，比较器排序要优先）

练习题案例：

1.在一个集合中存储了无序而且重复的字符串，让其有序，并且不能去除重复

我上面例子中，比较器排序的那个例子就是
答案

 

2.从键盘输入多个整数，直到输入quit时结束输入。把全部输入的整数倒叙排列打印

package lesson0004;

import java.util.Comparator;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class Demo01 {

    public static void main(String[] args) {
        
        Set<Integer> set = new TreeSet<Integer>(new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                // TODO Auto-generated method stub
                return (o2-o1)==0?1:(o2-o1);
//                return o2-o1;
            }
        });
        
        Scanner sc = new Scanner(System.in);
        while(true){
            String str = sc.nextLine();
            if("quit".equals(str)){
                break;
            }else{
                set.add(Integer.parseInt(str));
            }
        }
        for(Integer i:set){
            System.out.println(i);
        }

        
        
    }

}
答案

 

 

 

3.键盘录入学生信息按照总分排序后输出在控制台

package lesson0005;

import java.util.Comparator;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class Demo1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        Set<Student> set = new TreeSet<Student>();
        
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("请按照格式输入学生信息（学生名：年龄：成绩）");
            String line = sc.nextLine();
            if("quit".equals(line)){
                break;
            }else{
                String name = line.split(":")[0];
                int age = Integer.parseInt(line.split(":")[1]);
                int score = Integer.parseInt(line.split(":")[2]);
                set.add(new Student(name,age,score));
            }
        }
        for(Student std:set){
            System.out.println(std);
        }
        
        
    }

}
答案：main 
package lesson0005;

public class Student implements Comparable<Student> {

    private String name;
    private int age;
    private int score;
    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;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
    }
    public Student() {
        super();
    }
    public Student(String name, int age, int score) {
        super();
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public int compareTo(Student o) {
        int num = o.score - this.score;
        num =  num==0?this.name.compareTo(o.name):num;
        num =  num==0?(this.age-o.age):num;
        return num==0?1:num;
    }
    
    
    
}
答案：Student类
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程