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

目录

一.Map集合简介

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

1.特点和方法：

2.遍历方式

代码展示

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

四.泛型的作用 

五.Treemap排序

按照自然顺序排序

六. LinkedHashMap排序

按照插入顺序排序

七.WeakHashMap弱引用

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

 八.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.将集合中的元素进行复制到另一个集合

九.Arrays的使用 

1.数组排序--升序

2.对数组进行降序排序

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

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

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

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

7.将数组转换为List集合

---

一.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);
	}

}

输出结果：