Java基础复习——DAY9（Set；泛型；Map）

已于 2022-10-09 13:57:55 修改
阅读量570 收藏
点赞数
文章标签： java
于 2022-03-11 14:34:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kevinwen0228/article/details/123395300
版权

集合进阶

1. 集合知识回顾

集合类特点：提供一个存储空间可变的存储模型，存储的数据容量可以随时改变

单列集合（Collection）和双列集合（Map）

体系结构
在这里插入图片描述

Set

1.集合概述和特点

  • 元素不重复
  • 没有索引，不能普通for循环，可以用增强for
package arrays;

import java.util.HashSet;
import java.util.Set;

public class SetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();//HashSet对集合迭代顺序不保证
        set.add("hello");
        set.add("world");
        set.add("java");

        //增强for遍历
        for(String s :set){
            System.out.println(s);
            //world
            //java
            //hello
        }

    }
}

2. 哈希值

  • 哈希值：jdk根据对象的地址或者字符串或者数字，算出来的int类型的数值
  • Object类有一个方法：public int hashCode（） 返回对象的哈希值

对象哈希值的特点：

  • 默认情况下，不同对象的哈希值不同，可以通过重写hashCode()实现哈希值相同
  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的

3. HashSet集合概述和特点

  • 底层结构，哈希表

  • 不保证顺序

  • 没索引，不能普通for循环遍历

  • 不重复

（呀呦，不和上面一样）

package arrays;

import java.util.HashSet;
import java.util.Set;

public class SetDemo {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();//HashSet对集合迭代顺序不保证
        set.add("hello");
        set.add("world");
        set.add("java");

        //增强for遍历
        for(String s :set){
            System.out.println(s);
            //world
            //java
            //hello
        }

    }
}

4. HashSet集合保证元素唯一性源码分析

在这里插入图片描述

5. 数据结构——哈希表

  • 底层采用链表+数组，可以说是一个元素为链表的数组

在这里插入图片描述

HashSet存储学生信息

  • 重写hashCode（）和equals（）
package arrays;

import java.util.Objects;

public class 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 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);
    }
}


package arrays;

import java.util.HashSet;

public class SetDemo {
    public static void main(String[] args) {
        HashSet<Student> hs = new HashSet<>();//
        Student s1 = new Student("wts", 20);
        Student s2 = new Student("xwb", 30);
        Student s3 = new Student("cyc", 40);
        Student s4 = new Student("cyc", 40);//重复

        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);

        //增强for遍历
        for (Student s : hs) {
            System.out.println(s.getName() + "," + s.getAge());
            //xwb,30
            //cyc,40
            //wts,20
        }
    }
}

6. LinkedHashSet集合概述和特点

  • 哈希表和链表实现的Set接口，具有可预测的迭代顺序
  • 由链表保证元素有序，（存储和取出顺序一致）
  • 哈希表保证唯一
package arrays;

import java.util.LinkedHashSet;

public class SetDemo {
    public static void main(String[] args) {
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");

        for (String s : linkedHashSet) {
            System.out.println(s);
            //hello
            //world
            //java
        }
    }
}

7. TreeSet集合概述和特点

  • 元素有序，不是存储和取出顺序一致，而是按照一定的规则进行排序，取决于构造方法
    TreeSet():根据其元素自然排序进行排序
    TreeSet(Comparator comparator):根据指定比较器进行排序
  • 没有索引，不能普通for
  • 不重复

注意：所有基本类型存储是用它对应的包装类

package arrays;

import java.util.TreeSet;

public class SetDemo {
    public static void main(String[] args) {
        //创建对象  （基本数据类型创建的对象用它的包装类）
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(50);
        ts.add(40);
        ts.add(10);
        ts.add(30);
        ts.add(20);

        ts.add(10);//重复不录入

        for (Integer i : ts) {
            System.out.println(i);//自然排序
            //10
            //20
            //30
            //40
            //50
        }
    }
}

