集合和泛型

参考：JAVA开发从入门到精通
代码demo

一、Collection集合接口

List、Set、Map：表示接口
Collections：工具类，辅助几何处理的工具类
Arrays：用于数组处理的工具类

package com.test.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        // add()添加方法
        coll.add("aaa");
        coll.add("bbb");

        // size() 判断当前集合的元素个数
        int size = coll.size();
        System.out.println(size);  //输出结果为2

        //isEmpty() 判断该集合是否为空
        boolean empty = coll.isEmpty();
        System.out.println(empty); //输出结果为false

        // contains 判断该集合中是否包含该元素
        boolean contains = coll.contains("aaa");
        System.out.println(contains);  //输出结果为true
        boolean contains2 = coll.contains("ccc");
        System.out.println(contains2);  //输出结果为false

        //remove 移除元素
        boolean remove = coll.remove("aaa");
        System.out.println(remove); //输出结果为true
        boolean remove2 = coll.remove("ccc");
        System.out.println(remove2); //输出结果为false


        // toArray 把集合转成数组
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        Object[] objects = coll.toArray();
        /**
         * 输出结果为：
         * bbb
         * aaa
         * bbb
         * ccc
         */
        for(int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }

        // 把集合转换成Iterator迭代器对象，主要作用是便于我们进行遍历操作
        Iterator iterator = coll.iterator();


        System.out.println("-------------------");
        Collection coll2 = new ArrayList();
        coll2.add("aaa");
        // containsAll()：判断第一个集合中是否包含第二个集合中的所有元素
        boolean contains3 = coll.containsAll(coll2);
        System.out.println(contains3);  //输出结果为true
        //addAll()：将第二个集合中的所有元素加到第一个集合中
        System.out.println(coll.size());  //输出结果为4
        boolean isAll = coll.addAll(coll2);
        System.out.println(coll.size());  //输出结果为5
        Object[] objects2 = coll.toArray();
        /**
         * 输出结果为：
         * bbb
         * aaa
         * bbb
         * ccc
         * aaa
         */
        for(Object obj : objects2) {
            System.out.println(obj);
        }

        /**
         * 输出结果为：
         * bbb
         * aaa
         * bbb
         * ccc
         * aaa
         */
        for(int i = 0; i < objects2.length; i++) {
            System.out.println(objects2[i]);
        }


        coll.removeAll(coll2);  //从集合中移除指定集合包含的元素
        objects2 = coll.toArray();
        System.out.println("移除后的数据");
        /**
         * 输出结果为：
         * bbb
         * bbb
         * ccc
         */
        for(int i = 0; i < objects2.length; i++) {
            System.out.println(objects2[i]);
        }

        Collection coll3 = new ArrayList();
        coll3.add("bbb");
        coll.retainAll(coll3);  //保留集合中指定的元素
        objects2 = coll.toArray();
        /**
         * 输出结果为：
         * bbb
         * bbb
         */
        for(int i = 0; i < objects2.length; i++) {
            System.out.println(objects2[i]);
        }

        coll.clear();  //移除集合中所有的元素
        System.out.println(coll.size());   //输出结果为：0
    }
}

二、List和Set集合

package com.test.collection;

