java双列集合

两分z

已于 2023-03-25 11:28:59 修改

阅读量74

点赞数

文章标签： java jvm 开发语言 Powered by 金山文档

于 2023-03-25 11:19:31 首次发布

本文链接：https://blog.csdn.net/qq_58677820/article/details/129762962

版权

文章详细介绍了Java中的Map接口，包括其键值对的概念、常用API如put、remove、containsKey等，以及HashMap、LinkedHashMap和TreeMap三个主要实现类的特点。HashMap是无序且不重复的，而LinkedHashMap保持插入顺序，TreeMap则按特定排序规则存储。文章还展示了不同遍历Map的方式和使用lambda表达式的示例。

摘要由CSDN通过智能技术生成

键值一一对应关系，名称：键值对，键值对对象，Entry对象

键不能重复，值可以重复

Map

常用api

put(K key,V value) 添加键值对

remove （object key）根据键删除键值对

clear( ) 移除所有键值对

Boolean containsKey（object key）判断是否包含指定键

Boolean containsValue（object value）判断是否包含指定值

Boolean isEmpty（）判断是否为空

int size（）集合的长度

public class h {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,Integer> map=new HashMap<>();

        map.put("张三",123);
        map.put("李四",234);
        map.put("王五",345);

        System.out.println(map);//{李四=234, 张三=123, 王五=345}

        //添加重复键值对会把原来的覆盖，并返回原来的值
        System.out.println(map.put("李四",165165));//234
        System.out.println(map);//{李四=165165, 张三=123, 王五=345}

        //remove删除键值对后返回原来的值
        System.out.println(map.remove("李四"));//165165
        System.out.println(map);//{张三=123, 王五=345}

        //若键值对不存在则返回null
        System.out.println(map.remove("李四"));//null
        System.out.println(map.put("李四",165165));//null
    }
}

Map遍历方式

键找值

先将所有键返回到一个单列集合，再通过单列集合的遍历方式遍历

public class h {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,Integer> map=new HashMap<>();

        map.put("张三",123);
        map.put("李四",234);
        map.put("王五",345);

        System.out.println(map);//{李四=234, 张三=123, 王五=345}

        //获取所有键
        Set<String> keys = map.keySet();

        for (String key:keys){
            System.out.println(map.get(key));//234 123 345
        }
    }
}

键值对

public class h {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,Integer> map=new HashMap<>();

        map.put("张三",123);
        map.put("李四",234);
        map.put("王五",345);

        Set<Map.Entry<String, Integer>> entries = map.entrySet();

        for (Map.Entry<String, Integer> entry : entries) {
            System.out.println(entry);//李四=234 张三=123 王五=345
        }
    }
}

lambda表达式

public class h {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,Integer> map=new HashMap<>();

        map.put("张三",123);
        map.put("李四",234);
        map.put("王五",345);

        map.forEach((key,value)->
            System.out.println(key+"="+value)李四=234 张三=123 王五=345
        );
    }
}

HashMap

无序，不重复，无索引

底层数据结构和HashSet基本相同，区别为加入重复元素，HashSet是丢弃，HashMap是覆盖

LinkedHashMap

无序，不重复，无索引

底层数据结构和HashMap基本相同，区别为多个双链表记录存储顺序

TreeMap

可排序，不重复，无索引

底层数据结构和TreeSet基本相同，为红黑树

默认按键的升序排列

public class h {
    public static void main(String[] args) {
        //创建集合对象
        //Ctrl+P 查看可传入的参数
        TreeMap<Integer,String> map=new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //升序
                return o1-o2;
            }
        });

        map.put(123,"张三");
        map.put(234,"李四");
        map.put(345,"王五");

        System.out.println(map);//{123=张三, 234=李四, 345=王五}
    }
}

public class h {
    public static void main(String[] args) {
        //创建集合对象
        TreeMap<Integer,String> map=new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //降序
                return o1-o2;
            }
        });

        map.put(123,"张三");
        map.put(234,"李四");
        map.put(345,"王五");

        System.out.println(map);//{345=王五, 234=李四, 123=张三}
    }
}

Collections

public class h {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list,1,2,6,11,7,2,6,4,8,9,4,9,1);
        System.out.println(list);//[1, 2, 6, 11, 7, 2, 6, 4, 8, 9, 4, 9, 1]
        Collections.sort(list);
        System.out.println(list);//[1, 1, 2, 2, 4, 4, 6, 6, 7, 8, 9, 9, 11]
    }
}