Map集合_Java

一、Map集合的特点以及遍历方式

二、案例：统计字符串中各字母出现的次数

三、关于泛型

四、工具类

一、Map集合的特点以及遍历方式

首先我们还是定义一个Map集合，并且为它加入数据：

        //定义一个Map集合
       Map map = new HashMap<>();

       //添加
       map.put("a", 1);
       map.put("b", 2);
       map.put("c", 3);
       map.put("d", 4);
       map.put("e", 5);

我们再依次写上删除、修改、与查询单个的方法：

        //打印
       System.out.println("❀❀❀❀打印Map集合❀❀❀❀n"+map+"n");
       //删除
       Object remove = map.remove("e");
       //打印
       System.out.println("❀❀❀❀删除后❀❀❀❀n"+map+"n");
       //修改
       map.put("d", 9);
       //打印
       System.out.println("❀❀❀❀修改后❀❀❀❀n"+map+"n");

       //查询单个
       System.out.println("❀❀❀❀查询单个❀❀❀❀n"+map.get("a")+"n");

我们来看看执行后的结果：

我们再来看看循环遍历的两种方法：

一、通过键拿到值：

        //1、先拿到map集合中的所有key
       //2、通过拿到的键获取所有值
       Set keys = map.keySet();//拿到所有的键key
       //循环遍历

System.out.println("❀❀❀❀查询所有【通过键拿到值】❀❀❀❀");
       for (Object key : keys) {
           //通过键拿到值
           System.out.println("键："+key+"t值："+map.get(key));
       }

二、通过映射关系：

        //1、先拿到映射关系
       Set> entrySet = map.entrySet();

        System.out.println("❀❀❀❀查询所有【通过映射关系】❀❀❀❀");
       for (Entry entry : entrySet) {
           System.out.println("键："+entry.getKey()+"t值："+entry.getValue());
       }

执行结果如下：

然后其实除了HashMap之外还有一个Hashtable，我们来看看：

        //Hashtable
		Hashtable ht = new Hashtable<>();
		//public synchronized V put(K key, V value)
		
        //Hashmap
		//定义一个Map集合
		Map map = new HashMap<>();
		//V put(K key, V value)

我们可以看到，Hashtable的put方法里比Hashmap多了一个synchronized，要更加安全。

由上面的代码实操我们可以得到Hashmap的一些特点与结论：

二、案例：统计字符串中各字母出现的次数

好啦，这里有一个案例：统计一个字符串中每个字母出现的次数；

我们一起来看看吧：

首先，我们来理一下它的实现思路：

稍微理一下思路后我们就一起来探索一下吧！

首先我们需要创建一个字符串：

        //创建一个字符串
		String str = "woxihuannihahahanixihuanwoma";

切割成字符数组：

        //切割
		char[] arr = str.toCharArray();

定义一个Map集合并且循环遍历字符数组arr判断：

		//定义一个map集合
		Map map = new TreeMap<>();//用TreeMap可以按字母排序
		//循环遍历
		for (char c : arr) {
			Integer value = map.get(c);
			if(value == null) {
				map.put(c, 1);
			}
			else {
				map.put(c, value+1);
			}
		}

拿到映射关系，并且循环遍历出它的出现次数：

		//拿到映射关系
		Set> entrySet = map.entrySet();
		//循环遍历
		for (Entry entry : entrySet) {
			System.out.println(entry.getKey()+"t出现的次数:t"+entry.getValue());
		}

我们来看看它的执行结果：可以发现字符串中的字母也是排好序的！

需求2：按照出现次数的大小来排序：

将原来的遍历的for循环注释，换成这样写：

   		Stream> sorted = 
        map.entrySet().stream().sorted((x,y)-> x.getValue() - y.getValue());
		sorted.forEach(System.out::println);

注意：要写在循环判断的后面！

执行结果：

三、关于泛型

