java关于Map

大概的内容如下

1可变参数

public class l可变参数 {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
    }
    //public static int sum1(int b,int...a){}
    public static int sum(int...a){
        //a其实是一个数组
        int sum=0;
        for(int i:a)
        {
            sum+=i;
        }
        return sum;
    }
}

Map1

public class Map1 {
    //将键映射到值的对象。地图不能包含重复的键，每个键可以映射到最多一个值
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String>map=new HashMap<String,String>();
        map.put("itheima001","林青霞");
        map.put("itheima002","张曼玉");
        map.put("itheima003","王祖贤");
        map.put("itheima003","柳岩");
        System.out.println(map);
    }
}

Map2

public class Map2 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        //System.out.println(map.remove("郭靖"));
        //System.out.println(map.remove("郭襄"));
        //map.clear();
        System.out.println(map.containsKey("郭靖"));
        System.out.println(map.containsKey("郭襄"));
        System.out.println(map.containsValue("赵敏"));
        System.out.println(map.isEmpty());
        System.out.println(map.size());
        System.out.println(map);

    }
}

Map3

public class Map3 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");

        System.out.println(map.get("张无忌"));
        System.out.println(map.get("张三丰"));
        //获取所有键的集合
        Set<String> keySet=map.keySet();
        for(String key:keySet){
            System.out.println(key);
        }
        //获取值的集合
        Collection<String> values = map.values();
        for(String value:values)
        {
            System.out.println(value);
        }

    }
}

Map4

public class Map4 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        //获取所有键的集合，用keySet()方法实现
        Set<String> keySet=map.keySet();
        for(String key:keySet){
            //根据键去找值，用get(Object key)方法实现
            String value=map.get(key);
            System.out.println(key+","+value);
        }
    }
}

Map5

public class Map5 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        //获取所有键值对对象的集合
        Set<Map.Entry<String,String>> entrySet=map.entrySet();
        //遍历键值对对象的集合，得到每一个键值对对象
        for(Map.Entry<String,String> me:entrySet)
        {
            //根据键值对对象得到键和值
            String value=me.getValue();
            String key=me.getKey();
            System.out.println(key+","+value);
        }

    }
}

Map6

public class Map6 {
    public static void main(String[] args) {
      //创建HashMap集合对象
        HashMap<String ,Student> hm=new HashMap<String,Student>();
        //创建学生对象
        Student s1=new Student("林青霞",30);
        Student s2=new Student("张曼玉",35);
        Student s3=new Student("王祖贤",33);
        //把学生添加到集合
        hm.put("itheima001",s1);
        hm.put("itheima002",s2);
        hm.put("itheima003",s3);
        //方式一：键找值
        Set<String> Keyset = hm.keySet();
        for(String key:Keyset)
        {
           Student value= hm.get(key);
            System.out.println(key+","+value.getName()+","+value.getAge());
        }
        //方式二:键值对对象找键和值
        Set<Map.Entry<String, Student>> entrySet = hm.entrySet();
        for(Map.Entry<String, Student> me:entrySet)
        {
            String key = me.getKey();
            Student value = me.getValue();
            System.out.println(key+","+value.getName()+","+value.getAge());
        }
    }
}

Map7

public class Map7 {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Student ,String> hm=new HashMap<Student ,String>();
        //创建学生对象
        Student s1=new Student("林青霞",30);
        Student s2=new Student("张曼玉",35);
        Student s3=new Student("王祖贤",33);
        Student s4=new Student("王祖贤",33);
        //把学生添加到集合
        hm.put(s1,"西安");
        hm.put(s2,"武汉");
        hm.put(s3,"郑州");
        hm.put(s4,"北京");
        //遍历集合
        Set<Student> keySet = hm.keySet();
        for(Student key:keySet)
        {
            String value = hm.get(key);
            System.out.println(key.getName()+","+key.getAge()+","+value);
        }
    }
}

Map8

public class Map8 {
    //集合嵌套之ArrayList嵌套HashMap
    //需求：创建一个ArrayList集合，存储三个元素，每一个元素都是HashMap,每一个HashMap的键和值都是String,并遍历
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList<HashMap<String,String>> array=new ArrayList<HashMap<String,String>>();
        //创建HashMap集合,并添加键值元素
        HashMap<String,String> hm1=new HashMap<String ,String>();
        hm1.put("孙策","大乔");
        hm1.put("周瑜","小乔");
      //把HashMap作为元素添加到ArrayList集合
        array.add(hm1);

