Java—-双列集合

已于 2023-10-21 15:54:43 修改
阅读量49 收藏
点赞数
文章标签： java
于 2023-10-21 15:52:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62452899/article/details/133696263
版权

Map

键值对（key，value）

new不是new map对象，是new实现类的对象

Map<String,String> map = new HashMap<String,String>();

put会覆盖 以最新的为主

m.put("a","b");
String value=m.put("a","c");
System.out.println(value);  //如果键已经存在，则返回的是原有值b
System.out.println(m);  //而集合里显示最新的c

遍历方式（3种）

一、键找值

//1.把所有的键放到一个单列集合中  
 Set<String> keys=map.keySet();
//2.遍历单列集合，得到每一个键
    for(String key:keys){
        System.out.println(key);
//3.利用map集合中的键获取对应的值
        String value =map.get(key);
        System.out.println(key+" "+value);
    }

二、键值对

获取键值对对象，分别用getKey()和getValue()获取键、值

 Map<String,String> map = new HashMap<String,String>();
        Set<Map.Entry<String, String>> entries = map.entrySet();//map.entrySet()再自动补全即可
        //遍历entries集合，用get方法获取键值(entries调用for循环)
        for (Map.Entry<String, String> entry : entries) {
            String key =entry.getKey();
            String value=entry.getValue();
            System.out.println(key+" "+value);
        }

三、Lambda表达式

HashMap

package Oct18;

import java.util.Objects;

public class Student {
    private String name;
    private int age;
    //右键，ptg to javabean
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.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);
    }

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

法一： 

package Oct18;
import java.util.Set;
import java.util.Map;
import java.util.HashMap;

public class One {
    public static void main(String[] args) {
    //由于学生放在键上，所以要重写hashCode和equals方法
    //创建hashmap对象
    HashMap<Student,String> hm = new HashMap<>();
    //创建三个学生对象
        //ctrl+d向下复制一行
        Student s1 = new Student ("625",21);
        Student s2 = new Student ("cy",20);
        Student s3 = new Student ("小小鸠",3);
    //添加元素
    hm.put(s1,"辽宁");
    hm.put(s2,"湖南");
    hm.put(s3,"江苏");
    //遍历集合
    Set<Student> keys = hm.keySet();
        for (Student key : keys) {
            String value = hm.get(key);
            System.out.println(key+"="+value);

        }

    }

}

 法二：

 Set<Map.Entry<Student, String>> entries = hm.entrySet();
        for (Map.Entry<Student, String> entry : entries) {
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }

法三：

 

结果： 

package Oct18;

import java.util.*;

public class Two {
    public static void main(String[] args) {
        //1.定义四个数组存储四个景点
        String[] arr={"A","B","C","D"};
        //利用随机数模拟80个同学的投票
        ArrayList<String> list=new ArrayList<>();
        Random r=new Random();
        for (int i = 0; i < 80; i++) {
            //在arr的长度内随机生成索引，然后再通过索引找到对应元素
            int index = r.nextInt(arr.length);//随机索引
            System.out.println(arr[index]);//打印同学的投票
            list.add(arr[index]);
        }
            //80个同学投完票了，开始统计
            //string代表景点名称 integer代表景点出现次数
            HashMap<String,Integer> hm =new HashMap<>();
            //hm是hashmap对象；name是临时变量代表景点名；
            for (String name : list) {
                //判断当前景点在map里面是否存在

                if(hm.containsKey(name)){
                    //景点已存在，次数+1
                    //先获取当前景次数
                    int count = hm.get(name);
                    count++;
                    //更新次数
                    hm.put(name,count);
                }
                else{
                //景点不存在，创建景点，次数为一
                hm.put(name,1);
                }
            }
            System.out.println(hm);
        //求哪个景点人最多（那个map里谁的值最大）
        int max =0;
        Set<Map.Entry<String, Integer>> entries = hm.entrySet();
        //这句话Set<>代表集合；每个Map.Entry<>代表一个键值对;<>为泛型。
        //这句话用来获取HashMap hm 中所有键值对的集合，然后后续的代码通过遍历entries集合来处理键值对
        //hm是hashmap对象，hm.entrySet()返回一个包含HashMap中所有键值对（即键和对应的值）的集合
        //entry是一个键值对（Map.Entry），entries是包含所有键值对的集合（Set类型）
        for (Map.Entry<String, Integer> entry : entries) {
            int count = entry.getValue();
            if(count>max){
                max=count;
            }
        }
        System.out.println("最大值是："+max);
        //哪些景点都是最大值，都得打印
        for (Map.Entry<String, Integer> entry : entries) {
            int count = entry.getValue();
            if(count==max){
                System.out.println("投票最多的是："+entry.getKey());
            }

        }

        }

}

LinkHashMap

package Oct18;
import java.util.LinkedHashMap;

public class LinkHashMap {
    public static void main(String[] args) {
        //1.创建集合
        LinkedHashMap<String,Integer> lhm = new LinkedHashMap<>();
        //2.添加元素
        lhm.put("a",123);
        lhm.put("a",123);
        lhm.put("b",456);
        lhm.put("c",789);

    }
}

