AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Map集合详解及Collections方法和Arrays方法

2023-10-25 60
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Map集合详解及Collections方法和Arrays方法

一.Map集合简介

Java中的Map是一种键值对的集合类型，它允许将键映射到值。在Map中，键的值是唯一的，而值则可重复。Map定义了一些方法，可以通过键来操作值。

二.Map集合的特点和遍历方式

1.特点和方法：

增删改查

获取获取Map中键值对的数量：size()

containsKey(key)方法判断Map中是否包含某个键

containsValue(value)方法判断Map中是否包含某个值

2.遍历方式

a.通过keyset转为set集合进行遍历

b.通过entryset转换为set集合遍历

代码展示

package com.ctb.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
 * map集合的特点：增删改查
 * 
 * map集合的遍历：1.转ketset遍历 2.entryset遍历
 * 
 * @author biao
 *
 */
public class Demo1 {
  public static void main(String[] args) {
    Map<Object, String> map=new HashMap<Object, String>();
    //增加
    map.put("name", "东哥");
    map.put("hobby", "掉找天");
    map.put("age", "芜湖");
    map.put("address", "奥迪噶多");
    //删除-以键删除整体
    map.remove("hobby");
    //修改--即覆盖
    map.put("age", "34");
    //查询
    System.out.println(map);
    //containsKey(key)方法判断Map中是否包含某个键
    boolean hasKey = map.containsKey("name");
    //containsValue(value)方法判断Map中是否包含某个值
    boolean hasValue = map.containsValue("female");
    System.out.println(hasKey); // 输出: true
    System.out.println(hasValue); // 输出: false
    //获取Map中键值对的数量
    int size = map.size();
    System.out.println(size);
    System.out.println("-------------keyset遍历-------------");
    //遍历1--KeySet
    Set<Object> keySet = map.keySet();
    for (Object key : keySet) {
      System.out.println(key+":"+map.get(key));
    }
    System.out.println("------------entrySet遍历-----------");
    //遍历2--entryset
    Set<Entry<Object, String>> entrySet = map.entrySet();
    for (Entry<Object, String> entry : entrySet) {
      System.out.println(entry.getKey()+":"+entry.getValue());
    }
  }
}

输出结果：

三.通过Map集合统计一串字符串的数量 

package com.ctb.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
 * 统计字符串的数量
 * @author biao
 *
 */
public class Demo2 {
  public static void main(String[] args) {
    //定义一窜字符串
     String s = "adfjakjdflkajlfajsalkfjdklqajwlekrjlkamfdklasjklrfejqkfnmsfdakhjfdklawjerklwjmfl";
         //转换成数组
     char[] chars = s.toCharArray();
          Map<Character, Integer> map = new HashMap<Character, Integer>();
          //遍历
          for (char c : chars) {
                  Integer o = map.get(c);
                 if (o == null){//如果为空，则只有一个
                     map.put(c,1);
                 }else {
                     map.put(c,o+1);//不为空，则+1
                 }
    }
          //将map集合转为set集合
           Set<Entry<Character, Integer>> entrySet = map.entrySet();
           for (Entry<Character, Integer> entry : entrySet) {
             System.out.println(entry.getKey()+"出现了"+entry.getValue()+"次");
           }
  }
}

输出结果：  

四.泛型的作用

1.可将运行时的异常转换为编译期的错误

2.提高代码的健壮性

package com.ctb.map;
import java.util.HashMap;
import java.util.Map;
/**
 * 泛型的作用
 * 
 * @author biao
 *
 */
public class Demo3 {
  public static void main(String[] args) {
    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("as", 12);
    map.put("rf", 43);
    map.put("haha", 24);
    // map.put(12, 21);会报错，若不添加异常，则以下方法会报异常错误
    //指定泛型后则 1.可将运行时的异常转换为编译期的错误  2.提高代码的健壮性
     for (Integer value : map.values()) {
              if (value != null){
                  if (value % 2 == 0){
                      System.out.println(value);//打印结果：12  24
                  }
              }
          }
  }
}

五.Treemap排序

按照自然顺序排序

package com.ctb.map;
import java.util.Map;
import java.util.TreeMap;
/**
 * treemap排序
 * 默认按照自然顺序排序
 * @author biao
 *
 */
