Java学习之路(八)：Set

Set集合概述以及特点：

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

HashSet

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

我们一般使用HashSet来去重：

我们需要重写累的hashCode（）和equals（）方法

HashSet去重的依据：

　　首先会比较hashCode()，如果不一样则存进去，如果一样的话，调用equals（）方法进行比较，如果返回True就不存储，false存储

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

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

31刚刚好，既不大也不小

31这个数好算，2的五次方-1，相当于向左移5位-1

答案

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

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

}

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

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 存储自定义对象：

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

如果想用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;
    }
}

以上是最简单的一个例子，然后呢，我们现在需要实现：

　　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的排序方式有两种：

自然排序
比较器顺序

自然顺序：

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

比较器顺序：

创建TreeSet的时候可以定制一个Comparator
如果传入了Comparator的子类对象，那么TreeSet就会按照比较器的规则比较
add方法内部会调用Comparator接口中的compare方法排序
调用的对象是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类

posted @ 2018-07-27 00:30 "%201 阅读(268) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

smiling_and_crying