详解Java LinkedHashMap与HashMap的使用

目录

HashMap存储自定义类型键值LinkedHashMapMap集合练习JDK9对集合添加的优化

HashMap存储自定义类型键值

练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。
注意，学生姓名相同并且年龄相同视为同一名学生。
编写学生类：

1. public class Student {
2.     private String name;
3.     private int age;
5.     public Student() {
6.     }
8.     public Student(String name, int age) {
9.         this.name = name;
10.         this.age = age;
11.     }
13.     public String getName() {
14.         return name;
15.     }
17.     public void setName(String name) {
18.         this.name = name;
19.     }
21.     public int getAge() {
22.         return age;
23.     }
25.     public void setAge(int age) {
26.         this.age = age;
27.     }
29.     @Override
30.     public boolean equals(Object o) {
31.         if (this == o)
32.             return true;
33.         if (o == null || getClass() != o.getClass())
34.             return false;
35.         Student student = (Student) o;
36.         return age == student.age && Objects.equals(name, student.name);
37.     }
39.     @Override
40.     public int hashCode() {
41.         return Objects.hash(name, age);
42.     }
43. }

复制代码

编写测试类：

1. public class HashMapTest {
2.     public static void main(String[] args) {
3.         //1,创建Hashmap集合对象。
4.         Map<Student,String>map = new HashMap<Student,String>();
5.         //2,添加元素。
6.         map.put(newStudent("lisi",28), "上海");
7.         map.put(newStudent("wangwu",22), "北京");
8.         map.put(newStudent("zhaoliu",24), "成都");
9.         map.put(newStudent("zhouqi",25), "广州");
10.         map.put(newStudent("wangwu",22), "南京");
12.         //3,取出元素。键找值方式
13.         Set<Student>keySet = map.keySet();
14.         for(Student key: keySet){
15.             Stringvalue = map.get(key);
16.             System.out.println(key.toString()+"....."+value);
17.         }
18.     }
19. }

复制代码

当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。

LinkedHashMap

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？ 在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

1. public class LinkedHashMapDemo {
2.     public static void main(String[] args) {
3.         LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
4.         map.put("青菜", "萝卜");
5.         map.put("红花", "绿叶");
6.         map.put("美景", "佳人");
7.         Set<Entry<String, String>> entrySet = map.entrySet();
8.         for (Entry<String, String> entry : entrySet) {
9.             System.out.println(entry.getKey() + "  " + entry.getValue());
10.         }
11.     }
12. }

复制代码

结果:

青菜  萝卜
红花  绿叶
美景  佳人

Map集合练习

需求： 计算一个字符串中每个字符出现次数。 分析：

获取一个字符串对象创建一个Map集合，键代表字符，值代表次数。遍历字符串得到每个字符。判断Map中是否有该键。如果没有，第一次出现，存储次数为1；如果有，则说明已经出现过，获取到对应的值进行++，再次存储。打印最终结果

代码：

1. public class MapTest {
2. public static void main(String[] args) {
3.         //友情提示
4.         System.out.println("请录入一个字符串:");
5.         String line = new Scanner(System.in).nextLine();
6.         // 定义 每个字符出现次数的方法
7.         findChar(line);
8.     }
9.     private static void findChar(String line) {
10.         //1:创建一个集合 存储  字符 以及其出现的次数
11.         HashMap<Character, Integer> map = new HashMap<Character, Integer>();
12.         //2:遍历字符串
13.         for (int i = 0; i < line.length(); i++) {
14.             char c = line.charAt(i);
15.             //判断 该字符 是否在键集中
16.             if (!map.containsKey(c)) {//说明这个字符没有出现过
17.                 //那就是第一次
18.                 map.put(c, 1);
19.             } else {
20.                 //先获取之前的次数
21.                 Integer count = map.get(c);
22.                 //count++;
23.                 //再次存入  更新
24.                 map.put(c, ++count);
25.             }
26.         }
27.         System.out.println(map);
28.     }
29. }

复制代码

JDK9对集合添加的优化

通常，我们在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。 实例化集合，几个 add方法 调用，使得代码重复。

1. public class Demo01 {
2.     public static void main(String[] args) {
3.         List<String> list = new ArrayList<>();
4.         list.add("abc");
5.         list.add("def");
6.         list.add("ghi");
7.         System.out.println(list);
8.     }
9. }

复制代码

Java 9，添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。 例子：

1. public class HelloJDK9 {  
2.     public static void main(String[] args) {  
3.         Set<String> str1=Set.of("a","b","c");  
4.         //str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合  
5.         System.out.println(str1);  
6.         Map<String,Integer> str2=Map.of("a",1,"b",2);  
7.         System.out.println(str2);  
8.         List<String> str3=List.of("a","b");  
9.         System.out.println(str3);  
10.     }  
11. }

复制代码

需要注意以下两点：
of()方法只是Map，List，Set这三个接口的静态方法，其父类接口和子类实现并没有这类方法，比如    HashSet，ArrayList等待；
返回的集合是不可变的；
到此这篇关于详解Java LinkedHashMap与HashMap的使用的文章就介绍到这了,更多相关Java LinkedHashMap HashMap内容请搜索中国红客联盟以前的文章或继续浏览下面的相关文章希望大家以后多多支持中国红客联盟！