public class Demo6 {
  public static void main(String[] args) {
    Map<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(3, "c");
    treeMap.put(1, "a");
    treeMap.put(2, "b");
    treeMap.put(4, "d");
    //排序
    for (Map.Entry<Integer, String> entry : treeMap.entrySet()) {
      System.out.println(entry.getKey() + " : " + entry.getValue());
    }
  }
}

输出结果：  

六. LinkedHashMap排序

按照插入顺序排序

package com.ctb.map;
import java.util.Map;
import java.util.LinkedHashMap;
/**
 * LinkedHashMap
 * 默认按照插入顺序排序
 * @author biao
 *
 */
public class Demo7 {
  public static void main(String[] args) {
    Map<String, String> linkedHashMap = new LinkedHashMap<>();
    linkedHashMap.put("a", "A");
    linkedHashMap.put("c", "C");
    linkedHashMap.put("b", "B");
    for (Map.Entry<String, String> entry : linkedHashMap.entrySet()) {
      System.out.println(entry.getKey() + " : " + entry.getValue());
    }
  }
}

输出结果：  

七.WeakHashMap弱引用

当某个键没有任何引用时，对应的键值对会被从Map中删除

package com.ctb.map;
import java.util.Map;
import java.util.WeakHashMap;
/**
 * WeakHashMap 弱引用
 * 
 * @author biao
 *
 */
public class Demo8 {
  public static void main(String[] args) {
    // WeakHashMap 当某个键没有任何引用时，对应的键值对会被从Map中删除
    Map<Object, String> weakHashMap = new WeakHashMap<>();
    // weak：弱的
    Object key = new Object();
    weakHashMap.put(key, "value");
    System.out.println(weakHashMap.get(key));
    key = null;
    System.gc();// 垃圾回收
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println(weakHashMap.get(key));
  }
}

输出结果：

八.Collections的使用

1.Collections.sort(list);默认升序

2.Collections.sort(list, Collections.reverseOrder()); 字符串降序排序

3.Collections.sort(ll, (a, b) -> b - a);数字类型降序排序

4.collections比较器排序

5.list比较器排序

6.list集合转数组（转字符串数组，转Object类型数组，转integer类型数组）

7.set集合转数组（转integer类型数组）--同list

8.map集合转数组（转object类型数组，转换为指定类型数组，将键(key)转为指定类型数组，将值(value)转为指定类型数组）

9.将集合中的元素进行翻转操作

10.将集合中的元素打乱

11.在集合中进行二分查找

12.获取集合中的最大值和最小值

13.将集合中的所有元素替换成？？？

14.将集合中的元素进行复制到另一个集合

package com.ctb.map;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
 * collection的使用
 * 
 * @author biao
 *
 */