import java.util.ArrayList;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {

        List list = new ArrayList();
        // add(int index, E element):在列表的指定位置插入指定元素
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(1);
        list.add(0, "aaaa");
        System.out.println(list.size());
        Object[] objects = list.toArray();
        /**
         * 输出结果：
         * aaaa
         * 1
         * 2
         * 3
         * 1
         */
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        System.out.println("-----------");
        for(Object obj : objects) {
            System.out.println(obj);
        }

        // get()：返回列表中指定位置的元素
        Object o = list.get(0);
        System.out.println(o);  //输出结果为：aaaa

        //indexOf()：返回此列表中第一次出现的指定元素的索引
        int i = list.indexOf(1);
        System.out.println(i);  //输出结果为：1

        //lastIndexOf()：返回此列表中最后出现的指定元素的索引
        int i2 = list.lastIndexOf(1);
        System.out.println(i2);  //输出结果为：4

        //remove()：移除列表中指定位置的元素
        //boolean r = list.remove("aaaa");
        //System.out.println(r);  //输出结果为：aaaa
        Object remove = list.remove(0);
        System.out.println(remove);  //输出结果为：aaaa

        System.out.println("------------");


        //set()：用指定元素替换列表中指定位置的元素
        /**
         * 输出结果：
         * 1
         * 2
         * 3
         * 1
         */
        for(Object obj : list) {
            System.out.println(obj);
        }
        list.set(0, 4);
        System.out.println("------------");
        /**
         * 输出结果：
         * 4
         * 2
         * 3
         * 1
         */
        for(Object obj : list) {
            System.out.println(obj);
        }

        System.out.println("-----sublist-----");
        //sublist()：截取指定下标的集合列表,截取的元素是左闭右开，
        // 比如list.subList(1, 3)表示截取是第二个和第三元素，不包含下标为4的元素
        List list1 = list.subList(1, 3);
        /**
         * 输出结果：
         * 2
         * 3
         */
        for(Object obj : list1) {
            System.out.println(obj);
        }
    }
}

package com.test.collection;

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetDemo {
    public static void main(String[] args) {

        Set set = new HashSet();
        Set set2 = new TreeSet();

        set.add("111");
        set.add("333");
        set.add("222");
        //set不能添加重复元素
        set.add("222");

        /**
         * 遍历set元素
         * 输出结果：
         * 111
         * 222
         * 333
         */
        for (Object obj : set) {
            System.out.println(obj);
        }



    }
}

三、集合的变量方式

package com.test.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorDemo {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");

        // 通过迭代器对象进行遍历集合中的元素
        Iterator iterator = coll.iterator();
        /**
         * 输出结果为：
         * aaa
         * bbb
         * ccc
         */
        while(iterator.hasNext()) {  //hasNext(): 判断是否还有元素
            Object obj = iterator.next();  //next()：获取迭代器的下一个元素
            System.out.println(obj.toString());
        }

        // 通过将集合转换成对象数组进行遍历
        Object[] objects = coll.toArray();
        //通过for循环进行遍历
        for(int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }

        //通过for-each的方式进行遍历
        for(Object obj : coll) {
            System.out.println(obj);
        }
    }
}

四、Map集合

package com.test.collection;