TreeMap

代码书写两种排序规则如果都写了，则以第二种(Comparator)为准。

默认升序排列

package Oct18;
import java.util.Comparator;
import java.util.TreeMap;

public class TreeMap1 {
    public static void main(String[] args) {
        //改变排序方式：在小括号里，new Comparator（若什么都不写则默认升序）
        TreeMap<Integer,String> tm = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //o1：当前要添加的元素
                // o2：已经在红黑树中存在的元素
                return o1-o2;//升序
                //return o2-o1; 降序
                return 0;
            }
        });
        tm.put(1,"cy");
        tm.put(2,"625");
        tm.put(3,"小小鸠1");
        tm.put(4,"小小鸠2");
        tm.put(5,"小小鸠3");
        System.out.println(tm);



    }
}

TreeMap 

package Oct18;

import java.util.TreeMap;

public class TreeMap2 {
    public static void main(String[] args) {
        TreeMap<Student2,String> tm =new TreeMap<>();
        Student2 s1 =new Student2("625",21);
        Student2 s2 =new Student2("cy",20);
        Student2 s3 =new Student2("小小鸠",3);
        tm.put(s1,"辽宁");
        tm.put(s2,"湖南");
        tm.put(s3,"江苏");
        //要利用Comparable指定打印顺序(姓名年龄一样的为同一个人；升序排列)
        System.out.println(tm);

    }
}

 Student

package Oct18;

public class Student2 implements Comparable<Student2>{
    private String name;
    private int age;


    public Student2() {
    }

    public Student2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student2{name = " + name + ", age = " + age + "}";
    }

    @Override
    public int compareTo(Student2 o) {
        //指定比较规则：姓名年龄一样的为同一个人；升序排列
        //this:当前要添加的
        //o:在红黑树中已存在的元素
        int i=this.getAge()-o.getAge();
        //返回值:
        //正数：当前大，存右边
        //负数：当前小，存右边
        //0：当前已存在，舍弃
        //已存在则按名字排序(i==0)，否则返回i本身(i!=0)
        i=(i==0?this.getName().compareTo(o.getName()):i);
        return i;
    }
}

注意这段方法重写：

结果排序用TreeMap，不要求排序用HashMap

package Oct18;

import java.util.StringJoiner;
import java.util.TreeMap;
import java.util.function.BiConsumer;

public class TreeMap3 {
    public static void main(String[] args) {
        String s="ashdajdknqjbasababab";
        TreeMap<Character,Integer> tm=new TreeMap<>();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            //在循环内，通过 s.charAt(i) 获取字符串's'中索引为i的字符，并将它赋给变量c
            if(tm.containsKey(c)){
                //把原次数拿出来
                int count =tm.get(c);
                //加一
                count++;
                //添加结果
                tm.put(c,count);
            }else{
                tm.put(c,1);
            }
        }
        System.out.println("------------默认排序-----------");
        System.out.println(tm);
        System.out.println("------------StringBulider自定义排序------------");
        //遍历集合，按照指定样式拼接
        StringBuilder sb =new StringBuilder();
        /*tm.forEach(new BiConsumer<Character, Integer>() {
            @Override
            public void accept(Character key, Integer value) {
                sb.append(key).append("(").append(value).append(")");
            }
        });*/
        //简略为Lamda表达式
        tm.forEach((key, value)-> sb.append(key).append("(").append(value).append(")"));
        System.out.println(sb);
        System.out.println("------------StringJoiner自定义排序-------------");
        //要指定开始结束和间隔符号
        StringJoiner sj =new StringJoiner("","","");
        //add后面括号里要为字符串，不是字符串的直接+""即可
        tm.forEach((key, value)-> sj.add(key+"").add("(").add(value+"").add(")"));
        System.out.println(sj);

    }
}