public class Demo4 {
  public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("a");
    list.add("d");
    list.add("b");
    list.add("f");
    list.add("h");
    list.add("e");
    System.out.println("打印前：" + list);
    // 排序--对象同操作
    Collections.sort(list);
    System.out.println("Collections排序(默认升序):" + list);
    Collections.sort(list, Collections.reverseOrder()); // 对集合进行降序排序
    System.out.println("字符串降序："+list);
    List<Integer> ll=new ArrayList<>();
    ll.add(2);
    ll.add(4);
    ll.add(42);
    ll.add(5);
    ll.add(7);
    Collections.sort(ll, (a, b) -> b - a); // 对集合进行降序排序
    System.out.println("数字类型降序："+ll);
    // collections比较器排序
    Collections.sort(list, new Comparator<String>() {
      @Override
      public int compare(String o1, String o2) {
        return o1.compareTo(o2);
      }
    });
    System.out.println("collections比较器排序:" + list);
    // list比较器排序
    list.sort(new Comparator<String>() {
      @Override
      public int compare(String o1, String o2) {
        return o1.compareTo(o2);
      }
    });
    System.out.println("list比较器排序:" + list);
    System.out.println("-----------------list集合转数组-------------------");
    // 转换为字符串数组
    String[] array1 = list.toArray(new String[0]);
    System.out.println("转换为字符串数组:"+Arrays.toString(array1));
    // 转换为Object类型数组
    Object[] array2 = list.toArray();
    System.out.println("转换为Object类型数组:"+Arrays.toString(array2));
    // 转换为integer类型数组
    List<Integer> list1 = new ArrayList<Integer>();
    list1.add(12);
    list1.add(4);
    list1.add(3);
    Integer[] array = list1.toArray(new Integer[0]);
    System.out.println("转换为integer类型数组:"+Arrays.toString(array));
    System.out.println("-------------------set集合转数组------------------");
    // 转换为integer类型数组--其它数组类型同上
    Set<Integer> set = new HashSet<>();
    set.add(1);
    set.add(2);
    set.add(5);
    int[] arr = set.stream().mapToInt(Integer::intValue).toArray();
    System.out.println("转换为integer类型数组:"+Arrays.toString(arr)); // 输出: [1, 2, 5]
    System.out.println("----------------------map集合转数组--------------------------");
    Map<String, Integer> map = new HashMap<>();
    map.put("A", 1);
    map.put("B", 2);
    map.put("C", 3);
    Set<Entry<String, Integer>> entrySet = map.entrySet();
    // 转换为object类型数组
    Object[] array11 = entrySet.toArray();
    System.out.println("转换为object类型数组:"+Arrays.toString(array11));
    //转换为指定类型数组
    Map.Entry<String, Integer>[] array21 = entrySet.toArray(new Map.Entry[0]);
    System.out.println("转换为指定类型数组:"+Arrays.toString(array21));
    //将键(key)转为指定类型数组
    String[] keys = map.keySet().toArray(new String[0]);
    System.out.println("将键(key)转为指定类型数组:"+Arrays.toString(keys)); // 输出: [A, B, C]
    //将值(value)转为指定类型数组
    Integer[] values = map.values().toArray(new Integer[0]);
    System.out.println("将值(value)转为指定类型数组:"+Arrays.toString(values)); // 输出: [1, 2, 3]
    //------------------------------------------------
    System.out.println("============================================");
    List li=new ArrayList<>();
    li.add("花花");
    li.add("文文");
    li.add("琳琳");
    li.add("安安");
    System.out.println("原数据:"+li);
    // 将集合中的元素进行翻转操作
    Collections.reverse(li); 
    System.out.println("将集合中的元素进行翻转:"+li); 
     // 将集合中的元素打乱
    Collections.shuffle(li);
    System.out.println("将集合中的元素打乱:"+li); 
  System.out.println("---------------------------");
  List<Integer> lt=new ArrayList<>();
  lt.add(2);
  lt.add(4);
  lt.add(6);
  lt.add(8);
  lt.add(10);
  System.out.println("原数据："+lt);
  //在集合中进行二分查找
  int index = Collections.binarySearch(lt, 8); // 在集合中查找元素8
  System.out.println("二分查找:"+index);
  int max = Collections.max(lt); // 获取集合中的最大值
  int min = Collections.min(lt); // 获取集合中的最小值
  System.out.println("最大值:"+max); // 输出: 10
  System.out.println("最大值:"+min); // 输出: 2
  List<Integer> lis =new ArrayList<>();
  lis.add(3);
  lis.add(1);
  lis.add(12);
  lis.add(23);
  lis.add(45);
  System.out.println(lis);
  Collections.copy(lis, lt); // 将lt中的元素复制到lis中
  System.out.println("复制："+lis); 
  // 将集合中的所有元素替换成0
  Collections.fill(lt, 0); 
  System.out.println("将集合中的所有元素替换成0:"+lt); 
  }
}

输出结果：

九.Arrays的使用

1.数组排序--升序

2.对数组进行降序排序

3.复制一个数组的一部分或全部到一个新数组中

4.复制一个数组的一部分到一个新数组中

5.判断两个数组是否相等

6.将数组全部元素替换成？？？

7.将数组转换为List集合

package com.ctb.map;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
 * arrays的使用
 * 
 * @author biao
 *
 */
