集合排序概述

数组的排序

int[] arr= {2,3,4,5,2,1};
Arrays.sort(arr);

集合排序
使用Collection类的sort方法

sort(List<T>list)

--根据元素的自然顺序对指定列表按升序进行排序，整型数据从小到大，对于字符串和字符数据，会按ASCII码值对其进行排序

案例：对整型进行排序

package com.imooc.sort;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class IntSort {

public static void main(String[] args) {
    // 对存储在List中的整型数据进行排序
    List<Integer> list=new ArrayList<Integer>();
    list.add(5);
    list.add(9);
    list.add(3);
    list.add(1);
    System.out.println("排序前：");
    for(int n:list){
        System.out.print(n+"    ");
    }
    System.out.println();
    //对List中的数据进行排序
    Collections.sort(list);
    System.out.println("排序后：");
    for(int n:list){
        System.out.print(n+"    ");
    }
}
}

案例：对字符串进行排序

package com.imooc.sort;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class StringSort {

public static void main(String[] args) {
    // 对存放在List中的字符串进行排序
    List<String> list=new ArrayList<String>();
    list.add("orange");
    list.add("blue");
    list.add("yellow");
    list.add("gray");
    System.out.println("排序前：");
    for(String s:list){
        System.out.print(s+"   ");
    }
    System.out.println();
    Collections.sort(list);
    System.out.println("排序后：");
    for(String s:list){
        System.out.print(s+"   ");
    }
}

}

编程练习1

对英文单词进行排序，效果图如下：

任务

1、 给list添加元素

2、 输出排序前list中的内容

3、对list中的元素进行排序

4、输出排序后list中的内容

package me.feihong.string;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class StringSort {

public static void main(String[] args) {
    //给list添加元素
    List<String> list=new ArrayList<String>();
    list.add("orange");
    list.add("tomato");
    list.add("apple");
    list.add("litchi");
    list.add("banana");

    //输出排序前list中的内容
    System.out.println("排序前：");
    for(String s:list) {
        System.out.print(s+"   ");
    }
     System.out.println();  

    //对list中的元素进行排序
    Collections.sort(list);

    //输出排序后list中的内容
    System.out.println("排序后：");
    for(String s:list) {
        System.out.print(s+"   ");
    }
}

}

Comparator接口介绍

疑问：自定义的类如何排序
解决办法：使用Comparable或Comparator接口
Comparator接口：
强行对某个对象进行整体排序的比较函数
可以将Comparator传递给sort方法（如Collections.sort或 Arrays.sort）
int compare(T o1, T o2) 比较用来排序的两个参数
--如果o1<o2,返回负整数
--如果o1==o2，返回0
--如果o1>o2，返回正整数
boolean equals(Object obj)指示某个其他对象是否“等于”此Comparator
此方法可以被Object类中的equals方法覆盖，不必重写，也就是说，我们在Comparator接口中只需要重写compare这个方法

案例：对宠物猫进行排序

package com.imooc.sort;

public class Cat {
    private String name; //名字
    private int month; //年龄
    private String species;//品种
    
//构造方法
public Cat(String name, int month, String species) {
    super();
    this.name = name;
    this.month = month;
    this.species = species;
}
//getter与setter方法
public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getMonth() {
    return month;
}

public void setMonth(int month) {
    this.month = month;
}

public String getSpecies() {
    return species;
}

public void setSpecies(String species) {
    this.species = species;
}
@Override
public String toString() {
    return "[名字：" + name + ", 年龄：" + month + ", 品种：" + species + "]";
}

}
package com.imooc.sort;

import java.util.Comparator;