        HashMap<String,String> hm2=new HashMap<String ,String>();
        hm1.put("郭靖","黄蓉");
        hm1.put("杨过","小龙女");
        //把HashMap作为元素添加到ArrayList集合
        array.add(hm2);

        HashMap<String,String> hm3=new HashMap<String ,String>();
        hm1.put("令狐冲","任盈盈");
        hm1.put("林平之","岳灵珊");
        //把HashMap作为元素添加到ArrayList集合
        array.add(hm3);

        //遍历ArayList集合
        for(HashMap<String,String> hm:array)
        {
            Set<String> keySet = hm.keySet();
            for(String key:keySet)
            {
                String value = hm.get(key);
                System.out.println(key+","+value);
            }
        }
    }
}

Map9

public class Map9 {
    //HashMap集合存储AraryList元素并遍历
    public static void main(String[] args) {
        //创建HashMap集合
        HashMap<String, ArrayList<String>> hm=new HashMap<String, ArrayList<String>>();
        //创建ArrayList集合并添加元素
        ArrayList<String> sgyy=new ArrayList<String>();
        sgyy.add("诸葛亮");
        sgyy.add("赵云");
        //把ArrayList作为元素添加到HashMap集合
        hm.put("三国演义",sgyy);

        ArrayList<String> xyj=new ArrayList<String>();
        sgyy.add("唐僧");
        sgyy.add("孙悟空");
        //把ArrayList作为元素添加到HashMap集合
        hm.put("西游记",xyj);

        ArrayList<String> shz=new ArrayList<String>();
        sgyy.add("武松");
        sgyy.add("鲁智深");
        //把ArrayList作为元素添加到HashMap集合
        hm.put("水浒传",shz);

        //遍历HashMap集合
        Set<String> keySet=hm.keySet();
        for(String key:keySet)
        {
            System.out.println(key);
            ArrayList<String> value=hm.get(key);
            for(String s:value)
            {
                System.out.println(s);
            }
        }
    }
}

Map 10

public class Map10 {
    public static void main(String[] args) {
        //1.键盘录入一个字符串
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line = sc.nextLine();
        //创建HAshMap集合，键是Character,值是Integer
        HashMap<Character,Integer> hm=new HashMap<Character,Integer>();

        //遍历字符串，得到每一个字符
        for(int i=0;i<line.length();i++)
        {
            char key = line.charAt(i);
            //拿得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
            Integer value = hm.get(key);

            if(value==null)
            {
                //如果返回的值是null,说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
                hm.put(key,1);
            }else{
                //如果返回值不是NUll,说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
                value++;
                hm.put(key,value);
            }
            //遍历HashMap集合，得到键和值，按照要求进行拼接
            StringBuilder sb=new StringBuilder();

            Set<Character> keySet = hm.keySet();
            for(Character key1 : keySet)
            {
                Integer value1 = hm.get(key1);
                sb.append(key1).append("(").append(value1).append(")");
            }
            String result = sb.toString();
            //输出结果
            System.out.println(result);
        }

    }
}

类型通配符

public class TPF {
    /*
    类型通配符，<?>
    List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型
    这种带通配符的List仅表示它是各种泛型list的父类，并不能把元素添加到其中

    类型通配符上限，<? extends 类型>
    List<? extends Number>:它表示的类型是Number或者其子类型

    类型通配符下限，<? super 类型>
    List<? super Number>:它表示的类型是Number或者其父类型
     */
    public static void main(String[] args) {
        //类型通配符<?>
        List<?> list1=new ArrayList<Object>();
        List<?> list2=new ArrayList<Number>();
        List<?> list3=new ArrayList<Integer>();
        System.out.println("-----------");
        //类型通配符的上限
       //List<? extends Number> list4=new ArrayList<Object>();
        List<? extends Number> list5=new ArrayList<Number>();
        List<? extends Number> list6=new ArrayList<Integer>();
        //类型通配符的下限
        List<? super Number> list7=new ArrayList<Object>();
        List<?  super Number> list8=new ArrayList<Number>();
//        List<?  super Number> list9=new ArrayList<Integer>();
    }
}

创建学生类

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
//重写equals和hasshCode时，只需按下alt+ins自动生成即可。
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

Collections存储学生并排序

public class ColltctionsDemo {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<Student> array=new ArrayList<Student>();

