Java基础——Map集合、HashMap、LinkedHashMap、TreeMap、Collections工具类

最新推荐文章于 2022-05-21 09:16:20 发布

Geek Li

最新推荐文章于 2022-05-21 09:16:20 发布

阅读量121

点赞数 1

分类专栏： Java 文章标签： java 排序算法数据结构

本文链接：https://blog.csdn.net/weixin_43496491/article/details/121534660

版权

Java 专栏收录该内容

63 篇文章 3 订阅

订阅专栏

1.Map集合

Map接口概述:
	将键映射到值的对象
	一个映射不能包含重复的键
	每个键最多只能映射到一个值

Map接口和Collection接口的不同
	Map是双列的,Collection是单列的
	Map的键唯一,Collection的子体系Set是唯一的
	Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

Map集合的功能概述
	a:添加功能 
		V put(K key,V value):添加元素。这个其实还有另一个功能,替换
			如果键是第一次存储，就直接存储元素，返回null
			如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
	b:删除功能
		void clear():移除所有的键值对元素
		V remove(Object key)：根据键删除键值对元素，并把值返回
	c:判断功能
		boolean containsKey(Object key)：判断集合是否包含指定的键
		boolean containsValue(Object value):判断集合是否包含指定的值
		boolean isEmpty()：判断集合是否为空
	d:获取功能
		Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
		V get(Object key):根据键获取值
		Set<K> keySet():获取集合中所有键的集合
		Collection<V> values():获取集合中所有值的集合
	e:长度功能
		int size()：返回集合中的键值对的对数

Map集合的遍历之键找值

package com.xawl.demo;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
/**
 * @Author:liger
 * @Description:爱学Java
 */

public class Test {
    public static void main(String[] args) {
        Map<Integer, String> hashmap = new HashMap<>();
        hashmap.put(1,"貂蝉");
        hashmap.put(2,"吕布");
        hashmap.put(3,"赵云");
        hashmap.put(4,"周瑜");
        hashmap.put(5,"小乔");
        //1.keySet方法
        Set<Integer> integers = hashmap.keySet();
        for (int i = 1; i <=integers.size(); i++) {
            System.out.println(i+"=="+hashmap.get(i));
        }
        System.out.println("**********我是分隔符**********");
        //2.entrySet方法
        for (Map.Entry<Integer, String> hashmap1 : hashmap.entrySet()) {
            System.out.println(hashmap1.getKey()+"==="+hashmap1.getValue());
        }
        System.out.println("**********我是分隔符**********");
        //3.forEach遍历 
        hashmap.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer key, String value) {
                System.out.println(key+"==="+value);
            }
        });
    }
}

HashMap集合键是Student值是String的案例
键唯一注意Student重写hashCode方法和 equals 方法

package com.xawl.demo;

import java.util.HashMap;
import java.util.function.BiConsumer;

/**
 * GEEK
 * @author :LiGer
 */
public class Test {
    public static void main(String[] args) {
//        HashMap集合键是Student值是String的案例
        HashMap<Student, String> hashMap = new HashMap<>();
        hashMap.put(new Student("张飞",20),"学生一");
        hashMap.put(new Student("刘备",24),"学生二");
        hashMap.put(new Student("关羽",45),"学生三");
        hashMap.put(new Student("吕布",37),"学生五");
        hashMap.put(new Student("貂蝉",28),"学生六");
        hashMap.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student key, String value) {
                System.out.println(key+"==="+value);
            }
        });

    }
}

HashMap集合键是String值是Student的案例

package com.xawl.demo;

import java.util.HashMap;
import java.util.function.BiConsumer;

/**
 * GEEK
 * Description:爱学Java
 * @author :LiGer
 */
public class Test2 {
    public static void main(String[] args) {
        HashMap<String, Student> hashMap = new HashMap<>();
        hashMap.put("一",new Student("张三丰",60));
        hashMap.put("二",new Student("杨过",30));
        hashMap.put("三",new Student("小龙女",27));
        hashMap.put("四",new Student("郭靖",50));
        hashMap.forEach(new BiConsumer<String, Student>() {
            @Override
            public void accept(String key, Student value) {
                System.out.println(key+"==="+value);
            }
        });

    }
}

2.LinkedHashMap

LinkedHashMap的概述:	Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。
LinkedHashMap的特点:底层的数据结构是链表和哈希表 元素有序 并且唯一
			元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证
			Map集合的数据结构只和键有关

3.TreeMap

TreeMap 键不允许插入null

 TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性  
	    排序分为自然排序和比较器排序 
	    线程是不安全的效率比较高

TreeMap集合键是Student值是String的案例
按照年龄大小进行排序 ,注意键要实现Comparable 接口
测试类

package com.xawl.demo;

import java.util.TreeMap;
import java.util.function.BiConsumer;
/**
 * GEEK
 * Description:爱学Java
 *
 * @author :LiGer
 */
public class Test3  {
    public static void main(String[] args) {
        TreeMap<Student, String> treeMap = new TreeMap<>();
        treeMap.put(new Student("小乔",24),"英雄一");
        treeMap.put(new Student("周瑜",26),"英雄二");
        treeMap.put(new Student("赵云",28),"英雄三");
        treeMap.put(new Student("刘备",30),"英雄四");
        treeMap.put(new Student("孙尚香",27),"英雄五");
treeMap.forEach(new BiConsumer<Student, String>() {
    @Override
    public void accept(Student key, String value) {
        System.out.println(key+"==="+value);
    }
});
    }
}

学生类

