Java-容器

一.遍历容器
方法一

        Collection books = new HashSet();
        books.add("1");
        books.add("2");
        books.add("3");
        Iterator it = books.iterator();    //建立迭代器
        while(it.hasNext()){    //如果容器中元素还没遍历完，则返回true
            String book = (String) it.next();    //next()返回类型时Obj
            System.out.println(book);
        }

方法二

        Collection books = new HashSet();
        books.add("1");
        books.add("2");
        books.add("3");
        Iterator it = books.iterator();    //建立迭代器
        it.forEachRemaining(obj -> System.out.println("迭代元素为："+obj));

方法三

        Collection books = new HashSet();
        books.add("1");
        books.add("2");
        books.add("3");
        for(Object obj:books){
            String book = (String)obj;
            System.out.println(book);
        }

二.批量删除容器中的元素

        Collection books = new HashSet();
        books.add("100");
        books.add("2");
        books.add("300");
        books.removeIf(ele -> ((String)ele).length()<2);
        System.out.println(books);

三.Set
1.HashSet(常用)
添加元素时，判断对象的值和hashcode是否相等，两者都一样才能添加失败。
访问元素时通过hash快速访问的，如果有两个一样的hashcode，则会降低性能。
一般情况下，尽量保证同一对象，hashcode相等(毕竟是set)。
2.TreeSet(采用红黑树的数据结构存储)
最大特点：元素有序，添加对象为同一类对象
集合内元素必须实现Comparable接口（重写eauals()方法和compareTo()方法，一般要求这两个方法判断方法一致，讲义308页）
比HashSet多了几个操作

        TreeSet n = new TreeSet();
        n.add(5);
        n.add(2);
        n.add(-9);
        n.add(10);
        System.out.println(n.first());   //第一个元素
        System.out.println(n.last());    //最后一个元素
        System.out.println(n.headSet(4));     //比4大的
        System.out.println(n.tailSet(5));   //比5小的
        System.out.println(n.subSet(-3,4));   //大小在3-4之间的

排序方法有两种：
1.自然排序(从小到大)
2.自定义排序

            TreeSet n = new TreeSet((o1,o2) ->{
            M m1=(M)o1;      //M为要排序的类的统一对象
            M m2=(M)o2;
            return m1.age> m2.age?-1:m1.age<m2.age?1:0;
        });

自然排序实现的是comparable接口。其在类可以修改时使用。
定制排序实现的是comparator接口。其在类不可以修改时使用
参考：https://www.cnblogs.com/kelly-one/p/8324775.html
自然排序和定制排序结构基本一样，只是使用的方法不太一样。
四.List(有序，可重复)
基本的容器方法都有，以下是新增方法：

        List books = new ArrayList();
        books.add("wjh"); 
        books.add("love");
        books.add("gtt");
        System.out.println(books);
        books.add(1,"really");   //将元素添加到index的位置上
        for(Object s:books){
            String s1 = (String)s;
            System.out.println(s1);
        }
        books.remove(2);    //删除index的元素
        System.out.println(books);
        books.get(2);   //获得index处的元素
        System.out.println(books.indexOf("gtt"));     //返回该元素的索引
        books.set(0,"wwjh");   //替换
        System.out.println(books);
        System.out.println(books.subList(1,2));     //截取1-2位置上的元素

ArrayList和Vector都是List的子类，尽量少使用Vector(缺点多)。
五.Queue
1.ArrayDeque(栈)

        ArrayDeque stack = new ArrayDeque();
        stack.push("wjh");   //将一个元素压入栈顶（第一个位置，不是next）
        stack.push("love");
        stack.push("gtt");
        System.out.println(stack);
        System.out.println(stack.peek());   //访问第一个元素，但是不删除
        System.out.println(stack);
        System.out.println(stack.pop());    //访问且删除第一个元素（栈顶）
        System.out.println(stack);

2.ArrayDeque(队列)

        ArrayDeque queue = new ArrayDeque();
        queue.offer("wjh");    //添加元素
        queue.offer("love");
        queue.offer("gtt");
        System.out.println(queue);
        System.out.println(queue.peek());   //获取队头元素，但是不删除
        System.out.println(queue);
        System.out.println(queue.poll());   //获取队头元素，但是删除
        System.out.println(queue);

3.LinkedList
疯狂Java30页
跟Arraylist和ArrayDeque差不多，实现机制不太一样
六.Map

        Map map = new HashMap();
        map.put("wjh","gtt");
        map.put("love","love");
        map.put("gtt","wjh");
        System.out.println(map);
        System.out.println(map.put("wjh","ggtt"));  //覆盖的话，会返回原来的value
        System.out.println(map);
        System.out.println("map是否包含"+map.containsKey("wjh"));   //是否包含key
        System.out.println("map是否包含"+map.containsValue("wjh"));  //是否包含value
        for(Object obj:map.keySet()){   //返回所有key组成set集合
            System.out.println(obj+"-->"+map.get(obj));    //得到key————》对应的value
        }
        map.replace("wjh","gtt");   //修改
        map.remove("love");    //删除
        System.out.println(map);

2.TreeMap

class R implements Comparable{
    int count;
    R(int count){
        this.count=count;
    }
    public String toString(){
        return "P[count:"+count+"]";
    }
    public boolean equals(Object obj){
        if(this==obj){
            return true;
        }
        if(obj!=null&&obj.getClass()==R.class){   //判断两个比较对象是不是同一个类的
            R r= (R)obj;
            return r.count==this.count;
        }
        return false;
    }
    @Override
    public int compareTo(Object obj) {
        R r = (R)obj;
        return count>r.count?1:
                count<r.count?-1:0;
    }
}

public class Test {
    public static void main(String[] args){
        TreeMap tm = new TreeMap();
        tm.put(new R(3),"wjh");
        tm.put(new R(-5),"love");
        tm.put(new R(9),"gtt");
        System.out.println(tm);
        System.out.println(tm.firstEntry());   //获得最key-value（最大（排序发生变化时））
        System.out.println(tm.lastKey());   //获得最小key
        System.out.println(tm.higherKey(new R(2)));   //获得比2大的
        System.out.println(tm.lowerEntry(new R(2)));   //获得比2小的
        System.out.println(tm.subMap(new R(-1),new R(4)));    //获得-1---4之间的，如果顺序从大到小，则写成4，-1
        Object a =  tm.keySet().toArray();
        System.out.println(Arrays.binarySearch((Object[]) a,new R(9)));     //搜寻对象位置
    }
}

七.Collections

        ArrayList nums = new ArrayList();
        nums.add(2);
        nums.add(-5);
        nums.add(3);
        nums.add(0);
        System.out.println(nums);
        Collections.reverse(nums);   //次序反转
        System.out.println(nums);  
        Collections.sort(nums);     //排序
        System.out.println(nums);
        Collections.shuffle(nums);   //随机排序
        System.out.println(nums);
        System.out.println(Collections.max(nums));   //最大
        System.out.println(Collections.min(nums));   //最小
        Collections.replaceAll(nums,0,1);  //替换
        System.out.println(nums);
        System.out.println(Collections.frequency(nums,-5));   //元素出现次数
        Collections.sort(nums);   //排序
        System.out.println(Collections.binarySearch(nums,3));   //二分法查找