8. 自然排序Comparator的使用

  • 用TreeSet集合存储自定义对象时，无参构造方法使用的是自然排序对元素进行排序的
  • 自然排序，就是让所有元素所属的类实现Comparable接口，重写comparableTo()方法
  • 重写是按照要求

案例：存储学生对象，年龄从小到达输出

package arrays;

public class Student implements Comparable<Student> { //学生类实现Comparable接口
    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 int compareTo(Student s) {
        //return 0;//0只添加了第一个(认为s2和s1是同一个元素 )；1升序存储；-1降序存储
        //按照年龄从小到大
        int num = this.age - s.age;//this表示存入的元素,（拿s2和s1说，s1先存进去了，s2后存进去，this就是s2// ）
        //int num = s.age - this.age
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;

    }
}


package arrays;

import java.util.TreeSet;

public class SetDemo {
    public static void main(String[] args) {
        //创建对象  （基本数据类型创建的对象用它的包装类）
        //按照年龄从小到大排序
        TreeSet<Student> ts = new TreeSet<>();
        Student s1 = new Student("wts", 20);
        Student s2 = new Student("xwb", 60);
        Student s3 = new Student("wyx", 30);
        Student s4 = new Student("cyc", 40);
        Student s5 = new Student("lx", 20);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        for (Student s : ts) {
            System.out.println(s.getName() + ',' + s.getAge());
//            lx,20
//            wts,20
//            wyx,30
//            cyc,40
//            xwb,60
        }
    }
}

比较器排序Comparator的使用

  • 就是让集合构造方法接受Comparator的实现类对象，重写方法（匿名内部类）
package arrays;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {//匿名内部类
            @Override
            public int compare(Student s1, Student s2) {
                //this.age - s.age
                //s1,s2
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

        //创建学生对象
        //按照年龄从小到大排序
        Student s1 = new Student("wts", 20);
        Student s2 = new Student("xwb", 60);
        Student s3 = new Student("wyx", 30);
        Student s4 = new Student("cyc", 40);
        Student s5 = new Student("lx", 20);
        Student s6 = new Student("lx", 20);//无效

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        for (Student s : ts) {
            System.out.println(s.getName() + ',' + s.getAge());
//            lx,20
//            wts,20
//            wyx,30
//            cyc,40
//            xwb,60

        }
    }
}


package arrays;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {//匿名内部类
            @Override
            public int compare(Student s1, Student s2) {
                //this.age - s.age
                //s1,s2
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

        //创建学生对象
        //按照年龄从小到大排序
        Student s1 = new Student("wts", 20);
        Student s2 = new Student("xwb", 60);
        Student s3 = new Student("wyx", 30);
        Student s4 = new Student("cyc", 40);
        Student s5 = new Student("lx", 20);
        Student s6 = new Student("lx", 20);//无效

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        for (Student s : ts) {
            System.out.println(s.getName() + ',' + s.getAge());
//            lx,20
//            wts,20
//            wyx,30
//            cyc,40
//            xwb,60

        }
    }
}

案例：比较器输出学生成绩（条件：总分降序，语文成绩，姓名）

package arrays;

public class Student {
    private String name;
    private int chinese;
    private int math;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getsum() {
        return this.chinese + this.math;
    }
}


package arrays;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建对象，运用比较器删选
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //主要条件
                int num = s2.getsum() - s1.getsum();
                //次要条件
                int num2 = num==0?s1.getChinese()-s2.getChinese():num;
                int num3 = num2==0?s1.getName().compareTo(s2.getName()):num2;
                return num3;
            }
        });

        //创建学生
        Student s1 = new Student("wts",80,90);
        Student s2 = new Student("wts",84,82);
        Student s3 = new Student("wts",52,63);
        Student s4 = new Student("wts",55,46);
        Student s5 = new Student("wts",76,43);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        for(Student s:ts){
            System.out.println(s.getName()+','+s.getChinese()+','+s.getMath()+','+s.getsum());
        }
    }
}

案例：随机数集合输出

package arrays;

