集合常用类及方法汇总

 List 、Set和Map接口中常用类以及方法整理：主要包括对集合中的对象进行增删改和遍历操作

Collection接口

        /**
         * 以下演示对Collection的操作方法
         */
        Collection<String > c = new ArrayList<>();
        //向集合中增加指定对象
        c.add("hello");
        c.add("world");
        c.add("I'm coming!");
        System.out.println("初始Collection集合：" + c);

        //移除集合中的某对象
        c.remove("world");
        System.out.println("删除world对象后的集合：" + c);

        //判断集合中是否包含某对象
        boolean world = c.contains("world");
        System.out.println("是否仍包含world对象："+ world);

        //计算集合中对象的个数
        int size = c.size();
        System.out.println("集合的大小：" + size);

        //toArray()方法将集合转换为Object数组
        System.out.print("集合转换为Object数组，数组中的元素为：");
        Object[] obj = c.toArray();
        for (int i=0; i<obj.length; i++) {
            System.out.print(obj[i] + ",");
        }
        System.out.println();

        //toArray(T[] a)方法将集合转换为相应类型的数组
        System.out.print("集合转换为String数组，数组中的元素为：");
        String[] str = c.toArray(new String[2]);
        for (int j=0; j<str.length; j++) {
            System.out.print(str[j] + ",");
        }
        System.out.println();

        //iterator()方法遍历集合中的对象
        Iterator<String> item = c.iterator();
        System.out.print("依次遍历集合中的对象：");
        while (item.hasNext()) {
            String strItem = item.next();
            System.out.print(strItem + "  ");
        }
        System.out.println();

        //清除集合中的对象
        c.clear();
        System.out.println("移除所有对象后的集合：" + c);

运行结果：

