Java集合类之---（TreeSet排序分析，重复元素判断，集合输出）

TreeSet排序分析

• 要想进行排序实际上是针对于对象数组进行的排序处理，而如果要进行对象数组的排序，对象所在的类一定要实现Comparable接口并且覆写compareTo()方法，只有通过此方法才能知道大小关系
• 如果现在使用Comparable接口进行大小关系匹配，所有属性必须全部进行比较操作

重复元素判断

• 在使用TreeSet子类进行数据保存的时候，重复元素的判断依靠的ComParable接口完成的。
• 但是这并不是全部Set接口判断重复元素的方式，因为如果使用的是HashSet子类，由于其跟Comparable没有任何关系，所以它判断重复元素的方式依靠的是Object类中的两个方法：
• 1. hash码： public native int hashCode();
• 2. 对象比较：public boolean equals(Object obj);
• 在Java中进行对象比较的操作有两步：第一步要通过一个对象的唯一编码找到一个对象的信息，当编码匹配之后再调用equals()方法进行内容的比较。

class People implements Comparable<People>{
    private String name;
    private Integer age;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        People people = (People) o;
        return Objects.equals(name, people.name) &&
                Objects.equals(age, people.age);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    @Override
    public int compareTo(People o) {
        if(this.age > o.age){
            return 1;
        }else if(this.age < o.age){
            return -1;
        }else {
            return this.name.compareTo(o.name);
        }
    }
    public People(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}
public class Collect {
    public static void main(String[] args) {
        Set<People> set = new HashSet<>();
        set.add(new People("zhangsan",20));
        set.add(new People("lisi",21));
        set.add(new People("wangwu",18));
        set.add(new People("zhangsan",20));
        System.out.println(set);
    }
}

• 对象判断必须两个方法equals()、hashCode()返回值都相同才判断为相同。
• 1. 保存自定义对象的时候使用List接口；
• 2. 保存系统类信息的时候使用Set接口(避免重复)。

集合输出

• 集合输出一共有四种手段：Iterator、ListIterator、Enumeration、foreach。

迭代输出：Iterator

• 三个抽象方法
• 判断是否有下一个元素：public boolean hasNext()
• 取得当前元素：public E next()
• 删除元素：public default void remove()

List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("hello");
        //实例化Iterator对象
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            String str = iterator.next();
            //System.out.println(str);
            if(str.equals("hello")){
                iterator.remove();
                continue;
            }
            System.out.println(str);

• 使用集合提供的remove()方法list.remove("hello")，会产生生ConcurrentModificationException；
• 使用Iterator的remove方法则不会产生异常
• 在进行集合输出的时候不要修改集合中元素

双向迭代接口：ListIterator

• 只能够由前向后进行内容的迭代处理，而如果要想进行双向迭代，那么就必须依靠Iterator的子接口：ListIterator来实现
• 1.判断是否有上一个元素：public boolean hasPrevious()
• 2.取得上一个元素：public E previous()
• ListIterator是由List接口支持的：取得ListIterator接口对象：public ListIterator listIterator()
• 如果要想实现由后向前的输出，那么应该首先进行从前向后的输出，否则无法实现双向

public class Collect {
    public static void main(String[] args) {
     List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("hello");
        list.add("B");
        //实例化Iterator对象
        ListIterator<String> listIterator = list.listIterator();
        System.out.println("从前向后输出：");
        while (listIterator.hasNext()){
            System.out.println(listIterator.next()+",");

        }
        System.out.println("\n从后向前输出：");
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous()+",");
        }
    }
}

枚举输出： Enumeration

• 接口定义：
• 1.判断是否有下一个元素：public boolean hasMoreElements()
• 2.取得元素：public E nextElement()
• 取得这个接口的实例化对象，只能够依靠Vector子类：取得Enumeration接口对象：:public Enumeration elements()
• 使用Enumeration输出

 Vector<String> vector = new Vector<>() ;
        vector.add("Hello") ;
        vector.add("Hello") ;
        vector.add("B") ;
        vector.add("Bit") ;
        Enumeration<String> enumeration = vector.elements() ;
        while (enumeration.hasMoreElements()) {
            System.out.println(enumeration.nextElement()) ;
        }

foreach输出

public static void main(String[] args) {
List<String> list = new ArrayList<>() ;
list.add("Hello") ;
list.add("Hello") ;
list.add("B") ;
list.add("Bit") ;
for (String str : list) {
System.out.println(str) ;
}
}