头歌 ：学习-Java集合类之Set的TreeSet之整理电话簿 12-8

任务描述

本关任务：使用 TreeSet 集合整理电话簿。

相关知识

什么是 TreeSet 集合

TreeSet 集合是 Set 集合的实现类，因此它也具有元素唯一性和无序性，它的底层数据结构是 TreeMap 树结构，它确保元素的唯一性是通过 Compareable 接口的 compareto 方法，另外，它既是无序的，又是有序的。无序指的是存储元素顺序和输出顺序不同，有序指的是遍历集合时，输出的所有元素是有序的。

创建 TreeSet 集合

使用以下代码即可创建 TreeSet 集合。

public static void main(String[] args) {
        // 创建存储字符串的TreeSet集合
        Set<String> set = new TreeSet<>();
    }

TreeSet 集合的无序性

在以下代码中，往集合中存储元素的顺序为：123-aa-a，输出顺序却是123-a-aa，这就是 TreeSet 集合的无序性，即存储元素顺序和提取顺序不同。

public static void main(String[] args) {
        // 创建存储字符串的TreeSet集合
        Set<String> set = new TreeSet<>();
        // 添加元素
        set.add("123");
        set.add("aa");
        set.add("a");
        // 打印集合
        System.out.print(set);
    }

执行结果：

[123,a,aa]

TreeSet 集合的有序性

添加元素到 TreeSet 集合时，TreeSet 集合会调用元素的 compareTo() 方法来比较元素之间的大小关系，并将集合元素按升序排列，这就是它的有序性，下表展示了 TreeSet 集合对各种数据类型的默认排序规则：

元素类型	排序方式
数值类型	按数值大小
Character类型	按字符的 unicode 值来进行比较
Boolean类型	true 大于 false
String类型	按字符串中字符的 unicode 值进行比较
Date、Time类型	后边的时间、日期比前面的时间、日期大

以下代码中，往集合中分别添加元素 true 和 false，根据默认排序规则，输出结果为：[false,true]。

 public static void main(String[] args) {
        // 创建存储Boolean类型的TreeSet集合
        Set<Boolean> set = new TreeSet<>();
        // 判断集合是否为空
        boolean empty = set.isEmpty();
        System.out.println(empty);
        // 添加元素
        set.add(empty);     
        set.add(false);
        // 打印集合
        System.out.print(set);
    }

执行结果：

true
[false, true]

TreeSet 集合自定义排序

如果需要实现自定义排序，例如降序，则可以使用 Comparator 接口，该接口里包含一个 compare（T o1， T o2）方法，该方法用于比较 o1 和 o2 的大小。在创建 TreeSet 集合对象时，提供一个 Comparator 对象与该 TreeSet 集合关联，该 Comparator 对象负责集合元素的排序逻辑。

自定义降序输出示例：

import java.util.*;

// 自定义类实现Comparator
class DescSort implements Comparator<Integer> {
    // 重写compare方法
    public int compare(Integer s1, Integer s2) {
        // 如果第一个数大于第二个数，返回负数，默认为正数
        if (s1.compareTo(s2) > 0)
            return -1;
        // 如果第一个数小于第二个数，返回正数，默认为负数
        else if (s1.compareTo(s2) < 0)
            return 1;
        // 如果第一个数等于第二个数，返回0
        else
            return 0;
    }
}

public class tt {

    public static void main(String[] args) {
        // 创建存储整数的TreeSet集合
        Set<Integer> set = new TreeSet<>();
        // 创建Comparator对象
        Comparator<Integer> comp = new DescSort();
        // 把Comparator对象与TreeSet对象关联
        set = new TreeSet<Integer>(comp);
        // 添加元素
        for (int i = 9; i < 14; i++)
            set.add(i);
        // 打印集合
        System.out.print(set);
    }
}

执行结果：

[13, 12, 11, 10, 9]

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 间编写程序代码，整理给定的电话簿，具体要求如下：

• 接收给定的一行字符串（该字符串属于电话簿，包含多个电话号码，如：13545453432，13678909808）；