import java.io.ObjectInputStream;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class MapDemo {
    public static void main(String[] args) {
        //map：键值对映射集合，实例化
        Map map = new HashMap();
        Map map2 = new TreeMap();

        //常用方法
        map.put("username", "zhangsan");
        map.put("password", "123456");

        int size = map.size();
        System.out.println(size);  //输出结果为：2

        //通过key来获取value值
        Object value = map.get("username");
        System.out.println(value);  //输出结果为：zhangsan
        Object value2 = map.get("password");
        System.out.println(value2);  //输出结果为：123456

        System.out.println(map.isEmpty()); //输出结果为：false

        Object username = map.remove("username");
        System.out.println("username: " + map.get("username"));  //输出结果为：username: null

        System.out.println(map.containsKey("username"));  //输出结果为：false
        System.out.println(map.containsKey("password"));  //输出结果为：true
        System.out.println(map.containsValue("123456"));  //输出结果为：true
        System.out.println(map.containsValue("12345"));   //输出结果为：false

        map.clear();
        System.out.println(map.size());  //输出结果为：0

        map2.put("aaa", "111");
        map2.put("bbb", "222");
        map.putAll(map2);   //putAll()：从指定映射中将所有映射关系复制到此映射中
        System.out.println(map.size());  //输出结果为：2

        // keySet():返回此映射中包含的键的Set视图
        Set keySet = map.keySet();
        /**
         * 输出结果为：
         * aaa
         * bbb
         */
        for(Object obj : keySet) {
            System.out.println(obj);
        }
        /**
         * 输出结果为：
         * aaa : 111
         * bbb : 222
         */
        for(Object obj : keySet) {
            System.out.println(obj  + " : " + map.get(obj));
        }

        //values()：返回此映射中包含的值的Collection视图
        Collection values = map.values();
        /**
         * 输出结果为：
         * 111
         * 222
         */
        for(Object o : values){
            System.out.println(o);
        }

        // entrySet()：返回此映射中包含的映射关系的Set视图
        Set entrySet = map.entrySet();
        /**
         * 输出结果为：
         * aaa=111
         * bbb=222
         */
        for(Object ob : entrySet) {
            System.out.println(ob);
        }

        /**
         * 输出结果为：
         * aaa : 111
         * bbb : 222
         */
        for(Object ob : entrySet) {
            Map.Entry entry = (Map.Entry) ob;
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}

五、Collections和Arrays集合工具类

package com.test.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("111");
        list.add("333");
        list.add("222");
        /**
         * 输出结果为：
         * 111
         * 333
         * 222
         */
        for(Object obj : list) {
            System.out.println(obj);
        }

        //sort():根据元素的自然顺序对指定列表按升序进行排序
        Collections.sort(list);
        /**
         * 输出结果为：
         * 111
         * 222
         * 333
         */
        for(Object obj : list) {
            System.out.println(obj);
        }

        //binarySearch()：使用二分搜索法搜索指定列表，以获取指定对象
        //特别注意：二分查找的前提，先对集合进行正序排序之后才能进行二分法查找
        int i = Collections.binarySearch(list, "333");
        System.out.println("i = " + i);  //输出结果：i = 2


        //reverse()：反转指定列表中元素的顺序
        Collections.reverse(list);
        /**
         * 输出结果为：
         333
         222
         111
         */
        for(Object obj : list) {
            System.out.println(obj);
        }



        //max()：根据元素的自然顺序，返回给定collection的最大元素
        Object max = Collections.max(list);
        System.out.println("max: " + max);  //输出结果：max: 333

        //min()：根据元素的自然顺序，返回给定collection的最小元素
        Object min = Collections.min(list);
        System.out.println("min: " + min);   //输出结果：min: 111

        //replaceAll()：使用另一个值替换列表中出现的所有某一指定值
        Collections.replaceAll(list,"333", "aaa");
        /**
         * 输出结果为：
         * aaa
         * 222
         * 111
         */
        for(Object obj : list) {
            System.out.println(obj);
        }
    }
}

package com.test.collection;

import java.io.ObjectInputStream;
import java.util.Arrays;
import java.util.List;

public class ArraysDemo {
    public static void main(String[] args) {
        //Arrays工具类用来操作数组（比如排序和搜索）的各种方法
        String[] strs = {"aaa", "bbb", "ddd", "ccc"};

        //asList()：返回一个受指定数组支持的固定大小的列表
        List asList = Arrays.asList(strs);
        Object object = asList.get(1);
        System.out.println(object);  //输出结果：bbb
        /**
         * 输出结果为
         * aaa
         * bbb
         * ddd
         * ccc
         */
        for(Object obj : asList) {
            System.out.println(obj);
        }

        //sort()：根据元素的自然顺序对指定对象数组按升序进行排序
        Arrays.sort(strs);
        /**
         * 输出结果为
         * aaa
         * bbb
         * ccc
         * ddd
         */
        for(Object obj : strs) {
            System.out.println(obj);
        }

        //binarySearch()：使用二分搜索法来搜索指定数组，以获取指定对象
        int index = Arrays.binarySearch(strs, "ccc");
        System.out.println("index = " + index);   //输出结果为：index = 2


        //toString()：返回指定数组内容的字符串表示形式
        String s = Arrays.toString(strs);
        System.out.println(s);  //输出结果为： [aaa, bbb, ccc, ddd]
    }
}

六、泛型

Box.java

package com.test.collection;

public class Box<T> {
    private T data;

    public Box(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

}

BoxDemo.java

package com.test.collection;

public class BoxDemo {
    public static void main(String[] args) {
        Box<String> box1 = new Box("aaa");
        Box<Integer> box2 = new Box(111);
        Box<Object> box3 = new Box(true);
        getName(box1);
        getName(box2);
        getName(box3);

    }

    private static void getName(Box<?> box1) {
        /**
         * 输出结果为：
         * aaa
         * 111
         * true
         */
        System.out.println(box1.getData());
    }
}