        //创建学生对象
        Student s1=new Student("linqingxia",30);
        Student s2=new Student("zhangmanyu",35);
        Student s3=new Student("wangzhuxian",33);
        Student s4=new Student("liuyan",33);

        //把学生添加到集合
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);

        //使用Collections对ArrayList进行排序

        Collections.sort(array, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
                int num=s1.getAge()-s2.getAge();
                int num2=num==0?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });
        //遍历集合
        for(Student s:array)
        {
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

斗地主发牌案例1

public class DouDIZhu {
    public static void main(String[] args) {
        //模拟斗地主的洗牌，发牌，看牌
        //创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
        ArrayList<String> array=new ArrayList<String>();

        //往牌盒里面装牌
        /*  ♠2...
            ♦3...
            ♥4...
            ♣2...
            小王，大王
         */
        //定义花色数组
        String[] colors={"♠"," ♦","♥"," ♣"};
        //定义点色数组
        String[] numbers={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
        for(String color:colors)
        {
            for(String number:numbers)
            {
                array.add(color+number);
            }
        }
        array.add("小王");
        array.add("大王");

        //洗牌，也就是把牌打乱,用Collections的shuffle()方法实现
        Collections.shuffle(array);
        //发牌，也就是遍历集合，给三个玩家发牌
        ArrayList<String> lqxArray=new ArrayList<String>();
        ArrayList<String> lyArray=new ArrayList<String>();
        ArrayList<String> fqyArray=new ArrayList<String>();
        ArrayList<String> dpArray=new ArrayList<String>();
        for(int i=0;i<array.size();i++)
        {
            String poker = array.get(i);
            if(i>=array.size()-3)
            {
                dpArray.add(poker);
            }else if(i%3==0)
            {
                lqxArray.add(poker);
            }else if(i%3==1)
            {
                lyArray.add(poker);
            } else if (i%3==2) {
                fqyArray.add(poker);
            }
        }
        System.out.println("底牌："+dpArray);
        System.out.println("刘岩"+lyArray);
        System.out.println("风清扬"+fqyArray);
        System.out.println("林青霞"+lqxArray);
        //看牌的方法
//        void lookPoker(String name,ArrayList<String> array)
//        {
//            System.out.println(name,+"的牌是:");
//        }
    }
}

斗地主发牌案例2

public class DouDiZhuP {
    public static void main(String[] args) {
        //创建HashMap,键是编号，值是牌
        HashMap<Integer,String> hm=new HashMap<Integer,String>();

        //创建ArayList,存储编号
        ArrayList<Integer> array=new ArrayList<Integer>();

        //创建花色数组和点色数组
        String[] colors={"♠"," ♦","♥"," ♣"};
        //定义点色数组
        String[] numbers={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        //从0开始往HashMap里面存储编号，并存储对应的牌，同时往ArrayList里面存储编号
        int index=0;
        for(String number:numbers)
        {
            for(String color:colors)
            {
                hm.put(index,color+number);
                array.add(index);
                index++;
            }
        }
        hm.put(index,"小王");
        array.add(index);
        index++;
        hm.put(index,"小王");
        array.add(index);
        //洗牌（洗的是编号），用Collections的shuffle()方法实现
        Collections.shuffle(array);

        //发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收)
        TreeSet<Integer> lqxSet=new TreeSet<>();
        TreeSet<Integer> lySet=new TreeSet<>();
        TreeSet<Integer> fqySet=new TreeSet<>();
        TreeSet<Integer> dpSet=new TreeSet<>();
        for(int i=0;i<array.size();i++)
        {
            int x=array.get(i);
            if(i>=array.size()-3){
                dpSet.add(x);
            } else if (i % 3 == 0) {
                lqxSet.add(x);
            } else if (i % 3 == 1) {
                lySet.add(x);
            } else if (i % 3 == 2) {
                fqySet.add(x);
            }
        }
        look("林青霞",lqxSet,hm);
        look("刘岩",lySet,hm);
        look("风清扬",fqySet,hm);
        look("底牌",dpSet,hm);
    }
    //定义方法看牌
    public  static void look(String name,TreeSet<Integer> ts,HashMap<Integer,String> hm){
        System.out.println(name+"的牌是:");
        for(Integer key:ts) {
            String poker = hm.get(key);
            System.out.print(poker+" ");
        }
        System.out.println();
    }
}