Collections集合工具类的方法sort(list，Comparator)

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

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

Comparator和Comparable的区别

　　comparable:自己(this)和别人(参数)比较,自己需要实现comparable接口,重写比较的规则compareTo方法

　　comparator:相当于找一个第三方的裁判,比较两个

Person

public class student{
    private String name;
    private int age;

    public student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public student() {
    }

    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 static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add( 1);
        list1.add( 3);
        list1.add(2);
        System.out.println(list1);
        Collections.sort(list1,new Comparator<Integer>() {
            //重写比较的规则
            @Override
            public int compare( Integer o1,Integer o2) {
                return o2-o1;//降序
            }
        });
        System.out.println(list1);
        ArrayList<student> list02 = new ArrayList<>();
        list02.add( new student("虎二", 18));
        list02.add(new student( "莉莉安",20));
        list02.add(new student("李青",17));
        list02.add(new student( "巴德", 18));

        Collections.sort(list02, new Comparator<student>() {
            @Override
            public int compare(student o1, student o2) {
               int i = o1.getAge()-o2.getAge();
               if (i==0){
                   i = o1.getName().charAt(0)-o2.getName().charAt(0);
               }
               return i;
            }
        });
        System.out.println( list02) ;
    }

Person

public class person implements Comparable<person>{
private String name;
private int age;

public person() {
}

public person(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) {
System.out.println(getClass());//通过反射获取当前类的类型，即person
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
person person = (person) o;
return age == person.age &&
Objects.equals(name, person.name);//使用Objects中的equals方法，可以避免空指针异常
}

@Override
public int hashCode() {
return Objects.hash(name, age);
}

@Override
public String toString() {
return "person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}

@Override
public int compareTo(person o) {
return this.getAge()-o.getAge();//按年龄升序排序
}
}

private static void show() {
        LinkedList<String> listStr = new LinkedList<>();
        listStr.add("1123");
        listStr.add("122");
 
        //方式1
        /*listStr.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });*/
 
        //方式2
        Collections.sort(listStr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return Integer.parseInt(o1)-Integer.parseInt(o2);
            }
        });
        System.out.println(listStr);
 
    }

Student 初始类

    package com.learn.demo05.Collections;
     
    public class Student {
        private String name;
        private int age;
     
        public Student() {
        }
     
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
     
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", 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;
        }
    }


测试类：

    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;//升序
        }
    }

再次测试 效果如下：

    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}

Map集合概述

java.utiL. Map<k, v>集合

　　Map集合的特点;
　　　　1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)

　　　　2.Map集合中的元素,key和value的数据类型可以相同,也可以不同

　　　　3.Map集合中的元素,key是不允许重复的, volue是可以重复的

　　　　4 .Map集合中的元素,key和value是——对应

Map集合的完整格式：

Map集合的特点：
1.Map是一个双列集合，一个元素包含两个值（一个key，一个value）

2.Map集合中的元素，key和value的数据类型可以相同，也可以不同

3.Map中的元素，key不允许重复，value可以重复

4.Map里的key和value是一一对应的。

二、Map中的方法:

1.public   V  put （K key，V value） 把指定的键和值添加到Map集合中，返回值是V

如果要存储的键值对，key不重复返回值V是null

如果要存储的键值对，key重复返回值V是被替换的value值

现实生活中，我们常会看到这样的一种集合:IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。

　　jJava提供了专门的集合类用来存放这种对象关系的对象，即 java.util.Map接口。

我们通过查看Map接口描述，发现wap.接口下的集合与collection接口下的集合，它们存储数据的形式不同