Java - 集合（二）

可变参数

package Parameter;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Parameter01 {
    public static void main(String[] args) {
        //特点
        test();//不传数据
        test(10);//传输一个数据
        test(10,20,30);//传输多个数据
        test(new int[]{10,20,30});//传输一个数组
    }

    //一个形参列表只能有一个可变参数
    //可变参数必须在形参列表的最后
    public static void test(int...nums)
    {
        //可变参数在方法内部，本质就是一个数组
        System.out.println(nums.length);
        System.out.println(Arrays.toString(nums));
        System.out.println("00000000000000000000000");
//        输出
//        0
//        []
//        00000000000000000000000
//        1
//        10]
//        00000000000000000000000
//        3
//        [10, 20, 30]
//        00000000000000000000000
//        3
//        [10, 20, 30]
//        00000000000000000000000

    }
}

 Collections

并不是集合，而是一个用来操作集合的工具类

        List<String> names = new ArrayList<>();

        //List\Set
        Collections.addAll(names,"张三","李四","王五","赵六","田七");
        System.out.println(names);
        //[张三, 李四, 王五, 赵六, 田七]

        //List
        Collections.shuffle(names);
        System.out.println(names);
        //[赵六, 张三, 田七, 王五, 李四]

        //List
        //非数字要制定比较规则
        Collections.sort(Students, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });
        System.out.println(Students);

 Map集合

//        Map<String,Integer> map = new HashMap<>();//按照键 无序 不重复 无索引
        Map<String,Integer> map = new LinkedHashMap<>();//按照键 有序 不重复 无索引
        map.put("张三",18);
        map.put("张三",128);//后面覆盖前面
        map.put("手表",128);
        map.put("金鸡奖",85);
        map.put(null,null);
        System.out.println(map);
        //HashMap：{金鸡奖=85, null=null, 手表=128, 张三=128}
        //LinkedHashMap：{张三=128, 手表=128, 金鸡奖=85, null=null}

        Map<Integer,String> map1 = new TreeMap<>();//可排序 不重复 无索引
        map1.put(1,"张三");
        map1.put(3,"张三");
        map1.put(5,"手表");
        map1.put(4,"金鸡奖");
        System.out.println(map1);
        //{1=张三, 3=张三, 4=金鸡奖, 5=手表}

 Map常用方法

map.size():获取集合大小

map.clear():清空集合

map.isEmpty():判断集合是否为空

map.get("object"):获取键对应值

map.remove("object"):根据键删除整个元素（删除键会返回对应键的值）

map.containsKey("object"):判断是否包含某个键

map.containsValue(2):判断是否包含某个值

Set<String> keys = map.keySet():获取集合的全部键

Collection<Integer> values = map.values():获取集合的全部值

map.putAll(map2):将map2全部放入map

遍历方式

 1.键找值：

        Map<String,Double> map = new HashMap<>();
        map.put("张三", 90.0);
        map.put("李四", 80.0);
        map.put("王五", 70.0);
        map.put("赵六", 60.0);
        map.put("田七", 50.0);
        System.out.println(map);
        //{李四=80.0, 张三=90.0, 王五=70.0, 赵六=60.0, 田七=50.0}

        //1.获取map集合所有键
        Set<String> keys = map.keySet();
        System.out.println(keys);
        //[李四, 张三, 王五, 赵六, 田七]
        //2.遍历全部键，根据键获取对应值
        for (String key : keys) {
            //根据键获取对应值
            Double value = map.get(key);
            System.out.println(key + "=====" + value);
        }
        //李四=====80.0
        //张三=====90.0
        //王五=====70.0
        //赵六=====60.0
        //田七=====50.0

 2.键值对：

        //1.调用map集合提供entrySet方法，把map集合转换成键值对类型的set集合
        Set<Map.Entry<String,Double>> entries = map.entrySet();
        for (Map.Entry<String, Double> entry : entries) {
            String ket = entry.getKey();
            double value = entry.getValue();
            System.out.println(ket + "=====" + value);
        }
        //李四=====80.0
        //张三=====90.0
        //王五=====70.0
        //赵六=====60.0
        //田七=====50.0

3.Lambda

//Lambda
        map.forEach((key,value)->{
            System.out.println(key + "=====" + value);
        });

HashMap:

LinkedHashMap:

 TreeMap: