devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

J2EE基础：集合框架之Map_java set> entrys = map.e

作者：你好赵伟 | 2024-04-17 17:38:55

赞

踩

java set> entrys = map.entryset();

目录

一.特点

1.增删改查

2.键值对形式存在

3.key可以为空

二.遍历方式

1.entrySet

2.keySet

 三.常用实现类HashMap

1.面试题：统计字符串个字母出现的次数

2.怎么能够按字符进行排序

3.debugger的使用：调试代码 

 四.泛型

1.作用

2.泛型

3.泛型方法

五.集合框架工具类

1.Collections 集合

2.Arrays 数组

面试题：

 解决方案：

2.2：对于这个集合而言，集合也是可以转换为数组的toArray

一.特点

1.增删改查

  1. package com.jiangwenjuan.map;
  2.  
  3.  
  4. import java.util.Map;
  5. import java.util.Set;
  6.  
  7. /**
  8.  * 	map集合的特点
  9.  *
  10.  * @author JWJ
  11.  *
  12.  * @date 2022年6月9日 上午11:26:38
  13.  */
  14. public class Demo1 {
  15. 	public static void main(String[] args) {
  16. 		
  17. 		
  18. 		Map<String,Integer> map = new HashMap<>();
  19. //		增加
  20. //		 V put(K key, V value);
  21. 		map.put("a", 1);
  22. 		map.put("b", 2);
  23. 		map.put("c", 3);
  24. 		map.put("d", 4);
  25. 		System.out.println(map);
  26. //		删除
  27. 		Object remove = map.remove("b");		
  28. 		System.out.println("被删除的"+remove);
  29. 		System.out.println(map);
  30. //		修改也是调用put方法
  31. 		map.put("c", 32);
  32. 		System.out.println("修改出来的结果："+map);
  33. 		
  34. //		查询
  35. 		System.out.println(map.get("c"));
  36. 		
  37. 		
  38. 		
  39. 		
  40. 	}
  41.  
  42. }

结果为：

 

2.键值对形式存在

Map的里面的put的方法,具备添加的功能也具备修改的功能

  1. Map:
  2.     Map<String,Integer> map = new HashMap<>();
  3. //    增加：
  4.     map.put("a",1);
  5.     //        键       值
  6.     // V put(K key, V value);
  7.  
  8. Hashtable:
  9.       Hashtable<Object, Object> table = new Hashtable<>();
  10. //    增加      
  11. 	    table.put("a", 1);
  12. //                                键       值
  13. //    public synchronized V put(K key, V value)

3.key可以为空

在jdk1.8以下hashtable的key不能存放null

  1. package com.jiangwenjuan.map;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Hashtable;
  5. import java.util.Map;
  6. import java.util.Map.Entry;
  7. import java.util.Set;
  8.  
  9. /**
  10.  * 	map集合的特点
  11.  * 		键值对
  12.  *
  13.  * @author JWJ
  14.  *
  15.  * @date 2022年6月9日 上午11:26:38
  16.  */
  17. public class Demo1 {
  18. 	public static void main(String[] args) {
  19. 		Hashtable<Object, Object> table = new Hashtable<>();
  20. //		 public synchronized V put(K key, V value)
  21. 		table.put("a", 1);
  22. 		table.put("null", null);
  23. 		
  24. 		
  25. 		Map<String,Integer> map = new HashMap<>();
  26. //		增加
  27. //		 V put(K key, V value);
  28. 		map.put("a", 1);
  29. 		map.put("b", 2);
  30.         map.put("null",2);
  31. 		map.put("c", 3);
  32. 		map.put("d", 4);
  33. 		System.out.println(map);
  34. 		
  35. 	}
  36.  
  37. }

二.遍历方式

1.entrySet

2.keySet

区别1：注意：Hashtable有同步方法的，相较比较安全

  1. Hashtable<Object, Object> table = new Hashtable<>();
  2.  
  3. //		 public synchronized V put(K key, V value)

 区别2：而注意：HashMap没有，相对不安全

  1. 	Map<String,Integer> map = new HashMap<>();
  2.  
  3. //		 V put(K key, V value);