• 使用 HashSet 去除电话簿中可能存在的重复电话号码；

• 按升序打印去重后的电话号码。

注意：电话簿中每个电话号码的分隔符是英文逗号。

测试说明

平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。

例：测试输入：

13545454545,13223233434,18876758432,13545454545

预期输出：

13223233434
13545454545
18876758432

注意：最后一个电话号码之后有一个空行。

---

开始你的任务吧，祝你成功！

代码

/*
仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 间编写程序代码，整理给定的电话簿，具体要求如下：
- 接收给定的一行字符串（该字符串属于电话簿，包含多个电话号码，如：13545453432，13678909808,18834353432）；
- 使用 HashSet 去除电话簿中可能存在的重复电话号码；
- 按升序打印去重后的电话号码。

注意：电话簿中每个电话号码的分隔符是英文逗号。
*/

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

public class CollTest {

    public static void main(String[] args) {
        // 请在Begin-End间编写代码
        /********** Begin **********/
        // 第一步：接收给定的字符串
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        // 第二步：切割字符串
        String[] strArray = str.split(",");
        // 第三步：创建集合
        TreeSet<String> set = new TreeSet<>();
        // 第四步：将切割后的电话号码添加进集合
        for(String s:strArray){
            set.add(s);
        }
        // 第五步：输出去重后的电话号码
        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        /********** End **********/
    }
}

总结

一、TreeSet比较常见形式

TreeSet可以对元素按照某种规则进行排序：

public class test {
    public static void main(String[] args) {
        Set<Integer> s1=new TreeSet<>();
        s1.add(23);
        s1.add(3);
        s1.add(2);
        s1.add(13);
        s1.add(63);
        s1.add(25);
        s1.add(22);
        System.out.println(s1);
        Set<String> s2=new TreeSet<>();
        s2.add("c");
        s2.add("f");
        s2.add("a");
        s2.add("t");
        s2.add("j");
        s2.add("b");
        s2.add("n");
        System.out.println(s2);
    }
}

如果添加的是对象（Studen）时，如何排序呢？

class Student{
    private String name;
    private int 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;
    }
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public Student() {
    }
} 

public class test {
    public static void main(String[] args) {
        Set<Student> s1=new TreeSet<Student>();
        s1.add(new Student("zhangsan",23));
        s1.add(new Student("lisi",22));
        s1.add(new Student("wangwu",32));
        s1.add(new Student("huyijie",19));
        System.out.println("s1===================");
        for(Student s:s1){
            System.out.println(s);
        }
    }
}

会发现无法排序。

二、解决方法

1 自然排序

TreeSet存入数据后自动调用元素的compareTo(Object obj)方法，自动对数据进行排序，所以输出的数据是经过排序的数据

注：compareTo方法返回值有：负数、零、整数，分别表示小于、等于、大于。

对于存入自定义的对象元素时，要重写元素的compareTo(Object obj)方法

元素定义时，需要实现Comparable<T>接口

class Student implements Comparable<Student>{
    private String name;
    private int 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;
    }
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public Student() {
    }
 
    @Override
    public int compareTo(Student o) {
        return o.age-this.age;  //从大到小输出
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class test {
    public static void main(String[] args) {
        Set<Student> s1 = new TreeSet<Student>((o1, o2) -> o1.getAge() - o2.getAge());
        s1.add(new Student("zhangsan", 23));
        s1.add(new Student("lisi", 22));
        s1.add(new Student("wangwu", 32));
        s1.add(new Student("huyijie", 19));
        System.out.println("s1===================");
        for (Student s : s1) {
            System.out.println(s);
        }
    }
}

2 自定义比较器排序

这种方法需要一个新的类实现Comparator<T>接口，重写其中的Compare方法

TreeSet当元素不具备比较性，或者比较性不是所需要的时候，可以使TreeSet集合具有比较性，定义比较器，将比较器作为参数传给TreeSet集合，比较器需要实现Comparator接口，当元素具备比较性和比较器同时出现时，以比较器为准。

class TestComparator implements Comparator<Student>{
 
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge()-o2.getAge();
    }
}
//(o1, o2) -> o1.getAge() - o2.getAge()
public class test {
    public static void main(String[] args) {
        Set<Student> s1 = new TreeSet<Student>(new TestComparator());
        s1.add(new Student("zhangsan", 23));
        s1.add(new Student("lisi", 22));
        s1.add(new Student("wangwu", 32));
        s1.add(new Student("huyijie", 19));
        System.out.println("s1===================");
        for (Student s : s1) {
            System.out.println(s);
        }
    }
}
也可以通过匿名内部类简化，
public class test {
    public static void main(String[] args) {
        Set<Student> s1 = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.getAge()-o1.getAge();
            }
        });
        s1.add(new Student("zhangsan", 23));
        s1.add(new Student("lisi", 22));
        s1.add(new Student("wangwu", 32));
        s1.add(new Student("huyijie", 19));
        System.out.println("s1===================");
        for (Student s : s1) {
            System.out.println(s);
        }
    }
}