import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建set对象
        //Set<Integer> set = new HashSet<>();//无序输出
        Set<Integer> set = new TreeSet<>();//升序输出
        
        //创建random随机数
        Random r = new Random();

        //判断集合长度是否小于10,产生一个随机数增加到
        while (set.size()< 10){
            set.add(r.nextInt(20)+1); //[1,21)  1~20之间的数

        }
        for(Integer i:set){
            System.out.println(i);
        }
    }
}

泛型

本质：参数化类型，使用或者调用传入具体类型
格式

  • <类型>，形参
  • <类型1，类型2> ， 形参
  • 将来具体调用时给定的类型可以看作实参，并且实参只能是引用数据类型
  • 把运行问题提前到编译期间，避免强制转换

1. 泛型类

感觉是模板

package arrays;

public class Generic <T>{
    private T t;

    public Generic() {
    }

    public Generic(T t) {
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}


package arrays;

public class Demo {
    public static void main(String[] args) {
        Generic<String> s = new Generic<>();
        s.setT("wts");
        Generic<Integer> i = new Generic<>();
        i.setT(20);
        System.out.println(s.getT() + ',' + i.getT());
    }
}

2. 泛型方法

package arrays;

public class Generic {
    public <T> void show(T t){
        System.out.println(t);
    }
}


package arrays;

public class Demo {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("wts");//wts
        g.show(20);//20
        g.show(12.25);//12.25
        g.show(true);//true
    }
}

3. 泛型接口

package arrays;
//泛型接口
public interface Generic <T> {
    void show(T t);
}


package arrays;
//接口的实现泛型类
public class GenericImpl<T> implements Generic<T>{
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}


package arrays;
/*测试*/
public class Demo {
    public static void main(String[] args) {
        Generic<String> g = new GenericImpl<>();
        g.show("wts");//wts
        Generic<Integer> g2 = new GenericImpl<>();
        g2.show(200);//200
    }
}

4.类型通配符

为了表示各种泛型List的父类，用类型通配符

  • 类型通配符<?>

  • List<?>:表示元素类型位置的List，他的元素可以匹配任何的类型

  • 仅表示各种泛型List的父类，不能添加元素

不希望List<?>是任何泛型List的父类，只希望是一个泛型List的父类，用类型通配符上限

  • <? extends 类型>
  • List<? extends Number> 表示Number或其子类

类型通配符下限

  • <? super 类型>
  • List<? super Number> 表示Number或其父类

感觉没啥用

5. 可变参数

  • 可变参数，其实是个数组
  • 如果一个方法有多个参数，包含可变参数，可变参数放最后
  • public static int sum(int b,int ...a) {...}
package arrays;

public class Demo {
    public static void main(String[] args) {
        System.out.println(sum(10, 20, 30));//60
        System.out.println(sum(10, 10, 10, 10, 10));//50
    }

    //public static int sum(int b ,int... a) {
    public static int sum(int... a) {
        int n = 0;
        for (int i : a) {//增强for 不太熟啊！
            n += i;
        }
        return n;
    }
}
  • Arrays工具类有一个静态的方法
    public static List asList(T …a):返回指定数组支持的固定大小的列表。不能增删，只能改
       List<String> list = Arrays.asList("hello","world","java");//[hello, world, java]
  • List接口中有一个静态的方法
    public static List of <E …elements>:返回含任意元素的不变的列表
    不能增删改
        List<String> list1 = List.of("wen","tian","sheng");//[wen,tian,sheng]
  • Set接口有一个静态的方法
    public static Set of <E …elements>:返回一个任意数量的不可变的集合不能增删改，不能重复
 Set<String> set = Set.of("wen", "tian", "sheng");//[tian, wen, sheng]
        System.out.println(set);

Map集合

1. Map集合的概述和使用

概述：

  • Interface Map< K, V>
  • 一键一值，不能包含重复的键
  • 举例：学生学号和姓名

创建Map集合的对象

  • 多态
  • 具体实现类HashMap
package arrays;

import java.util.HashMap;
import java.util.Map;