面试题：HashMap与Hashtable的区别：1.Hashtable是线程安全的

  1. package com.jiangwenjuan.map;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Hashtable;
  5. import java.util.Map;
  6. import java.util.Map.Entry;
  7. import java.util.Set;
  8.  
  9. /**
  10.  * 	map集合的特点
  11.  * 		键值对
  12.  * 		遍历：
  13.  * 			拿到key：再拿值
  14.  * 			拿到映射关系：键值都有了
  15.  * 
  16.  * @author JWJ
  17.  *
  18.  * @date 2022年6月9日 上午11:26:38
  19.  */
  20. public class Demo1 {
  21. 	public static void main(String[] args) {
  22. 		Hashtable<Object, Object> table = new Hashtable<>();
  23.         //注意：Hashtable有synchronized同步方法,相较比较安全
  24.  
  25. //		 public synchronized V put(K key, V value)
  26. 		table.put("a", 1);
  27. //		table.put("null", null);
  28. 		
  29. 		
  30. 		Map<String,Integer> map = new HashMap<>();
  31. //		增加
  32.         //注意：HashMap没有，相对不安全
  33.  
  34. //		 V put(K key, V value);
  35. 		map.put("a", 1);
  36. 		map.put("b", 2);
  37. 		map.put("null",2);
  38. 		map.put("c", 3);
  39. 		map.put("d", 4);
  40. 		System.out.println(map);
  41.  
  42. 		
  43. //		查询所有
  44. //		第一种方式：先拿到map集合中的所以的key
  45. 		Set keys = map.keySet();
  46. 		for (Object key : keys) {
  47. 			System.out.println("键："+key+";值："+map.get(key));
  48. 		}
  49. 		System.out.println("===============");
  50. 		
  51. //		第二种方式：拿到映射关系
  52. 		Set<Entry<String,Integer>> entrySet = map.entrySet();
  53. 		for (Entry<String, Integer> entry : entrySet) {
  54. 			System.out.println("键："+entry.getKey()+";值："+entry.getValue());
  55. 		}
  56. 	}
  57.  
  58. }

结果为：

 三.常用实现类HashMap

1.面试题：统计字符串个字母出现的次数

String s="sjflajlfjalewfjwjelkfjwlkefjlkwajflajljfl";

需要一个Map容器,比如这张图：

实现思路：

        1.做字符串切割，得到一个字符数组
        2.接下来遍历，拿到单个字符
        3.如果该字符没有出现过，即value值为null,那么该字符为key，值初始化为1
        4.如果已经出现过，拿到原来的值+1

代码块：

  1. package com.jiangwenjuan.map;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Map.Entry;
  6. import java.util.Set;
  7.  
  8. public class Demo2 {
  9. 	public static void main(String[] args) {
  10. 		String s="sjflajlfjalewfjwjelkfjwlkefjlkwajflajljfl";
  11.  
  12. 		
  13. 		char[] arr = s.toCharArray();
  14. 		Map<Character, Integer> map = new HashMap<Character, Integer>();
  15. 		for (char c : arr) {
  16. 			Integer value = map.get(c);
  17. 			if(value == null) {
  18. 				map.put(c, 1);
  19. 			}
  20. 			else {
  21. 				map.put(c, value+1);
  22. 			}
  23. //			System.out.println(value);
  24. 			
  25. 		}
  26. 		Set<Entry<Character,Integer>> entrySet = map.entrySet();
  27. 		for (Entry<Character, Integer> entry : entrySet) {
  28. 			System.out.println(entry.getKey()+":"+entry.getValue());
  29. 		}
  30. 	}
  31.  
  32. }

 运行代码块结果：

2.怎么能够按字符进行排序

直接改map集合

Map<Character, Integer> map = new TreeMap<>();

 结果为：

3.debugger的使用：调试代码 

       1.打断点 双击即可
      2.采用debugger的方式运行程序

3.进入调试窗口，左上方有一个step over调试箭头，快捷键F6

这里下一步，下一步就一个一个字符出现的出现.
 4.接下来可以通过F6一步步调试当前程序对应的每一个变量值 

 四.泛型

1.作用

        ①.将运行时产生的异常转换为编译期的错误什么意思：下面讲解

          ②.提高代码的健壮性

当这行代码你还没有运行时是：之前：不健壮的代码，会在运行时才会把错误暴露出来

