Iterator 接口、重写 hashCode()和equals()原则、Comparable和Comparator比较器

继上一篇文章https://blog.csdn.net/weixin_44514198/article/details/105482625整理了collection接口的一些内容，下面介绍上一篇文章没有介绍到的一些问题

1. 使用 Iterator 接口遍历集合元素

Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了 Iterator接口的对象。
Iterator仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象，则必须有一个被迭代的集合。
集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常

//hasNext():判断是否还有下一个元素 
while(iterator.hasNext()){
 //next():①指针下移②将下移以后集合位置上的元素返回 
 System.out.println(iterator.next());
  }

Iterator接口remove()方法

Iterator iter = coll.iterator();//回到起点 
while(iter.hasNext()){
 Object obj = iter.next(); 
 if(obj.equals("Tom")){
  iter.remove(); 
  }
   }

Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，
再调用remove都会报IllegalStateException

2. 重写 hashCode() 方法的基本原则

在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。当两个对象的 equals() 方法比较返回
true 时，这两个对象的 hashCode() 方法的返回值也应相等。对象中用作 equals() 方法比较的
Field，都应该用来计算 hashCode 值。

3. 重写 equals() 方法的基本原则

当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是
要改写hashCode()，根据一个类的equals方法（改写后），两个截然不
同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。
因此，违反了“相等的对象必须具有相等的散列码”
结论：重写equals方法的时候一般都需要同时重写hashCode方法。通
常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。

4. java.lang.Comparable和java.util.Comparator比较器

在java中指定排序规则的方式只有两种：（java.lang.Comparable和java.util.Comparator）。为对集合中的元素按照一定的规则进行排序。

a) java.lang.Comparable接口

也称为内部比较器，存入TreeSet中的类实例必须实现java.lang.Comparable接口。这样在集合中的对象就可自动排序。Arrays.sort(Object[] a) 数组中的所有元素都必须实现 Comparable 接口。
Order:

import java.util.Date;

public class Order implements Comparable<Order>{
    private String orderNo;
    private int amout;
    private double totalPrice;
    private Date orderDate;

    public Order(){}

    /**
     *
     * @param orderNo 订单编号
     * @param amout 订单数量
     * @param totalPrice 订单总价
     * @param orderDate 订单日期
     */
    public Order(String orderNo, int amout, double totalPrice, Date orderDate) {
        this.orderNo = orderNo;
        this.amout = amout;
        this.totalPrice = totalPrice;
        this.orderDate = orderDate;
    }

    public String getOrderNo() {
        return orderNo;
    }

    public void setOrderNo(String orderNo) {
        this.orderNo = orderNo;
    }

    public int getAmout() {
        return amout;
    }

    public void setAmout(int amout) {
        this.amout = amout;
    }

    public double getTotalPrice() {
        return totalPrice;
    }

    public void setTotalPrice(double totalPrice) {
        this.totalPrice = totalPrice;
    }

    public Date getOrderDate() {
        return orderDate;
    }

    public void setOrderDate(Date orderDate) {
        this.orderDate = orderDate;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderNo='" + orderNo + '\'' +
                ", amout=" + amout +
                ", totalPrice=" + totalPrice +
                ", orderDate=" + orderDate +
                '}';
    }

    /**
     * 当前对象与指定对象进行比较
     * @param o
     * @return
     */
//    @Override
//    public int compareTo(Object o) {
//        return 0;
//    }

    //使用compare接口的时候声明泛型就能将object变成order

    /**
     * int compareTo(T o)
     * 参数：
     * o - 要比较的对象。
     * 返回：
     * 负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。
     * 抛出：
     * ClassCastException - 如果指定对象的类型不允许它与此对象进行比较。
     * 当前对象与指定对象进行比较，自然排序方法由排序方法体内部决定
     * @param o
     * @return 负数（当前对象小于o） 0 （当前对象等于o）正数（当前对象大于o）
     */
    @Override
    public int compareTo(Order o) {
        //按照订单的数量进行比较排序
        if (this.amout > o.amout) {
            return 1;
        } else if(this.amout < o.amout){
            return -1;
        }else {
            return 0;
        }
    }
}

主类TreeSetDemo

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args)throws ParseException {
        //泛型，set只能存order实例
        TreeSet<Order> set = new TreeSet<>();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        set.add(new Order("0T300",300,300.0,sdf.parse("2020-01-13 12:21:20")));
        set.add(new Order("0T100",100,100.0,new Date()));
        set.add(new Order("0T500",500,500.0,sdf.parse("2020-01-15 12:21:20")));
        set.add(new Order("0T200",200,200.0,sdf.parse("2020-01-12 12:21:20")));
        set.add(new Order("0T400",400,400.0,sdf.parse("2020-01-14 12:21:20")));

        for (Order order : set) {
            System.out.println(order);
        }

    }
}

