集合常用類及方法匯總

 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:王五