加上Set<Integer> set = new HashSet<>();就会直接告诉你不能加入字符串，因为是整数

  1. Set<Integer> set = new HashSet<>();
  2.         set.add(1);
  3. 		set.add(2);
  4. 		set.add(3);
  5. 		set.add(4);
  6. 		set.add(5);
  7. 		set.add("a");
  1. package com.jiangwenjuan.map;
  2.  
  3. import java.util.HashSet;
  4. import java.util.Set;
  5.  
  6. /**
  7.  * 	泛型
  8.  * 	
  9.  * @author JWJ
  10.  *
  11.  * @date 2022年6月9日 下午8:12:53
  12.  */
  13. public class Demo3 {
  14. 	public static void main(String[] args) {
  15. 		Set set = new HashSet<>();
  16. 		set.add(1);
  17. 		set.add(2);
  18. 		set.add(3);
  19. 		set.add(4);
  20. 		set.add(5);
  21. 		set.add("a");
  22. 		for (Object obj : set) {
  23. 			if(Integer.valueOf(obj.toString()) % 2 == 0) {
  24. 				System.out.println(obj);
  25. 			}
  26. //			set.remove(obj);//出错
  27. 		}
  28. 	}
  29.  
  30. }

当你运行的时候结果出来时：之后：将潜在的问题暴露出来，早预防早治疗 

2.泛型

        ①.通用的增删改查

之前我们就是要在BookDao里面写很多增删改查方法，现在只要写一个方法即可通用

下面这些就是泛型的作用

  1. class BookDao{
  2. //	add(Bokk book)
  3. //	add(Bokk book)
  4. //	add(Bokk book)
  5. //	add(Bokk book)
  6. }
  7. class UserDao extends BaseDao{
  8. 	
  9. }
  10. class BaseDao<T>{
  11. 	void add(T t) {
  12. 		
  13. 	}
  14. 	void del(T t) {
  15. 			
  16. 		}
  17. 	void edit(T t) {
  18. 		
  19. 	}
  20. 	List<T> list(T t) {
  21. 		return null;
  22. 	}
  23. 	
  24. }

3.泛型方法

        ②.通用结果集处理

当Result 的类没有任何的这个 <T> 你又想添加一个方法，怎么加呢,

就在前面加<T> 这就是泛型方法

  1. class Result{
  2. 	<T> void del(T t) {
  3. 		
  4. 	}
  5. }

五.集合框架工具类

1.Collections 集合

        ①.排序
        ②.集合转数组：toArray

2.Arrays 数组

        ①.toString

        ②.asList  数组可以转换为集合

         ③.sort

面试题：

arr是数组，数组长度是不可变的，然后把它转为list,list集合的长度是可变的，这个list集合本身到底是集合还是数组，list能用集合的方法，但是会报错。

你把arr工具类转换成list集合，它底层还是一个数组，数组长度是不可变的，所以说你往这个数组里面在加一个元素，是没有用的，加不了

  1. package com.jiangwenjuan.map;
  2.  
  3. import java.util.Arrays;
  4. import java.util.List;
  5.  
  6. /**
  7.  * 集合之间的相互转换
  8.  * @author JWJ
  9.  *
  10.  * @date 2022年6月9日 下午8:40:15
  11.  */
  12. public class Demo4 {
  13. 	public static void main(String[] args) {
  14. //		数据长度是不可变的
  15. 		String[] arr = {"a","b","c","d"};
  16. //		list长度是可变的
  17. 		List<String> list = Arrays.asList(arr);
  18. 		list.add("e");
  19. //		java.lang.UnsupportedOperationException
  20. 		System.out.println(list.size());
  21. 	}
  22.  
  23. }

就会出错：

 解决方案：

        集合之间的相互转换：

          1.数组转成集合：本质上依然是一个数组，长度是不可变的

          2.集合与数组所具备的方法是不一样的，如对于数组而言，就没有判断内部包含哪个元素

解释：

把数组转换成一个集合，它本质上依然是一个数组，只不过你可以利用集合的方式去操作这个数组，因为集合里面有很多的方法，比如说：String element = list.add(index, element); 方法，这个在数组里面就没有

2.2：对于这个集合而言，集合也是可以转换为数组的toArray

  1. 数据长度是不可变的
  2. 		String[] arr = {"a","b","c","d"};
  3. //		list长度是可变的
  4. 		List<String> list = Arrays.asList(arr);
  5. 		//转换为数组
  6. 		Object[] array = list.toArray();

     ①.Collections的自带排序及sort代码：

  1. package com.jiangwenjuan.map;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  6.  
  7. /**
  8.  *	 对于工具类其他方法的应用
  9.  * 	sort
  10.  * 	toString
  11.  * @author JWJ
  12.  *
  13.  * @date 2022年6月9日 下午9:05:49
  14.  */
  15. public class Demo5 {
  16. 	public static void main(String[] args) {
  17. 		List<String> list = new ArrayList<>();
  18. 		list.add("b");
  19. 		list.add("c");
  20. 		list.add("a");
  21. 		System.out.println(list);
  22. //		自带排序规则
  23. 		Collections.sort(list);
  24. 		System.out.println("排序"+list);
  25. //		改变排序
  26. //		这里面x,y指的是集合中的元素
  27. 		Collections.sort(list, (x,y)-> y.compareTo(x) );
  28. 		System.out.println("倒序排序"+list);
  29. 	}
  30.  
  31. }