public class Demo5 {
  public static void main(String[] args) {
    Integer[] arr = { 2, 3, 4, 7, 456, 32, 12 };
    Arrays.sort(arr);
    // 数组排序--默认升序
    System.out.println("数组排序--默认升序:" + Arrays.toString(arr));
    // 对数组进行降序排序
    Arrays.sort(arr, Collections.reverseOrder());
    System.out.println("对数组进行降序排序:" + Arrays.toString(arr));
    // 用于复制一个数组的一部分或全部到一个新数组中
    Integer[] copyArr = Arrays.copyOf(arr, 3); // 复制数组前3个元素到新数组中
    System.out.println("复制数组前3个元素到新数组中:" + Arrays.toString(copyArr));
    //用于复制一个数组的一部分到一个新数组中
    Integer[] copyArr1 = Arrays.copyOfRange(arr, 1, 4); // 复制数组索引1到3的元素到新数组中
    System.out.println("复制数组索引1到3的元素到新数组中:"+Arrays.toString(copyArr1));
    int[] arr1 = {1, 2, 3, 4, 5};
    int[] arr2 = {1, 2, 3, 4, 5};
     // 判断两个数组是否相等
    boolean isEqual = Arrays.equals(arr1, arr2);
    System.out.println("判断两个数组是否相等:"+isEqual); // 输出: true
    // 将数组全部元素替换成0
    Arrays.fill(arr, 3); 
    System.out.println("将数组全部元素替换成3:"+Arrays.toString(arr));
    // 将数组转换为List集合
    List<Integer> list = Arrays.asList(arr); 
    System.out.println("将数组转换为List集合:"+list);
  }
}

输出结果：


文章标签：
Java
关键词：
Map方法
Map集合
Map集合方法
Map collections
孤留光乩
目录
相关文章
WK
|
12天前
|
Python
Python中format_map()方法
在Python中，`format_map()`方法用于使用字典格式化字符串。它接受一个字典作为参数，用字典中的键值对替换字符串中的占位符。此方法适用于从字典动态获取值的场景，尤其在处理大量替换值时更为清晰和方便。
WK
65 36
刘大猫.
|
22天前
|
存储 JavaScript 前端开发
《进阶篇第8章：vuex》包括理解vuex、安装vuex、搭建vuex环境、四个map方法的使用、模块化+名命空间
《进阶篇第8章：vuex》包括理解vuex、安装vuex、搭建vuex环境、四个map方法的使用、模块化+名命空间
刘大猫.
16 3
刘大猫.
|
30天前
|
Java
vue2知识点：vuex中四个map方法的使用，包括：mapState、mapGetters、mapMutations、mapActions
vue2知识点：vuex中四个map方法的使用，包括：mapState、mapGetters、mapMutations、mapActions
刘大猫.
77 1
游客j4mujezz7vm7y
|
2月前
|
Go 定位技术 索引
Go 语言Map(集合) | 19
Go 语言Map(集合) | 19
游客j4mujezz7vm7y
36 4
光明顶阳顶天
|
2月前
|
存储 JavaScript 前端开发
`forEach()`方法和`map()`方法哪个执行效率更高？
`forEach()`方法和`map()`方法哪个执行效率更高？
光明顶阳顶天
30 1
周一同学Zelina
|
2月前
|
存储 前端开发 API
ES6的Set和Map你都知道吗？一文了解集合和字典在前端中的应用
该文章详细介绍了ES6中Set和Map数据结构的特性和使用方法，并探讨了它们在前端开发中的具体应用，包括如何利用这些数据结构来解决常见的编程问题。
周一同学Zelina
23 0
ES6的Set和Map你都知道吗？一文了解集合和字典在前端中的应用
花非花雾非雾11
|
2月前
|
JavaScript 前端开发
JavaScript Array map() 方法
JavaScript Array map() 方法
花非花雾非雾11
28 4
最好zzz
|
1月前
|
存储 分布式计算 Java
Stream很好，Map很酷，但答应我别用toMap()：Java开发中的高效集合操作
在Java的世界里，Stream API和Map集合无疑是两大强大的工具，它们极大地简化了数据处理和集合操作的复杂度。然而，在享受这些便利的同时，我们也应当警惕一些潜在的陷阱，尤其是当Stream与Map结合使用时。本文将深入探讨Stream与Map的优雅用法，并特别指出在使用toMap()方法时需要注意的问题，旨在帮助大家在工作中更高效、更安全地使用这些技术。
最好zzz
36 0
光明顶阳顶天
|
2月前
数组方法中的`forEach()`方法和`map()`方法有什么区别？
数组方法中的`forEach()`方法和`map()`方法有什么区别？
光明顶阳顶天
30 0
杀死一只知更鸟debug
|
2月前
|
JavaScript 前端开发
JavaScript 中 五种迭代数组的方法 every some map filter forEach
本文介绍了JavaScript中五种常用数组迭代方法：every、some、filter、map和forEach，并通过示例代码展示了它们的基本用法和区别。
杀死一只知更鸟debug
21 0