Collection集合（List,Set）

public class CollectionDemo {
    public static void main(String[] args) {
//        ArrayList
//        arr();
//        去重
//        arr2();
//        LinkedList
//        linked();
//        Vector
//        vec();
//        Set集合
        SetDemo sd = new SetDemo();
//        sd.hashSetFun();
//        sd.treeSetFun();
//        sd.stu();
//        sd.per();

//        short s1 = 1;
//        s1 += 1;
//        System.out.println(getType(s1));
//        System.out.println(Math.round(11.5));
//        System.out.println(Math.round(-11.5));
    }

    private static String getType(Object ss) {
        if (ss instanceof Short) {
            return "Short类型";
        }
        return "其他类型";
    }

    private static void arr() {
//        ArrayList 的底层是用数组来保存元素，所以新增和删除指定位置元素时，会导致创建新的数组，所以效率比较低
//        不适合大量的增删操作，但是查询比较方便
        ArrayList<Character> arr1 = new ArrayList<Character>();//线程不安全，Vector线程安全与ArrayList用法相同
        ArrayList arr2 = new ArrayList();
        arr1.add('a');
        arr1.add('b');
        arr1.add('c');
        arr1.add('d');//不允许null
        arr2.addAll(arr1);//把arr1集合添加到arr2集合中
        arr2.set(1, 'e');//替换指定位置的元素
        if (arr1.isEmpty()) {
            System.out.println("arr1集合是空");
        } else {
            System.out.println("arr1的长度是：" + arr1.size());
        }
        if (arr1.containsAll(arr2)) {
            System.out.println("arr1中包含arr2");
        } else {
            System.out.println("arr1中不包含arr2");
        }
        arr1.remove(arr1.get(3));
        arr1.remove(2);
        System.out.println("arr1的长度：" + arr1.size());
        arr1.clear();
        System.out.println("arr1的长度：" + arr1.size());
        if (arr2.contains('a')) {
            System.out.println(arr2.indexOf('a'));
        } else {
            System.out.println("arr2中没有'a'元素");
        }
        System.out.println(arr2.get(1));
        arr2.add(1, 'E');//在指定位置添加元素
        System.out.println(arr2.get(1) + "\narr2的长度：" + arr2.size());
    }

    private static void arr2() {
        ArrayList arr1 = new ArrayList();
        ArrayList arr2 = new ArrayList();
        arr1.add("a");
        arr1.add("b");
        arr1.add("c");
        arr1.add("d");
        arr2.addAll(arr1);
        arr2.set(3, "D");
        System.out.println(arr2.size());
//        迭代
        Iterator it = arr1.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            System.out.println(next);
            if (arr2.contains(next)) {
                arr2.remove(next);
            }
//            删除arr1中的a元素
            if ("a".equals(next)) {
//                arr1.remove(next);//会抛出异常java.util.ConcurrentModificationException
//                解决方式
//                1
//                break;//结束循环
//                2
//                it.remove();
            }
        }

//            逆向迭代（只能用于list集合）
        ListIterator lit = arr1.listIterator(arr1.size());//arr1.size()指定的迭代起始位置
        while (lit.hasPrevious()) {
            Object previous = lit.previous();
            System.out.println(previous);
        }

        System.out.println(arr2.size());
        arr1.addAll(arr2);
        System.out.println(arr1.toString());
//        foreach循环，不能对集合中的元素进行修改
        for (Object arr : arr1) {
            arr = "X";//临时变量，指向一个新的字符串
            System.out.println(arr);
        }
        System.out.println(arr1.toString());
    }

    private static void linked() {
//        LinkedList集合，是双向链表结构，每一个元素都采用引用的方式来记住它的前一个元素和后一个元素
//        当插入和删除元素时只需要改变这种引用就可以了
        LinkedList link = new LinkedList();
        link.add('q');
        link.add('w');
        link.add('e');
        link.add('r');
        System.out.println(link.toString());
        link.add(2, 'A');
        System.out.println(link.toString());
        link.remove(2);
        System.out.println(link.toString());
        link.addFirst('Q');
        System.out.println(link.toString());
        link.removeFirst();
        System.out.println(link.toString());
        link.addLast('Z');
        System.out.println(link.toString());
        link.removeLast();
        System.out.println(link.toString());
    }

    private static void vec() {
        Vector vec = new Vector();
        vec.add("a");
        vec.add("s");
        vec.add("d");
        Enumeration elements = vec.elements();
        while (elements.hasMoreElements()) {
            Object o = elements.nextElement();
            System.out.println(o);
        }
    }
}

 

public class SetDemo {
    //    HashSet存储的元素不可重复，并且无序
//    当存储一个对象时，会调用hashCode(),确定存储的位置若该位置没有元素直接存入，
// 有元素调用equal()来确定该位置有没有重复元素，返回false直接存入，否则舍弃

    protected static void hashSetFun() {
        HashSet hs = new HashSet();
        hs.add("Q");
        hs.add("W");
        hs.add("E");
        hs.add("Q");
        hs.add(null);//允许为null
        Iterator it = hs.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            System.out.println(next);
        }
    }

    //    TreeSet采用自平衡的排序二叉树的结构来存储元素的，左树小于右树
//  当向treeSet中存入元素时，会与其他元素进行比较，最后插入到有序的队列中
//    调用compareTo()方法进行比较,该方法在comparable接口中定义，因此要实现comparable接口
//    如果没有实现comparable接口，就不知道根据什么规则进行排序，程序就会报错
    protected static void treeSetFun() {
        TreeSet tree = new TreeSet();
        tree.add(12);
        tree.add(13);
        tree.add(19);
        tree.add(7);
        tree.add(14);
        tree.add(7);
//        tree.add(null);不允许为null
        Iterator it = tree.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

    }

    public static void stu() {
        HashSet hash = new HashSet();
        Student s1 = new Student("1", "A");
        Student s2 = new Student("2", "C");
        Student s3 = new Student("2", "D");//id相同会被舍弃
        hash.add(s1);
        hash.add(s2);
        hash.add(s3);
        System.out.println(hash);

    }

    public static void per() {
        TreeSet tree = new TreeSet();
        tree.add(new Person("A", 10));
        tree.add(new Person("B", 8));
        tree.add(new Person("C", 13));
        tree.add(new Person("D", 8));
        tree.add(new Person("C", 13));
        Iterator it = tree.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

    }
}

class Person implements Comparable {
    private String name;
    private int age;

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

    public String toString() {
        return name + ":" + age;
    }

    @Override
    public int compareTo(Object o) {//重写compareTo()方法
        Person p = (Person) o;
        if (this.age - p.age > 0) {//比较规则---先以年龄排序
            return 1;
        } else if (this.age - p.age == 0) {//age相同时，已name排序
            return this.name.compareTo(p.name);
        }
        return -1;
    }
}

class Student {
    String id;
    String name;

    public Student(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String toString() {
        return id + ":" + name;
    }

    //    重写hashCode()
    public int hashCode() {
        return id.hashCode();//返回id属性的哈希值
    }

    //    重写equals方法
    public boolean equals(Object obj) {
        if (this == obj) {//this指当前对象，obj已存在的要比较的对象
            return true;
        }
        if (!(obj instanceof Student)) {//判断是否是Student类型，不是返回false
            return false;
        }
        Student student = (Student) obj;//把对象强制转换成Student类型
        boolean e = this.id.equals(student.id);//判断id是否相同
//        boolean e = this.name.equals(student.name);//判断name是否相同
        return e;
    }
}