结果为：

排序代码块：

这行就会报错：什么原因呢？

Collections.sort(list);
  1. package com.jiangwenjuan.map;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  6.  
  7. /**
  8.  *	 对于工具类其他方法的应用
  9.  * 	sort
  10.  * 	toString
  11.  * @author JWJ
  12.  *
  13.  * @date 2022年6月9日 下午9:05:49
  14.  */
  15. public class Demo5 {
  16. 	public static void main(String[] args) {
  17. 		
  18. 		List<Person> list = new ArrayList<>();
  19. 		list.add(new Person("b", 16));
  20. 		list.add(new Person("c", 18));
  21. 		list.add(new Person("a", 20));
  22. 		System.out.println(list);
  23. 		Collections.sort(list);
  24. 		
  25. 	}
  26.  
  27. }
  28. class Person{
  29. 	private String name;
  30. 	private int age;
  31. 	public Person() {
  32. 		// TODO Auto-generated constructor stub
  33. 	}
  34. 	@Override
  35. 	public String toString() {
  36. 		return "Person [name=" + name + ", age=" + age + "]";
  37. 	}
  38. 	public Person(String name, int age) {
  39. 		super();
  40. 		this.name = name;
  41. 		this.age = age;
  42. 	}
  43. 	public String getName() {
  44. 		return name;
  45. 	}
  46. 	public void setName(String name) {
  47. 		this.name = name;
  48. 	}
  49. 	public int getAge() {
  50. 		return age;
  51. 	}
  52. 	public void setAge(int age) {
  53. 		this.age = age;
  54. 	}
  55. }

 怎么解决呢?

用昨天的方法：Person实现Comparable<>方法,然后在重写

  1. class Person implements Comparable<Person>{
  2. 	private String name;
  3. 	private int age;
  4.  
  5.     @Override
  6. 	public int compareTo(Person o) {
  7. 		// TODO Auto-generated method stub
  8. 		return o.getName().compareTo(this.name);
  9. 	}
  10. }

结果为：

 可不可以不实现Comparable<>，可以，怎么不实现呢，调用下一个方法：

  1. Collections.sort(list, (x,y)-> x.getName().compareTo(y.getName()));
  2. 		System.out.println("排序:"+list);

结果为：

 降序排序与升序的排序：

  1. Integer[] arr = {3,6,9,2,5,8};
  2. //		降序排序
  3. 		Arrays.sort(arr, (x,y)-> y-x);
  4. //		升序排序
  5. //		Arrays.sort(arr);
  6. 		System.out.println("默认地址:"+arr);
  7. 		System.out.println("排序："+Arrays.toString(arr));

结果为：

        降序：

降序排序：[9, 8, 6, 5, 3, 2]

          升序：

排序：[2, 3, 5, 6, 8, 9]

案例：按照字符出现的次数进行排序-->想按照map中的值进行比较然后排序

分析：

      1.拿到值有两种方式--->①.map.get(key)  ②.entry.getvalue();

        2.要进行排序，那么就需要定义排序规则，实现java.util.comparator接口  （x,y）-> x/y必须拿到map集合中的value        x可以是map集合本身，也可以是entry

        3.x怎么做到，代表是entry-->当list集合中放entry，那么x就代表entry

实现思路:

        1.将map集合转成list集合，并且list集合中的元素是entry

        2.针对list集合进行排序

ctrl+shift+o:快速导包

  1. Set<Entry<Character,Integer>> entrySet2 = map.entrySet();
  2. //		把map集合转换成list
  3. 		List<Entry<Character, Integer>> list = new ArrayList<>(entrySet2);
  4. 		
  5. 		System.out.println(map);
  6. 		System.out.println(list);
  7. 		
  8. 		Collections.sort(list, (x,y)->x.getValue() - y.getValue());
  9. 		System.out.println(list);

结果： 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/441412
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号