集合框架（二）

一，Collection的其他相关知识

前置知识：可变参数

1.可变参数

就是一种特殊形参，定义在方法，构造器的形参列表里，格式是：数据类型...参数名称

2.可变参数的特点和好处

（1）特点：可以不传数据给它；可以传一个或者同时传多个数据给它；可以传一个数组给它

（2）好处：常常用来灵活地接受数据

3.可变参数的注意事项：

（1）可变参数在方法内部就是一个数组

（2）一个形参列表中，只能有一个可变参数

（3）可变参数必须放在形参列表的最后面

import java.util.Arrays;

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

    }
    //注意事项1：一个形参列表中，只能有一个可变参数
    //注意事项2：可变参数必须放在形参列表的最后面
    public static void test(int ...nums){
        System.out.println(nums.length);
        System.out.println(Arrays.toString(nums));
        System.out.println("-----------------------------");
    }
}

//运行结果
0
[]
-----------------------------
1
[10]
-----------------------------
3
[10, 20, 30]
-----------------------------
3
[10, 20, 30]
-----------------------------

Collection

1.collections是一个用来操作集合的工具类

2.collection提供的常用静态方法

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

public class CollectionTest1 {
    public static void main(String[] args) {
        //1.public static <T> boolean addAll(Collection<? super T>c,T...elements)为集合批量添加
        List<String> names=new ArrayList<>();
        Collections.addAll(names,"张三","王五","李四");
        System.out.println(names);
        //2.public static void shuffle(List<?> list),打乱list集合中的顺序
        Collections.shuffle(names);
        System.out.println(names);
        //3.public static <T> void sort(List<T> list),对list集合中的数据进行升序排序
        List<Integer> list=new ArrayList<>();
        list.add(3);
        list.add(5);
        list.add(2);
        Collections.sort(list);
        System.out.println(list);
        //4.public static <T> void sart(List<T> list,Comparator<? super T> c)：对list集合中元素，按照比较器对象制定的规则进行排序

    }
}

二，Map集合

概述

1.认识Map集合

（1）Map集合称为双列集合，格式：{key1=value1,key2=valye2,....}一次需要存入一对数据做为一个元素

（2）Map集合的每个元素key=value，Map集合也被称为“键值对集合”

（3）Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每个键只能找到自己对应的值

2.Map集合体系的特点

注意：Map键决定，值不做要求

（1）HashMap：无序，不重复，无索引（用的最多）

（2）LinkedHashMap：有序，不重复，无索引

（3）TreeMap：按照大小默认升序排序，不重复，无索引

常用方法

Map是双列集合的祖宗，它的功能是双列集合都可以继承过来使用的

 //1.添加元素：无序，不重复，无索引
        Map<String,Integer> map=new LinkedHashMap<>();//有序，不重复，无索引
        map.put("手表",100);
        map.put("手表",220);
        map.put("手机",2);
        map.put("Java",2);
        map.put(null,null);
        System.out.println(map);
        //2.public int size():获取集合的大小
        System.out.println(map.size());
        //3.public void clear():清空集合
        //map.clear();
        //System.out.println(map);
        //4.public boolean isEmpty():判断集合是否为空，为空返回true，反之
        System.out.println(map.isEmpty());
        //5.public V get(Object key):根据键获取相应的值
        int v1=map.get("手表");
        System.out.println(v1);
        //6.public V remove(Object key):根据键删除某个元素（删除键会返回相应的值）
        System.out.println(map.remove("手表"));
        System.out.println(map);
        //7.public boolean containsKey(Object key):判断是否包含某个元素，包含返回true，反之
        System.out.println(map.containsKey("手表"));//false
        //8.public boolean containsValue(Object value):判断是否包含某个值的
        System.out.println(map.containsValue(2));
        System.out.println(map.containsValue("2"));//"2"代表键
        //9.pubLic Set<K> keySet():获取Map集合的全部键
        Set<String> keys=map.keySet();
        System.out.println(keys);
        //10.public Collectiob<V> values():获取Map集合的全部值
        Collection<Integer> values=map.values();
        System.out.println(values);
        //11.把其他Map集合的数据倒入到自己集合中来
        Map<String,Integer> map1=new HashMap<>();
        map1.put("java1",10);
        map1.put("java2",20);
        Map<String,Integer> map2=new HashMap<>();
        map1.put("java3",10);
        map1.put("java2",222);
        map1.putAll(map2);//把map2集合中的元素全部倒入map1
        System.out.println(map1);
        System.out.println(map2);

遍历方法

1.键找值

先获取Map集合全部的键，再通过遍历键来找值

  //1.准备一个Map集合
        Map<String,Double> map=new HashMap<>();
        map.put("蜘蛛精",162.5);
        map.put("紫霞",169.8);
        map.put("至尊宝",169.5);
        map.put("牛魔王",183.6);
        //1.获取Map集合的全部键
        Set<String> keys=map.keySet();
        //2.便利全部键，根据键获取对应的值
        for (String key : keys) {
            double value= map.get(key);
            System.out.println(key+"====>"+value);

2.键值对

 Map<String,Double> map=new HashMap<>();
        map.put("蜘蛛精",162.5);
        map.put("紫霞",169.8);
        map.put("至尊宝",169.5);
        map.put("牛魔王",183.6);
        Set<Map.Entry<String,Double>> entries=map.entrySet();
        for (Map.Entry<String, Double> entry : entries) {
            String key=entry.getKey();
            double value=entry.getValue();
            System.out.println(key+"-------->"+value);

3.Lambda

  Map<String,Double> map=new HashMap<>();
        map.put("蜘蛛精",162.5);
        map.put("紫霞",169.8);
        map.put("至尊宝",169.5);
        map.put("牛魔王",183.6);
        map.forEach((k,v)->{
            System.out.println(k+"----->"+v);
        });

集合的嵌套

 Map<String,List<String>> map=new HashMap<>();
        List<String> cities1=new ArrayList<>();
        Collections.addAll(cities1,"xxx","yyy","sss");
        map.put("湖北省",cities1);