铂西学习日记---Set 和 Iterator

简单介绍，源码自己点开看

import java.util.*;

public class SetDemo {
    /**
     * Set接口
     * 1.无序的（不保证顺序）
     * 2.不允许重复元素
     *
     * HashSet、TreeSet、LinkedHashSet 如何选择？
     * 需要排序就选择：TreeSet
     * 不要排序，也不要插入的顺序就选择：HashSet
     * 不要排序，要保证顺序就选择：LinkedHashSet
     */
    public static void main(String[] args) {
//        hashSet();
//        treeSet();
        linkedHashSet();
    }

    /**
     * HashSet
     * 1.实现原理：基于HashMap实现（哈希表）
     * 2.不允许重复，可以有一个NULL元素
     * 3.不保证顺序恒久不变
     * 4.添加数据时把元素作为HashMap的Key存储，HashMap的Value使用一个固定的Object对象来去补充
     * 5.排除重复元素是通过equals来检查对象是否相同
     * 6.判断两个对象是否相同，是先判断两个对象的hashcode，再判断equals，hashcode相同对象不一定相同
     * 7.自定义对象一般需要重写equals、hashcode方法
     *
     * 8.hash表的原理是数组加链表，数组里的每个元素以链表的形式存储
     * 9.如何把对象存储到哈希表中，先计算对象的hashCode值，再对数组的长度求余数，来决定对象要存储在数组中的哪个位置

     * 更多操作方法看API接口
     */
    public static void hashSet(){
        Set<String> set = new HashSet<>();
        set.add("刘");
        set.add("关");
        set.add("张");
        set.add("曹");
        set.add("马");
        String[] sets = set.toArray(new String[]{});
        for (String s : sets) {
            System.out.println(s);
        }
    }

    /**
     * LinkedHashSet
     * 就是HashSet 又 维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，即按照将元素插入到set中的顺序(插入顺序)进行迭代。

     * 更多操作方法看API接口
     */
    public static void linkedHashSet(){
        LinkedHashSet<Cat> set = new LinkedHashSet<>();
        Cat c1 = new Cat("lsq",21);
        Cat c2 = new Cat("lbx",16);
        Cat c3 = new Cat("lsx",22);
        Cat c4 = new Cat("lsx",22);
        set.add(c1);
        set.add(c2);
        set.add(c3);
        set.add(c4);
        for (Cat cat : set) {
            System.out.println(cat);
        }
    }

    /**
     * TreeSet
     * 更多方法看API接口
     * 它是有序的需要比较器否则会报错--- *** cannot be cast to java.lang.Comparable
     * 基于TreeMap(二叉树数据结构)
     * 对象比较器可以去除重复的元素，如果自定义的数据类，没有实现比较器接口将无法添加到TreeMap集合中
     */
    public static void treeSet(){
        TreeSet<Cat> set = new TreeSet<>(new CatComparator());
        Cat c1 = new Cat("lsq",21);
        Cat c2 = new Cat("lbx",16);
        Cat c3 = new Cat("lsx",22);
        Cat c4 = new Cat("lsx",22);

        set.add(c1);
        set.add(c2);
        set.add(c3);
        set.add(c4);
        System.out.println(set.size());
    }
}

class Cat{
    private String name;
    private int age;

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

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

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

    @Override
    public int hashCode() {
        return Objects.hash(name, 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;
    }
}

class CatComparator implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        //按照年龄来排序
        return o1.getAge()-o2.getAge();
    }
}

Iterator

import java.util.*;

public class IteratorDemo {
    /**
     * 集合的迭代 --- Iterator
     * 通用的迭代方法可以有效的避免不同的集合类有不同迭代方法的困扰
     *
     * @param args
     */

    public static void main(String[] args) {

    }

    //foreach(JDK1.5后)
    public static void iterator1(Collection<Cat> c) {
        for (Cat cat : c) {
            System.out.println(cat);
        }
    }

    //新foreach(JDK1.8后)
    public static void iterator3(Collection<Cat> c) {
        /**
         * default void forEach(Consumer<? super T> action) {
         *         Objects.requireNonNull(action);
         *         for (T t : this) {
         *             action.accept(t);
         *         }
         *     }
         */
        //配合Lambda表达式，代码更优雅、简洁
        c.forEach(cat-> System.out.println(cat));
        //双冒号表示调用方法
//        c.forEach(System.out::println);
    }

    //iterator(JDK1.5之前统一的迭代集合的方式)
    public static void iterator2(Collection<Cat> c) {
        Iterator<Cat> iter = c.iterator();
        while (iter.hasNext()) {
            System.out.println(iter.next());
        }
    }

    //和vector搭配使用的枚举遍历器
    private static void enumeration() {
        Vector<String> vs = new Vector<>();
        vs.add("tom");
        vs.add("jack");
        vs.add("job");
        vs.add("lily");
        Enumeration<String> es = vs.elements();

        while (es.hasMoreElements()) {
            System.out.println(es.nextElement());
        }
    }
    /**
     * ListIterator 针对list的迭代器
     *         ArrayList<Object> objects = new ArrayList<>();
     *         ListIterator<Object> objectListIterator = objects.listIterator();
     */
}