public class NameComparator implements Comparator<Cat> {

@Override
public int compare(Cat o1, Cat o2) {
    // 按名字升序排序
    String name1=o1.getName();
    String name2=o2.getName();
    int n=name1.compareTo(name2);
    return n;
}

}
package com.imooc.sort;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CatTest {

public static void main(String[] args) {
    // 按名字升序排序
    Cat huahua=new Cat("huahua",5,"英国短毛猫");
    Cat fanfan=new Cat("fanfan",2,"中华田园猫");
    Cat maomao=new Cat("maomao",3,"中华田园猫");
    List<Cat> catList=new ArrayList<Cat>();
    catList.add(huahua);
    catList.add(fanfan);
    catList.add(maomao);
    //排序前
    System.out.println("排序前：");
    for(Cat cat:catList){
        System.out.println(cat);
    }
    //按名字进行升序排序
    Collections.sort(catList, new NameComparator());
    System.out.println("按名字升序排序后：");
    for(Cat cat:catList){
        System.out.println(cat);
    }
    //按年龄进行降序排序
    Collections.sort(catList, new AgeComparator());
    System.out.println("按年龄降序排序后：");
    for(Cat cat:catList){
        System.out.println(cat);
    }
}

}
package com.imooc.sort;

import java.util.Comparator;

public class AgeComparator implements Comparator<Cat>{

@Override
public int compare(Cat o1, Cat o2) {
    // 按年龄降序排序
    int age1=o1.getMonth();
    int age2=o2.getMonth();
    return age2-age1;
}

}

编程练习2

定义一个学生信息类，包括学号，姓名，年龄三个成员变量，然后按名字进行升序排序。(使用Comparator接口)

运行效果图：

任务

1、定义学生类Student，内容如下：

  • 三个成员变量：学号、姓名、年龄
  • 构造方法
  • getter和setter方法
  • 重写toString()方法

2、定义测试类StudentTest，完成如下功能：

  • 实现Comparator接口
  • 在主方法中定义Student类的对象，并添加到列表中，进行排序，输出排序前和排序后的内容
package me.feihong.list;

public class Student {
    private int stuId;//学号
    private int stuAge;//年龄
    private String name;//姓名

//构造方法
public Student(int stuId, int stuAge, String name) {
    super();
    this.stuId = stuId;
    this.stuAge = stuAge;
    this.name = name;
}

//getter setter方法
public int getStuId() {
    return stuId;
}

public void setStuId(int stuId) {
    this.stuId = stuId;
}

public int getStuAge() {
    return stuAge;
}

public void setStuAge(int stuAge) {
    this.stuAge = stuAge;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

//toString方法
@Override
public String toString() {
    return "[学号：" + stuId + ", 年龄：" + stuAge + ", 姓名：" + name + "]";
}

}
package me.feihong.list;

import java.util.Comparator;

public class NameComparator implements Comparator<Student>{

@Override
public int compare(Student o1, Student o2) {
    String name1=o1.getName();
    String name2=o2.getName();
    int n=name1.compareTo(name2);
    return n;
}

}
package me.feihong.list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class StudentTest {

public static void main(String[] args) {
    //定义Student类的对象
    Student stu1=new Student(40, 20, "peter");
    Student stu2=new Student(28, 5, "angel");
    Student stu3=new Student(35, 18, "tom");
    
    //将对象添加到List中
    List<Student> stuList=new ArrayList<Student>();
    stuList.add(stu1);
    stuList.add(stu2);
    stuList.add(stu3);
    
    //输出排序前的数据
    System.out.println("按名字排序前：");
    for(Student name:stuList) {
        System.out.println(name);
    }
    
    //排序
    Collections.sort(stuList, new NameComparator());
           
    //输出排序后的数据
    System.out.println("按名字排序后：");
    for(Student name:stuList) {
        System.out.println(name);
    }

}

}

Comparable概述

实现排序的另一个接口：Comparable接口
此接口强行对实现他的每个类的对象进行整体排序
这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法
对于集合，通过调用Collection.sort方法进行排序
对于数组，通过调用Arrays.sort方法进行排序
int compareTo(T o)方法：
该对象小于，等于或大于指定对象，则分别返回负整数，0，或正整数

案例：对商品价格进行降序排序

package com.imooc.sort;

public class Goods implements Comparable<Goods> {
    private String id;//商品编号
    private String name;//商品名称
    private double price;//商品价格
    //构造方法
    public Goods(String id,String name,double price){
        this.id=id;
        this.name=name;
        this.price=price;
    }

//getter和setter方法
public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public double getPrice() {
    return price;
}

public void setPrice(double price) {
    this.price = price;
}
public String toString(){
    return "商品编号："+id+",商品名称："+name+"，商品价格："+price;
}
@Override
public int compareTo(Goods o) {
    // 取出商品价格
    double price1=this.getPrice();
    double price2=o.getPrice();
    int n=new Double(price2-price1).intValue();
    return n;
}

}
package com.imooc.sort;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class GoodsTest {

public static void main(String[] args) {
    Goods g1 = new Goods("s00001", "手机", 2000);
    Goods g2 = new Goods("s00002", "冰箱", 5000);
    Goods g3 = new Goods("s00003", "电视机", 3000);
    List<Goods> goodsList = new ArrayList<Goods>();
    goodsList.add(g1);
    goodsList.add(g2);
    goodsList.add(g3);
    // 排序前
    System.out.println("排序前：");
    for (Goods goods : goodsList) {
        System.out.println(goods);
    }
    Collections.sort(goodsList);
    // 排序后
    System.out.println("排序后：");
    for (Goods goods : goodsList) {
        System.out.println(goods);
    }

}

}

编程练习3

定义一个员工信息类，包括编号，姓名，工资三个成员变量，要求工资定义为float类型，然后按工资进行降序排序。(使用Comparable接口)

运行效果图：

任务

1、定义员工信息类Employee，实现Comparable接口，内容如下：

