java 集合进阶

双列集合

map

实例

package mymap;

import java.util.HashMap;
import java.util.Map;

public class MapDemo1 {
    public static void main(String[] args) {
        /*
        V put(K key,v value)添加元素
        V remove(object key)根据键删除键值对元素
        void clear()移除所有的键值对元素
        boolean containsKey(object key) 判断集合是否包含指定的键
        boolean containsValue(object value) 判断集合是否包含指定的值
        boolean isEmpty() 判断集合是否为空
        int size()集合的长度，也就是集合中键值对的个数
        */

        //1.创建一个Map集合对象
        Map<String,String> m=new HashMap<>();

        //2.添加元素
        //2.添加元素
        //put方法的细节:
        //添加/覆盖
        //在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中
        //在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回。
        m.put("1", "zhangsan");
        m.put("2", "lisi");
        m.put("3", "wangwu");

        //String v=m.put("3", "zhaoliu");
        //System.out.println(v);

        //删除
        //String result=m.remove("1");
        //System.out.println(result);

        //清空
        //m.clear();

        //判断是否包含
        //boolean keyResult=m.containsKey("1");
        //System.out.println(keyResult);

        //判断集合是否为空
        //boolean empty=m.isEmpty();
        //System.out.println(empty);

        //集合的长度
        int size=m.size();
        System.out.println(size);

        //3.打印集合对象
        System.out.println(m);

    }
}

Map的遍历方式

 1.键找值

package mymap;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo2 {
    public static void main(String[] args) {
        //1.创建一个Map集合
        Map<String,String> map=new HashMap<>();

        //2.添加元素
        map.put("1","one");
        map.put("2","two");
        map.put("3","three");

        //3.1获取键的集合
        Set<String> keys=map.keySet();
        //3.2通过键获取值
        for(String key:keys){
            System.out.println(key);
            //3.3获取值
            String value=map.get(key);
            System.out.println(key+"="+value);
        }
    }
}

用keySet()方法获取map中的键 

2.键值对

package mymap;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo3 {
    public static void main(String[] args) {
        //Map集合的第二种遍历方式

        //1.创建Map集合的对象
       Map<String,String> map=new HashMap<>();
        //2.添加元素
        //键:人物的外号
        //值:人物的名字
        map.put("标枪选手","马超");
        map.put("人物挂件","明世隐");
        map.put("御龙骑士","尹志平");

        //3.Map集合的第二种遍历方式
        //通过键值对对象进行遍历
        //3.1 通过一个方法获取所有的键值对对会
        Set<Map.Entry<String,String>> entries=map.entrySet();
        //3.2 遍历entries这个集合，去得到里面的每一个键值对对象
        for (Map.Entry<String, String> entry : entries) {
            //3.3 利用entry调用get方法获取键和值
            String key=entry.getKey();
            String value=entry.getValue();
            System.out.println(key+"="+value);
        }
    }
}

 用entrySet()方法获取map中的键值对

3.Lambda表达式

package mymap;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class MapDemo4 {
    public static void main(String[] args) {
        //Map集合的第三种遍历方式

        //1.创建Map集合的对象
        Map<String,String> map=new HashMap<>();

        //2.添加元素
        //键:人物的名字
        //值:名人名言
        map.put("鲁迅","这句话是我说的");
        map.put("曹操","不可能绝对不可能");
        map.put("刘备","接着奏乐接着舞");
        map.put("柯镇恶","看我眼色行事");
        //3.利用1ambda表达式进行遍历
        //底层:
        //forEach其实就是利用第二种方式进行遍历，依次得到每一个键和值
        //再调用accept方法
        map.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String k, String v) {
                System.out.println(k+"="+v);
            }
        });
        map.forEach((k,v)->{
            System.out.println(k+"="+v);
        });
    }
}

HashMap

HsahMap练习

练习1

package mymap;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashMapDemo1 {
    public static void main(String[] args) {
        /*
        需求:创建一个HashMap集合，
        键是学生对象(student)，值是籍贯(string)
        存储三个键值对元素，并遍历
        要求:同姓名，同年龄认为是同一个学生
        */

        //1.创建HashMap集合对象
        HashMap<Student, String> map = new HashMap<>();

        //2.创建学生对象
        Student s1 = new Student("zhangsan", 23);
        Student s2 = new Student("lisi", 24);
        Student s3 = new Student("wangwu", 25);
        Student s4 = new Student("wangwu", 25);

        //3.添加键值对元素
        map.put(s1, "北京");
        map.put(s2, "上海");
        map.put(s3, "广州");
        map.put(s4, "深圳");

        //4.遍历集合
        Set<Student> keys = map.keySet();
        for(Student key:keys){
            String value = map.get(key);
            System.out.println(key+"="+value);
        }

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

        Set<Map.Entry<Student, String>> entries = map.entrySet();
        for(Map.Entry<Student, String> entry:entries){
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }

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

        map.forEach((student,s)-> System.out.println(student+"="+s));
    }
}

