Java中各类Map的运用及方法 Collections接口中的静态方法(基础解析)

时间：2022-06-01 19:32:57

http://blog.csdn.net/ssssssue

Map

    双列结合的根接口
1.以键值对形式保存数据
        一个key 对应一个value
2.键保持唯一

    HashSet和HashMap之间的关系
    底层都是哈希算法 根据面向对象来分析 一套算法 两个类使用
    HashSet底层是依赖HashMap去实现的
    添加到Set中的值 实际上 是 添加到Map中的 键的 位置

    HashMap: 有去重功能(操作的是键)(value不具备这项功能)
    TreeMap: 有排序功能(操作的是键)(value不具备这项功能)

Map的添加方法


        // map 的添加方法
        HashMap<String, Integer> map = new HashMap<>();
Integer put = map.put("Java", 21);
Integer put2 = map.put("Javaya", 19);
Integer put3 = map.put("Javaya", 28);
        // Javaya 的 19 被 28 覆盖了
        // put方法 返回的是 被覆盖的值
        System.out.println(put);
        System.out.println(put2);
        System.out.println(put3);

是否包含key

    HashMap<String, Integer> map = new HashMap<>();
map.put("a", 21);
map.put("b", 20);
map.put("c", 22);
map.put("d", 19);
        //是否包含key
boolean containsKey = mao.containsKey("a");
        System.out.println(containsKey);

是否包含value

    HashMap<String, Integer> map = new HashMap<>();
map.put("a", 21);
map.put("b", 20);
map.put("c", 22);
map.put("d", 19);
boolean containsValue = map.containsValue(19)
        System.out.println(containsValue);

通过key 获取对应的value

    HashMap<String, Integer> map = new HashMap<>();
map.put("a", 21);
map.put("b", 20);
map.put("c", 22);
map.put("d", 19);
Integer i1 = map.get(a);
Integer i1 = map.get(b);
        System.out.println(i1);
        System.out.println(i2);

获取所有key的Set集合

    HashMap<String, Integer> map = new HashMap<>();
map.put("a", 21);
map.put("b", 20);
map.put("c", 22);
map.put("d", 19);
        Set<String> keySet = map.KeySet();
        System.out.println(keySet);

获取所有value的集合

    HashMap<String, Integer> map = new HashMap<>();
map.put("a", 21);
map.put("b", 20);
map.put("c", 22);
map.put("d", 19);
        Collection<Integer> values = map.values();
        System.out.println(values);

通过key删除整个键值对

    Integer remove = map.remove("c");
    System.out.println(remove);

清空Map

    HashMap<String, Integer> map = new HashMap<>();
map.put("a", 21);
map.put("b", 20);
map.put("c", 22);
map.put("d", 19);
map.clear();
        System.out.println(map);
    创建一个学生类 里面保存姓名和年龄
    写上构造方法 set/get方法 重写toString方法
    //创建一个Map key保存学生 value保存户籍
    HashMap<Student, String> hashMap = new HashMap<>();
        hashMap.put(new Student("a", 21), "温州");
        hashMap.put(new Student("b", 22), "安徽");
        hashMap.put(new Student("c", 23), "河南");
        hashMap.put(new Student("c", 23), "河北");
        System.out.println(hashMap);

    发现打印结果 c 有两个 且 一个户籍是 河南 一个户籍是河北
    如果想保持键的唯一性的话
    就需要去重
    这里去重就相当于Set集合去重
    需要重写hashCode 和 equals方法
    重写之后 key相同 value就会被新的值覆盖

用迭代器遍历Map

    HashMap<String, Integer> map = new HashMap<>();
map.put("a", 21);
map.put("b", 20);
map.put("c", 22);
map.put("d", 19);
//通过keySet遍历
Set<String> KeySet = map.KeySet();
        Iterator<String> iterator = keySet.iterator();
while(iterator.hasNext()){
String key = iterator.next();
//根据key 取出 value
Integer value = map.get(key);
            System.out.println(key + "=" + value);
        }

