集合常用方法

集合常用方法

Collection接口的常用方法：

add(T t) //添加指定元素 
remove(T t) //删除指定元素 
contains(T t) //是否包含某元素
size() //获得元素的个数 
toArray()方法将集合转换为Object数组
toArray(T[] a)方法将集合转换为相应类型的数组
iterator() //获得迭代器(Iterator类型)，一般用于遍历 
isEmpty() //集合是否为空 

以下演示对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);
        System.out.println("集合是否为空"+c.isEmpty());

运行结果：

List接口的常用方法

add(int index, T t) //向指定位置添加元素 
get(int index) //获取指定位置的元素 
remove(int index) //删除指定元素 
set(int index, T t) //修改指定位置的元素 
indexOf(T t) //获取指定元素的位置

以下演示对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);
        System.out.println("999999元素的索引位置："+list.indexOf(999999));

运行结果：

Set的常用方法：

add(T t) //添加指定元素 
contains(T t) //是否包含某元素
remove(T t) //删除指定元素 

以下演示对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);


        //遍历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 + " ");
        }

运行结果：

Map接口的常用方法

put (K key,V value):把键与值添加到Map集合中  
get(K  key)：根据指定的键，获取对应的值  
remove (K key):删除key对应的值  
containKey(K key):判断是否包含指定的键  
entrySet() :返回Map.Entry型对象，用于遍历。(entry.getKey()/entry.getValue()) 
keySet(K key):获取Map集合中所有的Key，存储到set集合中(用于遍历)  
values(V value) :获取Map集合中所有的Value，存储到Collection集合中(用于遍历)

以下演示对Map的操作方法

        Map<String,String> map = new HashMap<>();
        //对象添加到集合中
        map.put("352","张三");
        map.put("512","李四");
        map.put("853","王五");
        System.out.println("初始map集合：" + map);

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

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

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

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

        /**
         * 第一种方法
         * map.keySet() 返回一个 set<类型为key的类型> 集合
         * 由于这种方式在遍历中又获取了一遍值，所以这种方式比第二种方式慢很多
         */
        //foreach遍历
        for(String keys : map.keySet()) {
            System.out.println("key = " + keys + ", value = " + map.get(keys));
        }

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


        /**
         * 第二种
         * map.entrySet() 返回一个实现了 Map.Entry 接口的对象的set集合
         * Map.Entry 中封装了 getKey() 和 getValue()方法，可以获得相应的 key 和 value
         */
        // 使用Iterator遍历输出
        Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, String> m = it.next();
            System.out.println("key = " + m.getKey() + ", value = " + m.getValue());
        }

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

        /**
         * 第三种
         * map.values() 返回一个 cllection<String> 集合
         */
        Iterator iterator1 = map.values().iterator();
        while(iterator1.hasNext()) {
            System.out.println("value = " + iterator1.next());
        }

运行结果：