LinkedHashSet

• HashSet得到的数据是无序的--->能不能得到的数据是有序的，嫩不能按照输入原序输出？---->LinkedHashSet

特点

• 唯一
• 有序（按照输入顺序输出）
• 多了一个总链表，按装入顺序串在一起

原理

• 其实就是在HashSet的基础上，多了一个总的链表，这个总链表将放入的元素串在一起，方便有序的遍历。

比较器引入

比较器的使用

1. 以int类型为案列：

   • 比较思路：将比较的数据做差，然后返回一个int类型的数据，将这个int类型的数值 按照=0 >0 <0

2. 比较String类型的数据

   • String类实现了CompareTo接口，这个接口有一个抽象方法compareTo，String类中重写这个方法即可

           String a = "A";
           String b = "B";
           //String类里有compareTo方法以供比较
           System.out.println(a.compareTo(b));
   

3. 比较double类型数据

           double a = 9.6;
           double b = 9.3;
           System.out.println(((Double) a).compareTo((Double) b));
           //将a转成Double，调用compareTo，传入b转成Double的值，再输出
   

4. 比较自定义的数据类型

   • 内部比较器
     1. 实现Comparable接口
     2. 对compareTo进行重写

   //学生类
   public class Student implements Comparable<Student>{
       private int age;
       private double height;
       private String name;
   
       @Override
       public int compareTo(Student o) {
           //按照年龄比
   /*        return this.getAge()-o.getAge();//this-->当前对象*/
   
           //按照身高比
   /*        return ((Double)(this.getHeight())).compareTo((Double) o.getHeight());*/
           //转换成Double后直接用Double里的compareTo方法进行比较
   
           //按照名字进行比较
           return this.getName().compareTo(o.getName());
           //name就是String类型，直接用String里的compareTo
       }
       //后面是get/set发法等
   

   public class Test02 {
       public static void main(String[] args) {
           //比较两个学生
           Student s1 = new Student(10, 160.5, "lili");
           Student s2 = new Student(14, 170.5, "nana");
           //没有compareTo--->自己实现Comparable接口--->重写compareTo方法
           System.out.println(s1.compareTo(s2));
       }
   }
   

   • 外部比较器

     
     public class Student {
         private int age;
         private double height;
         private String name;
     
         public Student(int age, double height, String name) {
             this.age = age;
             this.height = height;
             this.name = name;
         }
     
         @Override
         public String toString() {
             return "Student{" +
                     "age=" + age +
                     ", height=" + height +
                     ", name='" + name + '\'' +
                     '}';
         }
     
         public double getHeight() {
             return height;
         }
     
         public void setHeight(double height) {
             this.height = height;
         }
     
         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;
         }
     }
     
     class BiJiao01 implements Comparator<Student> {//外部比较器-->实现Comparator接口-->重写compare方法
         @Override
         public int compare(Student o1, Student o2) {//传入两个学生
             //比较年龄
             return o1.getAge()-o2.getAge();
         }
     }
     class BiJiao02 implements Comparator<Student> {//再写一个，模块化
     
         @Override
         public int compare(Student o1, Student o2) {
             //比较名字
             return o1.getName().compareTo(o2.getName());
         }
     }
     class BiJiao03 implements Comparator<Student> {//再写一个，模块化
     
         @Override
         public int compare(Student o1, Student o2) {
             //在年龄相同的情况下，比较身高
             if ((o1.getAge()- o2.getAge())==0){
                 return ((Double)o1.getHeight()).compareTo((Double) o2.getHeight());
             }else {
                 return o1.getAge()- o2.getAge();
             }
         }
     }
     

             //比较两个学生
             Student s1 = new Student(10, 160.5, "lili");
             Student s2 = new Student(14, 170.5, "nana");
             //获取外部比较器
             Comparator bj1 =new BiJiao01();//接口等于实现类-->方便多态
             System.out.println(bj1.compare(s1, s2));//调用外部比较器方法
             bj1 = new BiJiao02();//多态
             System.out.println(bj1.compare(s1, s2));
     

5. 外部比较器和内部比较器谁好？

   • 外部比较器好，多态，扩展性好