参宿七625
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java-双列集合
weixin_64251178的博客
03-30 175
Map集合遍历
Java中的Map双列集合的基本讲解
gaoqiandr的博客
11-16 853
本文主要介绍的是Java中的Map集合的基本使用，包括他的常用的一些操作API
Java集合进阶——双列集合
最新发布
m0_74808313的博客
04-15 825
⑴方法细节①put 添加数据时若键存在，那么会将被覆盖的值返回⑵常用方法集合中最重要的莫过于增删改查，但是Map中没有定义set(修改元素)的方法但是我们可以put集合的特殊机制进行元素的修改与Map一致。
Java集合之双列集合
qq_52146944的博客
05-07 532
【代码】Java集合之双列集合。
Java 基础之双列集合
hj1993的博客
01-11 684
HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法studentHashMap . put(new Student("rose" , 18) , "北京");studentHashMap . put(new Student("lila" , 19) , "深圳");studentHashMap . put(new Student("john" , 18) , "重庆");return age。
Java双列集合HashMap
12-22
双列集合HashMap是属于java集合框架3大类接口的Map类， Map接口储存一组成对的键-值对象，提供key(键)到value(值)的映射.Map中的key不要求有序，不允许重复.value同样不要求有序，但允许重复. 　Iterator接口是...
Java集合（完整笔记）
05-14
作者在学习过程中自己整理的Java集合笔记，包括开发中常见的单列集合（Collection）和双列集合（Map）以及开发中集合常用的接口，类，以及方法等，适合零基础小白，笔记详细，希望和大家一起学习的道路上我们可以...
JAVA–集合
12-22
集合按照其存储结构可以分为两大类，单列集合java.util.Collection、双列集合java.util.Map 一、Collection Collection集合框架的体系 Collection常用功能 1.public boolean add(E e):把给定的对象添加到集合中 2....
java基础之集合总结
09-05
此文档属于本人当初学习java基础之集合，所整理的文档。里面整理了单列集合Collection与双列集合Map的子类及常用方法。希望对你的学习有帮助，谢谢！
java集合类（新手也能掌握）
12-21
集合按其存储结构可以分为两大类，即单列集合Collection和双列集合Map! 2.Collection接口 Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（List和Set)通用的方法，即： 注：此处列出的方法仅...
Java中的双列集合体系结构（一）
qq_46045392的博客
03-30 181
4、键 + 值这个整体，我们称之为 “ 键值对 ” 或者 “ 键值对对象 ” ，在Java中叫做 “ Entry对象 ”Map是双列集合的顶层接口，它的功能是全部双列集合都可以继承使用的。3、键和值是一 一对应的，每一个键只能找到自己对应的值。1、双列集合一次需要存一对数据，分别为键和值。下面将会讲解Map集合的所有实现类。2、键不能重复，值可以重复。3、Lambda表达式。
Java之双列集合
y_k_j_c的博客
07-26 715
比Set接口常用1.不同于单列集合只传一个对象，双列集合都是传两个对象2.Node类是HashMap的内部类符号表示HashMap$Nodenext把所有的Node元素连接然后对应数组索引可以调用到对应索引的第一个Node元素拿到第一个Node元素相当于后面都有了Node源码3和4.key不能重复，value可以重复，可以重复的话会替换原来key的value5.6.也可以用其他类的对象做key，因为形参是Objectkey7.通过如图。............
Java#29(集合进阶2---双列集合)
guaiwu_的博客
11-30 444
集合进阶2----双列集合(Map)
HashMap的底层原理jdk1.7和jdk1.8的实现的区别
ratel的博客
11-06 1602
HashMap的底层原理jdk1.7和jdk1.8的实现的区别
Java集合——单列集合Collection、双列集合Map
El Psy Congroo
08-30 1676
先来简单介绍一下集合吧。       我们平时想要对多个数据进行操作，初学时可能会想到使用数组来存储数据，这是没错的，但是数组的使用有时候很不便。Java中给了我们可以方便存储对象、对多个对象操作的容器--集合，集合的出现就是为了持有对象。集合中可以存储任意类型的对象，而且长度可变。在程序中有可能无法预先知道需要多少个对象，那么用数组来装的话就可能不知道长度要定义多少，而集合正解决了这样的问题。...
Java基础——单列、双列集合总结
weixin_41933719的博客
01-17 2070
栈：现金后出，入口和出口都是栈顶，存储元素都是吧元素粗出到栈的顶端位置，栈中已有元素一次向栈底方向移动。 队列：先进先出，队列的入口和出丑各占一侧 数组：查找元素快（通过索引可以快速访问指定位置的元素），增删元素慢（需要创建一个新数组，将指定新元素存储在指定索引位置，将新元素复制到指定索引位置/将要删除的元素不复制到新数组中，） 链表：各个节点之间，通过地址进行连接。一个节点存储了指针域（存...
Map---Java双列集合
xjswmgw的博客
09-28 444
------- android培训、java培训、期待与您交流！ ---------- 将Map单独拿出来做笔记是因为他是双列存储的集合，有所不同； 1定义：map集合中存放的是具有映射关系，表示为键值对的形式，同单列Collention一样，map存入的引用类型，所以在定义的时候要注意基本类型的包装方式 2格式：Map map=new HashMap(); 3体系以及子类特点： 1Ma
Java学习—双列集合
qq_40343117的博客
08-04 395
双列集合 Map接口 1、概述 双列集合类似于数据库一些，也是分为键值对，可以通过不同操作进行增删查改等等。 Map是一个将键映射到值的对象 一个映射不能包含重复的键 每个键最多映射到一个值（key=value） Map是双列集合，Collection是单列集合 Map的键是唯一的，Collection中Set是唯一的（元素）。 Map集合的数据结构只针对键有效，跟值无关。（Collection...
java单列集合与双列集合的区别
05-15
Java集合框架中包含了单列集合和双列集合两种类型。 单列集合，也叫做 Collection，存储单个元素。常用的单列集合有 List、Set 和 Queue。它们的区别在于其元素的存储方式和访问方式不同，List 的元素是有序可重复的，Set 的元素是无序不可重复的，Queue 的元素是先进先出的。 双列集合，也叫做 Map，存储键值对。常用的双列集合有 HashMap、TreeMap、LinkedHashMap 等。它们的区别主要在于其内部实现方式不同，以及是否支持键和值的排序。 总之，单列集合和双列集合在用法上有一些不同，需要根据实际使用场景来选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

参宿七625

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值