b) java.util.Comparator接口

也称为外部比较器，可以对存入Collection、List、Set集合中的对象进行整体排序，可以使Collections.sort(List, Comparator)或者Arrays.sort(数组，Comparator)方法完成排序。
例子1：
OrderVO

import java.util.Date;

public class OrderVO{
    private String orderNo;
    private int amout;
    private double totalPrice;
    private Date orderDate;

    public OrderVO(){}

    /**
     *
     * @param orderNo 订单编号
     * @param amout 订单数量
     * @param totalPrice 订单总价
     * @param orderDate 订单日期
     */
    public OrderVO(String orderNo, int amout, double totalPrice, Date orderDate) {
        this.orderNo = orderNo;
        this.amout = amout;
        this.totalPrice = totalPrice;
        this.orderDate = orderDate;
    }

    public String getOrderNo() {
        return orderNo;
    }

    public void setOrderNo(String orderNo) {
        this.orderNo = orderNo;
    }

    public int getAmout() {
        return amout;
    }

    public void setAmout(int amout) {
        this.amout = amout;
    }

    public double getTotalPrice() {
        return totalPrice;
    }

    public void setTotalPrice(double totalPrice) {
        this.totalPrice = totalPrice;
    }

    public Date getOrderDate() {
        return orderDate;
    }

    public void setOrderDate(Date orderDate) {
        this.orderDate = orderDate;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderNo='" + orderNo + '\'' +
                ", amout=" + amout +
                ", totalPrice=" + totalPrice +
                ", orderDate=" + orderDate +
                '}';
    }

}

TreeSetDemo2

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Comparator;
import java.util.Date;
import java.util.TreeSet;

public class TreeSetDemo2 {
    public static void main(String[] args) throws ParseException {
        Comparator<OrderVO> dateCompatator = new Comparator<OrderVO>() {
            @Override
            public int compare(OrderVO o1, OrderVO o2) {
                return o1.getOrderDate().compareTo(o2.getOrderDate());
            }

            @Override
            public boolean equals(Object obj) {
                return false;
            }
        };

        TreeSet<OrderVO> set = new TreeSet<>(dateCompatator);
        //泛型，set只能存order实例
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        set.add(new OrderVO("0T300",300,300.0,sdf.parse("2020-01-13 12:21:20")));
        set.add(new OrderVO("0T100",100,100.0,new Date()));
        set.add(new OrderVO("0T500",500,500.0,sdf.parse("2020-01-15 12:21:20")));
        set.add(new OrderVO("0T200",200,200.0,sdf.parse("2020-01-12 12:21:20")));
        set.add(new OrderVO("0T400",400,400.0,sdf.parse("2020-01-14 12:21:20")));

        for (OrderVO order : set) {
            System.out.println(order);
        }
    }
}

例子2：list集合需要使用collection.sort()方法
主程序：

import java.util.*;

/**
 * 8.	将写一个程序将List集合中的员工对象(Employee)按薪水的高低进行排序。
 * 1)	提示：使用java.util.Camparator实现排序。
 */
public class EmployeeTest {
    public static void main(String[] args) {

        Comparator<Employee> comparator = new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                return o1.getSalary().compareTo(o2.getSalary());
            }

        };
//        Comparator<Employee> comparator = (o1,o2) -> o1.getSalary().compareTo(o2.getSalary()); 简化

       List<Employee> employees = new ArrayList();

        employees.add(new Employee("jack",123456,8900.0));
        employees.add(new Employee("Alice",123457,9900.0));
        employees.add(new Employee("jane",123458,5900.0));
        employees.add(new Employee("via",123459,7900.0));

        System.out.println("------------排序前的员工信息------------");
        for (Employee employee : employees) {
            System.out.println(employee);
        }


       Collections.sort(employees,comparator);
        System.out.println("------------排序后的员工信息------------");
        for (Employee employee : employees) {
            System.out.println(employee);
        }

    }


}

Employee：

public class Employee {
    private String name;
    private Integer no;
    private Double salary;

    public Employee() {
    }

    public Employee(String name, Integer no, Double salary) {
        this.name = name;
        this.no = no;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public Integer getNo() {
        return no;
    }

    public void setNo(Integer no) {
        this.no = no;
    }

    public Double getSalary() {
        return salary;
    }

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

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", no=" + no +
                ", salary=" + salary +
                '}';
    }
}

c)比较两个对象是否相等方式

i. 通过重写o.equals(other)方法实现
ii. 通过比较器接口实现

海风_C

发布了28 篇原创文章 · 获赞 2 · 访问量 1474

私信关注