可再通过Lambda表达式简化，

三、TreeMap按值排序

首先说一下如果Map对key进行从小到大默认排序是创建TreeMap对象。Map<Integer,Integer> maps = new TreeMap<>();就行了。

那么如何实现按value排序呢? （把TreeMap的EntrySet转换成list，然后使用Collections.sort排序）

这里使用的是java.util.Collections类实现排序，将Map转成List，再自定义比较器，代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
 
public class MapValSort {
    public static void main(String[] args) {
        Map<String, Integer> maps = new TreeMap<String, Integer>();
        maps.put("zhangsan", 22);
        maps.put("lisi", 24);
        maps.put("wangwu", 18);
        maps.put("zhaoliu", 22);
         
        //自定义比较器
        Comparator<Map.Entry<String, Integer>> valCmp = new Comparator<Map.Entry<String,Integer>>() {
            @Override
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
                // TODO Auto-generated method stub
                return o2.getValue()-o1.getValue();  // 降序排序，如果想升序就反过来
            }
        };
        //将map转成List，map的一组key，value对应list一个存储空间
        List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String,Integer>>(maps.entrySet()); //传入maps实体
        Collections.sort(list,valCmp); // 注意此处Collections 是java.util包下面的,传入List和自定义的valCmp比较器
        //输出map
        for(int i=0;i<list.size();i++) {
            System.out.println(list.get(i).getKey() + " = " + list.get(i).getValue());
        }
    }
}

四、关于compareTo方法

compareTo() 方法用于将 Number 对象与方法的参数进行比较。可用于比较 Byte, Long, Integer等。

compareTo方法从第一位开始比较, 如果遇到不同的字符,则马上返回这两个字符的ascii值差值.返回值是int类型

返回参与比较的前后两个字符串的asc码的差值，如果两个字符串首字母不同，则该方法返回首字母的asc码的差值

String a1 = "a";
 
String a2 = "c";       
 
System.out.println(a1.compareTo(a2));//结果为-2

即参与比较的两个字符串如果首字符相同，则比较下一个字符，直到有不同的为止，返回该不同的字符的asc码差值

String a1 = "aa";
 
String a2 = "ad";       
 
System.out.println(a1.compareTo(a2));//结果为-3

如果两个字符串不一样长，可以参与比较的字符又完全一样，则返回两个字符串的长度差值

String a1 = "aa";
 
String a2 = "aa12345678";       
 
System.out.println(a1.compareTo(a2));//结果为-8

返回为正数表示a1>a2, 返回为负数表示a1<a2，返回0表示a1==a2。

数字类型不能用compareTo，nt跟int的比较不能用compareTo方法,直接用大于(>) 小于(<) 或者 等于(==) 不等于(!=)来比较即可

int型可以直接比较，所以没有用到compareTo比较，如果声明的是Date、String、Integer、或者其他的，可以直接使用compareTo比较，

Integer n1 = 5;
 
Integer n2 = 6;
 
System.out.println(n1.compareTo(n2));//-1