  • 三个成员变量：编号、姓名、工资
  • 构造方法
  • getter和setter方法
  • 重写toString()方法

2、定义测试类EmployeeTest，完成如下功能：

  • 在主方法中定义3个Employee类的对象，并添加到列表中
package me.feihong.list;

public class Employee implements Comparable<Employee>{
    private String empId;// 员工编号
    private String name;// 姓名
    private double salary;// 工资

// 构造方法
public Employee(String empId, String name, double salary) {
    super();
    this.empId = empId;
    this.name = name;
    this.salary = salary;
}

// getter setter方法
public String getEmpId() {
    return empId;
}

public void setEmpId(String empId) {
    this.empId = empId;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public double getSalary() {
    return salary;
}

public void setSalary(double salary) {
    this.salary = salary;
}

@Override
public String toString() {
    return "员工 [编号：" + empId + ", 姓名：" + name + ", 工资：" + salary + "]";
}

@Override
public int compareTo(Employee o) {
    double salary1=this.getSalary();
    double salary2=o.getSalary();
    int n=new Double(salary2-salary1).intValue();
    return n;
}

}
package me.feihong.list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class EmployeeTest {

public static void main(String[] args) {
    //定义Employee类的对象
    Employee e1=new Employee("emp001", "张三", 1800);
    Employee e2=new Employee("emp002", "李四", 2500);
    Employee e3=new Employee("emp003", "王五", 1600);
    
    //将对象添加到List中
    List<Employee> empList=new ArrayList<Employee>();
    empList.add(e1);
    empList.add(e2);
    empList.add(e3);
    
    //输出排序前的数据
    System.out.println("排序前：");
    for(Employee emp:empList) {
        System.out.println(emp);
    }
    
    //排序
    Collections.sort(empList);
    
    //输出排序后的数据
    System.out.println("排序后：");
    for(Employee emp:empList) {
        System.out.println(emp);
    }

}

}

集合排序总结

comparator和comparable接口的区别

版权属于：Feihong

本文链接：https://www.feihong.me/archives/65.html

转载时须注明出处及本声明

最后修改：2019 年 12 月 31 日 11 : 44 PM
© 允许规范转载
如果觉得我的文章对你有用，请随意赞赏