package com.xawl.demo;

import java.util.Objects;

/**
 * GEEK
 *
 * @author :LiGer
 */
 //实现Comparable接口
public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    //重写compareTo方法
    public int compareTo(Student o) {
        int num=o.age-this.age;
        return num;
    }
}

统计字符串中每个字符出现的次数
“aababcabcdabcde”,获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

package com.xawl.demo;

import java.util.HashMap;
import java.util.Scanner;

/**
 * GEEK
 * Description:爱学Java
 * @author :LiGer
 */
public class Test4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String s = sc.nextLine();
        HashMap<Character, Integer> hashMap = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (!hashMap.containsKey(c)){
                hashMap.put(c,1);
            }else{
                hashMap.put(c,hashMap.get(c)+1);
            }
        }
        System.out.println(hashMap);
    }
}

4.集合嵌套

集合嵌套之HashMap嵌套HashMap

代码：

package com.xawl.demo;

import java.util.HashMap;
import java.util.function.BiConsumer;

/**
 * GEEK
 * Description:爱学Java
 * @author :LiGer
 */
public class Test5 {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("张三",20);
        hashMap.put("李四",22);
        HashMap<String, Integer> hashMap2 = new HashMap<>();
        hashMap2.put("王五",21);
        hashMap2.put("赵六",23);
        HashMap<String, HashMap<String, Integer>> hashMapHashMap = new HashMap<>();
        hashMapHashMap.put("2018级",hashMap);
        hashMapHashMap.put("2019级",hashMap2);
        hashMapHashMap.forEach(new BiConsumer<String, HashMap<String, Integer>>() {
            @Override
            public void accept(String s, HashMap<String, Integer> stringIntegerHashMap) {
                System.out.println(s);
                stringIntegerHashMap.forEach(new BiConsumer<String, Integer>() {
                    @Override
                    public void accept(String key, Integer value) {
                        System.out.println("\t"+key+" "+value);
                    }
                });
            }
        });
    }
}

集合嵌套之HashMap嵌套ArrayList

package com.xawl.demo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/**
 * GEEK
 * Description:爱学Java
 * @author :LiGer
 */
public class Test6 {
    public static void main(String[] args) {
        ArrayList<String> arrayList1 = new ArrayList<>();
        arrayList1.add("吕布");
        arrayList1.add("周瑜");
        ArrayList<String> arrayList2 = new ArrayList<>();
        arrayList2.add("令狐冲");
        arrayList2.add("林平之");
        ArrayList<String> arrayList3 = new ArrayList<>();
        arrayList3.add("杨过");
        arrayList3.add("小龙女");
        HashMap<String, ArrayList<String>> hashMap = new HashMap<>();
        hashMap.put("三国演义",arrayList1);
        hashMap.put("笑傲江湖",arrayList2);
        hashMap.put("神雕侠侣",arrayList3);
        hashMap.forEach(new BiConsumer<String, ArrayList<String>>() {
            @Override
            public void accept(String key, ArrayList<String> strings) {
                System.out.println(key);
                strings.forEach(new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println("\t"+s);
                    }
                });
            }
        });
    }
}

在这里插入图片描述
集合嵌套之ArrayList嵌套HashMap

package com.xawl.demo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/**
 * GEEK
 * Description:爱学Java
 * @author :LiGer
 */
public class Test7 {
    public static void main(String[] args) {
        HashMap<String, String> hashMap1 = new HashMap<>();
        hashMap1.put("周瑜","小乔");
        hashMap1.put("吕布","貂蝉");
        HashMap<String, String> hashMap2 = new HashMap<>();
        hashMap2.put("郭靖","黄蓉");
        hashMap2.put("杨过","小龙女");
        HashMap<String, String> hashMap3 = new HashMap<>();
        hashMap3.put("令狐冲","任盈盈");
        hashMap3.put("林平之","岳灵珊");
        ArrayList<HashMap<String, String>> arrayList = new ArrayList<>();
        arrayList.add(hashMap1);
        arrayList.add(hashMap2);
        arrayList.add(hashMap3);

        arrayList.forEach(new Consumer<HashMap<String, String>>() {
            @Override
            public void accept(HashMap<String, String> stringStringHashMap) {
                stringStringHashMap.forEach(new BiConsumer<String, String>() {
                    @Override
                    public void accept(String s, String s2) {
                        System.out.println(s+"---"+s2);
                    }
                });
            }
        });
    }
}

在这里插入图片描述
HashMap和Hashtable的区别：
HashMap: 线程不安全,效率高.允许null值和null键
Hashtable: 线程安全 , 效率低.不允许null值和null键

5.Collections工具类

针对集合操作的工具类

Collections成员方法
	public static <T> void sort(List<T> list):					排序,默认按照自然顺序
	public static <T> int binarySearch(List<?> list,T key):		二分查找
	public static <T> T max(Collection<?> coll):				获取最大值
	public static void reverse(List<?> list):					反转
	public static void shuffle(List<?> list):						随机置换

Geek Li

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java基础——Map集合、HashMap、LinkedHashMap、TreeMap、Collections工具类

1.Map集合Map接口概述: 将键映射到值的对象一个映射不能包含重复的键每个键最多只能映射到一个值Map接口和Collection接口的不同 Map是双列的,Collection是单列的 Map的键唯一,Collection的子体系Set是唯一的 Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效Map集合的功能概述 a:添加功能 V put(K key,V value):添加元素。这个其实还有另一个功能,替换如果键是第一次
复制链接

扫一扫