public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();
        //V put<K,V>，指定元素和指定键关联，第一次赋值，第二次用就是覆盖
        map.put("cczu001","wts");
        map.put("cczu002","cyc");
        map.put("cczu003","wyx");
        map.put("cczu001","???");//覆盖了上一个键

        //输出集合对象
        System.out.println(map);
        //{cczu002=cyc, cczu001=???, cczu003=wyx}
    }
}

2. Map集合的基本功能

在这里插入图片描述

3. Map集合的获取功能

在这里插入图片描述

package arrays;

import java.util.*;

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

        map.put("001", "零零一");
        map.put("002", "零零二");
        map.put("003", "零零三");

        //根据键获取值
        System.out.println(map.get("001"));//零零一

        //获取所有键
        Set<String> keyset = map.keySet();
        for (String s : keyset) {
            System.out.print(s + ' ');//001 002 003
        }

        System.out.println();

        //获取所有值
        Collection<String> values = map.values();
        for (String ss : values) {
            System.out.print(ss + ' ');//零零一 零零二 零零三
        }
    }
}

4. Map遍历

4.1 方式1

在这里插入图片描述

package arrays;

import java.util.*;

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

        map.put("001", "零零一");
        map.put("002", "零零二");
        map.put("003", "零零三");

        //遍历
        Set<String> keyset = map.keySet();
        for (String key : keyset) {
            String value = map.get(key);
            System.out.println(key + ',' + value);
        }
       			 //001,零零一
				//002,零零二
				//003,零零三
    }
}

4.2 方式2

在这里插入图片描述

package arrays;