我们还是一样的，在了解泛型前咱们先来创建一个Set集合并存好数据：

        //定义Set
       Set set = new HashSet<>();
       //存值
       set.add(1);
       set.add(2);
       set.add(3);
       set.add(4);
       set.add(5);

OK，假如我们现在需要拿出集合中所有的偶数，那我们先来取得所有偶数：

        System.out.println("❀❀❀❀偶数❀❀❀❀");
		
		//循环
		for (Object obj : set) {
			//判断是否是偶数
			if(Integer.valueOf(obj.toString()) % 2 == 0) {
				//打印
				System.out.println(obj);
			}
		}

我们执行一下：

好啦，可以看到我们已经能够成功拿到集合里面的所有偶数，

但是此时如果往集合中加入一个非数字的内容：

set.add("a");

我们可以看到并没有报错

然后执行：

我们看到这边已经报错了：java.lang.NumberFormatException: For input string: "a"

原因就是我们在下面这个位置使用了Integer类型转换，而添加的数据不是整型，所有转换错误。

而当我们在定义Set集合的时候就定义好泛型的话就会提前报错：

//定义Set
Set set = new HashSet<>();

这个时候我们再添加一下非整型数据：

这个时候就可以看到已经在编译的时候就报错了。

由以上代码实操我们可以得到一些关于泛型的结论：

四、工具类 4.1 集合之间的相互转换

4.1.1 定义一个字符串数组：

//定义一个字符串数组
String[] arr = {"a","b","c","d"};

4.1.2 转为List

//转为List【依然还是数组】
List ls = Arrays.asList(arr);

4.1.3 打印验证

//打印验证
System.out.println(ls);

我们可以发现还是数组！

直接添加元素：

//ls.add("e");

我们发现还是会报错：java.lang.UnsupportedOperationException

所以我们可以得到集合相互转换的结论：

4.2 工具类其他方法的应用：排序

我们首先来看看普通的String类型的List集合排序：

1、定义一个List集合并添加好数据：

        //定义List集合
       List ls = new ArrayList<>();
       //存值
       ls.add("e");
       ls.add("b");
       ls.add("a");
       ls.add("d");
       ls.add("c");

我们将它排序：

Collections.sort(ls);

打印测试：

我们可以清楚的看到对比，排序成功。

而当我们想逆向排序的时候就需要用到比较器改变它默认的排序规矩了：

		//改变排序规则
		//这里的x、y指的是集合中的元素
		Collections.sort(ls, (x,y) -> y.compareTo(x));
		System.out.println("改变排序规则后："+ls);

我们执行：可以发现也成功了！

OK，String类型的排序就看到这里啦，接下来我们来看看对象怎么排序：

既然是对象，自然就要先来创建一个对象了：

注意：需要对象实现Comparable<>接口

//创建一个对象
class Ren implements Comparable {
	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public Ren() {
		
	}
	public Ren(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	@Override
	public int compareTo(Ren o) {
		return o.getName().compareTo(this.name);
	}
	
	@Override
	public String toString() {
		return "Ren [name=" + name + ", age=" + age + "]";
	}
	
}

然后老规矩：定义List集合、存值。

        //定义List集合
       List ls = new ArrayList<>();
       //存值
       ls.add(new Ren("e", 15));
       ls.add(new Ren("b", 15));
       ls.add(new Ren("a", 15));
       ls.add(new Ren("d", 15));
       ls.add(new Ren("c", 15));

排序：

       //排序
       Collections.sort(ls);

       System.out.println("排序后：t"+ls);

执行结果：

执行成功，排序OK！

我们再看看一个集合的升序降序：

定义：

Integer[] arr = {2,0,0,3,1,2,1,7};

升序：

		//升序
		String sx = Arrays.toString(arr);

降序：

		//降序
		Arrays.sort(arr, (x,y)-> y-x);

打印测试：

System.out.println(Arrays.toString(arr));

执行结果：

好啦OK，今天Leaf带来的学习分享就到这里啦！！！

咱们下次再见~

Map集合

Java相关栏目本月热门文章