用增强for循环(foreach)来遍历

    HashMap<String, Integer> map = new HashMap<>();
map.put("a", 21);
map.put("b", 20);
map.put("c", 22);
map.put("d", 19);
//通过增强for循环
//获取key的所有set集合
Set<Sring> keySet = map.KeySet();
        for(String key : keySet){
// 通过key取出value
Integer value = map.get(key);
            System.out.println(key + " = " + value);
        }

通过获取键值对对象是Set集合 来遍历

    HashMap<String, Integer> map = new HashMap<>();
map.put("a", 21);
map.put("b", 20);
map.put("c", 22);
map.put("d", 19);
Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
while(iterator.hasNext()){
// 获取Entry 对象
            Entry<String, Integer> entry = iterator.next();
// 获取key
String key = entry.getKey();
// 获取value
Integer value = entry.getValue();
            System.out.println(key + " = " + value);
        }

增强for循环 Entry遍历

    HashMap<String, Integer> map = new HashMap<>();
map.put("a", 21);
map.put("b", 20);
map.put("c", 22);
map.put("d", 19);
Set<Entry<String,Integer>> entrySet = map.entrySet();
        for (Entry<String, Integer> entry : entrySet) {
Integer value = entry.getValue();
String key = entry.getKey();
            System.out.println(key + " = " + value);
        }
    // 键盘输入字符串 统计字符串中每个字符出现的次数 

    System.out.println("请输入字符串");
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
char[] charArray = string.toCharArray();
        HashMap<Character, Integer> map = new HashMap<>();
for (int i = 0; i < charArray.length; i++) {
// 将每一个字符 存入map中
// 判断要存的字符 是否存在于 map 中
char key = charArray[i];
if (!map.containsKey(key)) {
// 不存在这个key 记录一次
                map.put(charArray[i], 1);
            }else {
// 存在这个key
// 利用key把对应的值 取出来 + 1
                Integer value = map.get(key);
value = value + 1;
// 再存回去 覆盖原来 值的 部分
                map.put(key, value);
            }

        }
        System.out.println(map);

linkedHashMap

    特点: 有序(怎么存的 怎么打印)
        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("a", 18);
map.put("b", 19);
map.put("c", 20);
map.put("d", 21);
        System.out.println(map);

TreeSet

    特点: 有排序功能(操作的是键)(value不具备这项功能)
    // 创建一个TreeMap key保存学生 value 保存 户籍
// 按年龄排序
    TreeMap<Student, String> map = new TreeMap<>();
map.put(new Student("a", 11), "安徽");
map.put(new Student("b", 13), "浙江");
map.put(new Student("c", 17), "河南");
map.put(new Student("d", 16), "江苏");
        System.out.println(map);

//使用TreeMap时 系统会自动帮你排序
//所以打印出来的结果就是按年龄从小打到打印

Collections类中的方法(静态方法)

随机交换集合中的值

    ArrayList<Integer> list = new ArrayList<>();
list.add(12);
list.add(13);
list.add(10);
list.add(11);
        Collections.shuffle(list);
        System.out.println(list);

排序

     ArrayList<Integer> list = new ArrayList<>();
list.add(12);
list.add(13);
list.add(10);
list.add(11);
        Collections.sort(list);
        System.out.println(list);
    ArrayList<Student> list = new ArrayList<>();
list.add(new Student("ygs",10));
list.add(new Student("sxd",12));
list.add(new Student("hzn",8));
//排序 实现comparable 接口 只要排的是对象 都需要编写排序规则
        Collections.sort(list);
        System.out.println(list);

二分查找(前提: 有序)

    ArrayList<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(13);
        list.add(10);
        list.add(11);
        int index = Collections.binarySearch;
        System.out.println(index);

反转

    ArrayList<Integer> list = new ArrayList<>();
list.add(12);
list.add(13);
list.add(10);
list.add(11);
        Collections.reverse(list);
        System.out.println(list);
标签：

相关文章