import java.util.*;

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

        map.put("001", "零零一");
        map.put("002", "零零二");
        map.put("003", "零零三");

        //获取键值对 对象集合
        for (Map.Entry<String, String> me : map.entrySet()) {
            System.out.print(me.getKey());
            System.out.print(',');
            System.out.println(me.getValue());
            //001,零零一
//            002,零零二
//            003,零零三
        }
    }
}
大概是犬青
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础学习笔记之泛型
09-02
所谓泛型，就是变量类型的参数化。泛型是JDK1.5中一个最重要的特征。通过引入泛型，我们将获得编译时类型的安全和运行时更小的抛出ClassCastException的可能。在JDK1.5中，你可以声明一个集合将接收/返回的对象的...
Java基础笔记之集合框架和泛型
07-31
详细的介绍了集合框架的用法，及其语法规则，剖析了使用的使用注意事项，帮助更牢靠的掌握集合框架的知识及泛型内容。谢谢
蓝桥杯 代码填空题 训练 题目集（java）
Tim的嵌入式之旅
03-29 3336
（待续）题目列表：1-----报数游戏2-----不连续处断开3-----猜数字4-----反转串5-----第一个数字6-----递归连续数7-----股票风险8-----括号问题9-----公倍数10---孪生素数11---拍7游戏12---排列平方数（由于文章太长，所以可以用ctrl+F键来搜索题目）1.报数游戏 有n个孩子站成一圈，从第一个孩子开始顺时针方向报数，报到3的人出列，下一个人继...
【java】泛型类：生成10个1到20之间的不重复的随机数并降序输出
JockLiu的博客
06-11 3839
需求： 编写一个程序，获取10个1至20的随机数，要求随机数不能重复。并把最终的随机数输出到控制台。 分析： 创建一个Random对象，用来生成随机数 创建一个hashset对象，泛型存储 循环生成10个1-20的随机数 对它们进行排序 遍历输出。Collections.sort 实现代码： package edu.xalead; import java.util.*; p...
C++面向对象程序设计 第七周 输入输出与文件操作
Reanon的博客
10-03 408
一、Week7_01简单的SumArray 输入 无 输出 TomJackMaryJohn 10 #include "stdafx.h" #include <iostream> #include <string> using namespace std; template <class T> T SumArray( // 在此处补充你的代码 ...
Java基础——Day18——泛型，collections，set，map
夏天的风清澈的酒
08-26 206
Day 18 一、泛型（掌握） 参数化数据类型 创建类的时候无法确定属性的数据类型，创建对象的时候根据实际需求确定数据类型 package com.qf.test; import java.util.ArrayList; public class Demo05 { public static void main(String[] args) { Student<String,String> stu01 = new Student<String,String>("1001
Java学习——Day12：泛型
zxzx666的博客
07-01 81
五、泛型 泛型的设计背景 ​ 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来 解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时**把元素的类型设计成一个参数，这个类型参数叫做泛型。**Collection，List，ArrayList 这个就 是类型参数，即泛型。 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个
Java基础学习——第十二章 泛型
weixin_47392089的博客
04-11 327
Java基础学习——第十二章 泛型 一、泛型的概念 1. 泛型的设计背景 集合容器类在声明阶段无法确定实际存储的是什么类型的对象，故JDK5.0之前只能把元素类型声明为Object JDK1.5之后使用泛型来解决：由于此时除了元素的类型不确定之外，其他的部分都是确定的， 例如关于这个元素如何保存， 如何管理等。因此把元素的类型设计成一个参数， 这种参数化类型的概念就是泛型 Collection<E>， List<E>， ArrayList<E> 中的<E>
Java高级编程——泛型
qq_61524266的博客
06-12 676
Java高级编程——泛型
day30 泛型 Map Set Hash HashMap Properties TreeSet
太极生两鱼
02-13 314
*自定义泛型可以吗？可以自定义泛型的时候， 尖括号中的是一个标识符，随便写。java源代码中经常出现的是：和E是Element单词首字母。T是Type单词首字母。*/ public class GenericTest03 < 标识符随便写 > {public void doSome(标识符随便写 o) {// new对象的时候指定了泛型是：String类型 GenericTest03 < String > gt = new GenericTest03 < >();
JAVA基础——泛型&list接口&set接口
06-13 565
第1章泛型 1.1泛型概述 泛型用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数传递。 泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型。 泛型的定义：定义泛型可以在类中预支地使用未知的类型。 泛型的使用：一般在创建对象时，将未知的类型确定具...
关于java基础的泛型的练习
04-24
关于java基础的泛型的练习
Java集合Set、List、Map的遍历方法
09-04
Java集合框架提供了多种接口和类，如Set、List和Map，它们各自有不同的特性和用途。本文将详细介绍如何遍历这些集合类型的实例。 首先，我们来看Set集合。Set接口代表不包含重复元素的集合，它的遍历方法主要有两种...
动力节点_Java基础视频教程126_泛型
11-29
动力节点的Java课程适合绝对零基础的观看，教程中讲解了Java开发环境搭建、Java的基础语法、Java的面向对象。每一个知识点都讲解的非常细腻，由浅入深。适合非计算机专业，想转行做Java开发的朋友，或者想让Java基础...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 508
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
最新发布
m0_67496588的博客
06-20 536
JSON，Ajax
Java 中 什么是 lambda 表达式？有什么优点？
liangzai215的专栏
06-13 936
但是，Lambda 表达式绝对不是 Java 8 的银弹，它在消除代码冗余、支持并发这两方面表现优秀，但是在其他方面并未有太多贡献，所以我们在编程的时候，还是需要结合实际情况，灵活选择使用。Lambda表达式在Java 8中是非常强大的工具，但是需要注意的是，Lambda并并不适合所有情况，它主要适用于函数式编程，处理集合操作和Stream操作，在某些具体的业务逻辑操作中就不一定会产生预期的效果。代码块：是 Lambda 表达式需要执行的功能，可以是一行代码，也可以是复杂的多行代码。
基于springboot的青年公寓服务平台源码数据库
s123456sj的博客
06-16 1209
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
java泛型map转map
11-10
以下是Java泛型Map转Map的示例代码： ```java Map, Integer> map1 = new HashMap(); map1.put("key1", 1); map1.put("key2", 2); Map, Object> map2 = new HashMap();for (Map.Entry, Integer> entry : map1....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值