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

简介: 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);
  }
}

输出结果:


相关文章
|
17天前
|
Go 定位技术 索引
Go 语言Map(集合) | 19
Go 语言Map(集合) | 19
|
16天前
|
存储 JavaScript 前端开发
`forEach()`方法和`map()`方法哪个执行效率更高?
`forEach()`方法和`map()`方法哪个执行效率更高?
|
16天前
|
存储 前端开发 API
ES6的Set和Map你都知道吗?一文了解集合和字典在前端中的应用
该文章详细介绍了ES6中Set和Map数据结构的特性和使用方法,并探讨了它们在前端开发中的具体应用,包括如何利用这些数据结构来解决常见的编程问题。
ES6的Set和Map你都知道吗?一文了解集合和字典在前端中的应用
|
26天前
|
JavaScript 前端开发
JavaScript Array map() 方法
JavaScript Array map() 方法
|
5天前
|
存储 分布式计算 Java
Stream很好,Map很酷,但答应我别用toMap():Java开发中的高效集合操作
在Java的世界里,Stream API和Map集合无疑是两大强大的工具,它们极大地简化了数据处理和集合操作的复杂度。然而,在享受这些便利的同时,我们也应当警惕一些潜在的陷阱,尤其是当Stream与Map结合使用时。本文将深入探讨Stream与Map的优雅用法,并特别指出在使用toMap()方法时需要注意的问题,旨在帮助大家在工作中更高效、更安全地使用这些技术。
18 0
|
16天前
数组方法中的`forEach()`方法和`map()`方法有什么区别?
数组方法中的`forEach()`方法和`map()`方法有什么区别?
|
16天前
|
JavaScript 前端开发
JavaScript 中 五种迭代数组的方法 every some map filter forEach
本文介绍了JavaScript中五种常用数组迭代方法:every、some、filter、map和forEach,并通过示例代码展示了它们的基本用法和区别。
|
2月前
|
JavaScript 前端开发 索引
JS中常用的数组迭代方法(filter,forEach,map,every,some,find,findIndex)
这段代码和说明介绍了JavaScript中数组的一些常用方法。函数接收三个参数:`item`(数组项的值)、`index`(项的位置,可选)和`array`(数组本身,可选)。示例展示了如何使用`filter()`过滤非空项、`forEach()`遍历数组、`map()`处理并返回新数组、`every()`检查所有元素是否满足条件、`some()`检查是否存在满足条件的元素、`find()`获取首个符合条件的元素值以及`findIndex()`获取其索引位置。这些方法都不会修改原数组。
JS中常用的数组迭代方法(filter,forEach,map,every,some,find,findIndex)
|
2月前
|
Java
【Java集合类面试二十二】、Map和Set有什么区别?
该CSDN博客文章讨论了Map和Set的区别,但提供的内容摘要并未直接解释这两种集合类型的差异。通常,Map是一种键值对集合,提供通过键快速检索值的能力,而Set是一个不允许重复元素的集合。
|
2月前
|
算法 Java 索引
【Java集合类面试四】、 描述一下Map put的过程
这篇文章详细描述了HashMap中put操作的过程,包括首次扩容、计算索引、插入数据以及链表转红黑树和可能的再次扩容。
【Java集合类面试四】、 描述一下Map put的过程