初始Collection集合：[hello, world, I'm coming!]
删除world对象后的集合：[hello, I'm coming!]
是否仍包含world对象：false
集合的大小：2
集合转换为Object数组，数组中的元素为：hello,I'm coming!,
集合转换为String数组，数组中的元素为：hello,I'm coming!,
依次遍历集合中的对象：hello  I'm coming!  
移除所有对象后的集合：[]

List接口：

        /**
         * 以下演示对List的操作方法
         */
        List<Integer> list = new ArrayList<>();
        //随机生成10个数，并放到list中
        for (int i=0; i<10; i++) {
            Random random = new Random();
            int j = random.nextInt(100); //0-100之前随机生成一个数
            list.add(j);
        }
        System.out.println("初始list集合：" + list);

        //获取第二个位置上的对象
        System.out.println("第二个位置上的对象为：" + list.get(1));

        //删除第二个位置上的对象
        list.remove(1);
        System.out.println("删除第二个位置对象后的集合：" + list);

        //修改第二个位置上的对象
        list.set(1,999999);
        System.out.println("修改第二个位置对象后的集合：" + list);

        //for循环遍历得到list集合中每个对象
        System.out.print("for循环依次遍历list集合中的对象：");
        for (int i=0; i<list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();

        //foreach循环遍历得到list集合中每个对象
        System.out.print("foreach循环依次遍历list集合中的对象：");
        for (int i:list) {
            System.out.print(i + " ");
        }
        System.out.println();

        //也可以通过iterator()方法遍历
        System.out.print("iterator依次遍历list集合中的对象：");
        Iterator<Integer> intItem = list.iterator();
        while (intItem.hasNext()) {
            int a = intItem.next();
            System.out.print(a + " ");
        }
        System.out.println();

        //清除list集合中的对象
        list.clear();
        System.out.println("移除所有对象后的集合：" + list);

运行结果：

初始list集合：[97, 4, 96, 72, 9, 15, 87, 13, 23, 19]
第二个位置上的对象为：4
删除第二个位置对象后的集合：[97, 96, 72, 9, 15, 87, 13, 23, 19]
修改第二个位置对象后的集合：[97, 999999, 72, 9, 15, 87, 13, 23, 19]
for循环依次遍历list集合中的对象：97 999999 72 9 15 87 13 23 19 
foreach循环依次遍历list集合中的对象：97 999999 72 9 15 87 13 23 19 
iterator依次遍历list集合中的对象：97 999999 72 9 15 87 13 23 19 
移除所有对象后的集合：[]

Set接口：

        /**
         * 以下演示对Set的操作方法
         */
        Set<String> set = new HashSet<>();
        //向集合中添加对象
        set.add("我wo");
        set.add("我b");
        set.add("爱ai");
        set.add("java");
        set.add("567");
        set.add("111");
        System.out.println("初始Set集合：" + set);

        //判断某对象是否在集合中
        boolean contains111 = set.contains("111");
        System.out.println("Set集合中是否包含111:" + contains111);

        //删除集合中的对象
        set.remove("111");
        System.out.println("删除111对象后的集合：" + set);

        //通过foreach循环遍历Set集合中的对象
        System.out.print("foreach循环依次遍历Set集合中的对象：");
        for (String strSet:set) {
            System.out.print(strSet + " ");
        }
        System.out.println();

        //通过iterator遍历Set集合中的对象
        System.out.print("iterator依次遍历Set集合中的对象：");
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String setVal = iterator.next();
            System.out.print(setVal + " ");
        }
        System.out.println();

        //遍历Set集合中的对象，并且使其按顺序输出
        System.out.print("顺序输出Set集合：");
        Set<String> treeSet = new TreeSet<>();
        treeSet.addAll(set);
        Iterator<String> treeIter = treeSet.iterator();
        while (treeIter.hasNext()) {
            String strSetItem = treeIter.next();
            System.out.print(strSetItem + " ");
        }
        System.out.println();

运行结果：

初始Set集合：[111, java, 爱ai, 567, 我wo, 我b]
Set集合中是否包含111:true
删除111对象后的集合：[java, 爱ai, 567, 我wo, 我b]
foreach循环依次遍历Set集合中的对象：java 爱ai 567 我wo 我b 
iterator依次遍历Set集合中的对象：java 爱ai 567 我wo 我b 
顺序输出Set集合：567 java 我b 我wo 爱ai 

Map接口：

        /**
         * 以下演示对Map的操作方法
         */
        Map<String,String> map = new HashMap<>();
        //对象添加到集合中
        map.put("352","张三");
        map.put("512","李四");
        map.put("853","王五");
        map.put("125","赵六");
        map.put("289","黄七");
        map.put("734","秦八");
        System.out.println("初始map集合：" + map);

        //获取key="734"的值
        System.out.println("key=734对应的value：" + map.get("734"));

        //删除key="734"的映射关系对象
        map.remove("734");
        System.out.println("删除key=734后的集合："+ map);

        boolean b = map.containsKey("125");
        System.out.println("集合中是否包含key=125：" + b);

        //修改key="125"对应的value
        map.put("125","哈哈哈");
        System.out.println("key=125的值修改后的集合：" + map);

        //遍历集合中的key
        Set keySet = map.keySet();
        System.out.print("key集合：");
        Iterator<String> setItem = keySet.iterator();
        while (setItem.hasNext()) {
            String strKey = setItem.next();
            System.out.print(strKey + " ");
        }
        System.out.println();

        //遍历集合中key和value，并且使其按顺序输出
        Map<String,String> treeMap = new TreeMap<>();
        treeMap.putAll(map);
        Iterator<String> iter = treeMap.keySet().iterator();
        System.out.print("顺序输出Map集合：");
        while (iter.hasNext()) {
            String strKey = iter.next();
            String strVal = treeMap.get(strKey);
            System.out.print(strKey + ":" + strVal + " ");
        }

运行结果：

初始map集合：{352=张三, 289=黄七, 125=赵六, 512=李四, 853=王五, 734=秦八}
key=734对应的value：秦八
删除key=734后的集合：{352=张三, 289=黄七, 125=赵六, 512=李四, 853=王五}
集合中是否包含key=125：true
key=125的值修改后的集合：{352=张三, 289=黄七, 125=哈哈哈, 512=李四, 853=王五}
key集合：352 289 125 512 853 
顺序输出Map集合：125:哈哈哈 289:黄七 352:张三 512:李四 853:王五