练习2

package mymap;

import java.util.*;

public class HashMapDemo2 {
    public static void main(String[] args) {
        /*
        某个班级80名学生，现在需要组成秋游活动，
        班长提供了四个景点依次是(A、8、C、D)，
        每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多
         */

        //1.需要先让同学们投票
        //定义一个数组，数组的元素是学生的投票选项
        String[]arr={"A","B","C","D"};
        ArrayList<String> list = new ArrayList<>();
        Random r=new Random();
        //利用随机数，模拟80个同学的投票
        for (int i = 0; i < 80; i++) {
            //随机生成一个索引
            int index=r.nextInt(arr.length);
            list.add(arr[index]);
        }
        //2.如果要统计的东西比较多，不方便用计数器，此时我们可以选择Map集合
        //定义一个Map集合，用来统计最终的结果
        HashMap<String, Integer> map = new HashMap<>();

        for (String name : list) {
            if(map.containsKey(name)){
                //包含了，说明之前已经投过票了
                int count=map.get(name);
                count++;
                map.put(name,count);
            }else{
                //不包含，说明是第一次投票
                map.put(name,1);
            }
        }

        System.out.println(map);

        //3.求最大值
        int max=0;
        Set<Map.Entry<String,Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            int count=entry.getValue();
            if(count>max){
                max=count;
            }
        }

        //4.判断哪个景点的次数和最大值一样，如果一样，就输出
        for (Map.Entry<String, Integer> entry : entries) {
            int count=entry.getValue();
            if(count==max){
                System.out.println(entry.getKey());
            }
        }
    }
}

 

 LinkedHashMap

TreeMap

如果两种排序规则都书写了，以第二种为准

案例

 

需求1 

package mymap;

import java.util.Comparator;
import java.util.TreeMap;

public class TreeMap1 {
    public static void main(String[] args) {
        /*
        TreeMap集合:基本应用
        需求1:
        键:整数表示id
        值:字符串表示商品名称
        要求1:按照id的升序排列
        要求2:按照id的降序排列
         */

        //1.创建TreeMap集合
        TreeMap<Integer,String> tm = new TreeMap<>(new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });

        //2.添加元素
        tm.put(1,"六个核弹");
        tm.put(2,"八个雅鹿");
        tm.put(3,"肯贝基");
        tm.put(4,"霸王堡");

        //3.打印集合
        System.out.println(tm);
    }
}

 需求2

package mytreemap;

public class Student implements Comparable<Student> {
    private String name;
    private int age;

    ......

    @Override
    public int compareTo(Student o) {
        int i = this.age - o.age;
        i=i==0?this.name.compareTo(o.name):i;
        return i;
    }
}

package mytreemap;

import myhashmap.Student;

import java.util.TreeMap;

public class TreeMap2 {
    public static void main(String[] args) {
        /*
        TreeMap集合:基本应用
        需求2:
        键:学生对象
        值:籍贯
        要求:按照学生年龄的升序排列，年龄一样按照姓名的字母排列，同姓名年龄视为同一个人。
         */

        //1.创建TreeMap集合
        TreeMap<mytreemap.Student,String> tm = new TreeMap<>();
        //2.添加元素
        tm.put(new mytreemap.Student("zhangsan",20),"北京");
        tm.put(new mytreemap.Student("lisi",21),"上海");
        tm.put(new mytreemap.Student("wangwu",22),"广州");
        tm.put(new mytreemap.Student("zhaoliu",20),"深圳");

        //3.打印集合
        System.out.println(tm);
    }
}

案例

package mytreemap;

import java.util.TreeMap;

public class TreeMap3 {
    public static void main(String[] args) {
        /*
        需求:
           字符串“aababcabcdabcde”
           请统计字符串中每一个字符出现的次数，并按照以下格式输出
           输出结果:
           a(5)b(4)c(3)d(2)e(1)
           新的统计思想:利用map集合进行统计
           如果题目中没有要求对结果进行排序，默认使用HashMap
           如果题目中要求对结果进行排序，请使用TreeMap
           键:表示要统计的内容
           值:表示次数
         */

        //1.定义字符串
        String str="aababcabcdabcde";

        //2.创建map集合
        TreeMap<Character,Integer> tm=new TreeMap<>();

        //3.遍历字符串，获取每一个字符
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            //4.判断map集合中是否包含该字符
            if(tm.containsKey(c)){
                //5.如果包含，获取该字符对应的值
                Integer value = tm.get(c);
                value++;
                tm.put(c, value);
            }else{
                //6.如果不包含，将该字符作为键，值为1存入map集合
                tm.put(c, 1);
            }
        }

        //遍历map集合，并按照格式输出
        for (Character key : tm.keySet()) {
            Integer value = tm.get(key);
            System.out.print(key+"("+value+")");
        }
    }
}