Map集合

最新推荐文章于 2024-08-16 17:35:37 发布
原创 最新推荐文章于 2024-08-16 17:35:37 发布 · 272 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

Map:一次添加一对元素。Collection一次添加一个元素。
Map也称为双列集合，Collection集合称为单例集合。
其实map集合中存储的就是键值对。
map集合中必须保证键的唯一性。

常用方法:
1.添加
value put(key,value); 返回前一个和key关联的值，如果没有返回null

2.删除
void clear();情况map集合
value remove(key);根据指定的键删除这个键值对。
3.判断
boolean containsKey(key);
boolean containsValue(value);
boolean isEmpty();
4.获取
value get(key);通过键拿值，如果没有该键返回null.
当然可以通过返回null,来判断是否包含指定键。
int size();获取键值对的个数

Map集合的常用的方法

public class Map02_1 {
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<Integer, String>();
        method(map);
    }
    public static void method(Map<Integer,String> map){//学号和姓名

        //添加元素

        System.out.println(map.put(8, "wangcai"));//null
        System.out.println(map.put(8, "xiaoqiang"));//wangcai,存相同的键，值会覆盖。
        map.put(2, "zhangsan");
        map.put(7, "zhouliu");


        //删除
//      System.out.println("remove:"+map.remove(2));

        //判断
        System.out.println("contains:"+map.containsKey(7));

        //获取
        System.out.println("get:"+map.get(8));

        System.out.println(map.size());
        System.out.println(map);
    }
}

取出Map集合的2中方法

1.keySet

    public class Map03_1 {
        public static void main(String[] args) {
            Map<Integer,String> map=new HashMap<Integer, String>();
            method_2(map);
        }

        public static void method_2(Map<Integer,String> map) {
                map.put(8,"wangwu");
                map.put(2,"zhouliu");
                map.put(7,"xiaoqiang");
                map.put(6,"wangcai");

                //取出map中所有的元素
                //原理，通过keySet方法获取map中多有的键所在的Set集合，在通过Set的迭代器获取到每一个键
                //在对每一个键通过map集合的get()方法获取其对应的值即可。
                Set<Integer> setKey=map.keySet();
                Iterator< Integer> it=setKey.iterator();
                while(it.hasNext()){
                    Integer key=it.next();
                    System.out.println(key);

                    System.out.println(map.get(key));
                }
        }
}

2.entrySet

    public class Map04_1 {
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<Integer,String>();
        method(map);
    }

    public  static void method(Map<Integer, String> map) {
        map.put(8,"wangwu");
        map.put(2,"zhouliu");
        map.put(7,"xiaoqiang");
        map.put(6,"wangcai");

        Collection<String>  values=map.values();
        Iterator<String> it1=values.iterator();
        while(it1.hasNext()){
            System.out.println(it1.next());
        }

        /*
         * 通过Map转成set就可以迭代。
         * 找到了另一个方法，entrySet。
         * 该方法将键和值的映射关系作为对象存储到了Set集合中，而这个映射关系的类型就是Map.Entry类型（结婚证）
         * */

        Set<Map.Entry<Integer, String>> entrySet=map.entrySet();
    //  System.out.println(entrySet);
        Iterator<Map.Entry<Integer, String>> it=entrySet.iterator();
        while(it.hasNext()){
        //  System.out.println(it.next());
            Map.Entry<Integer, String> me=it.next();
            Integer i=me.getKey();
            String s=me.getValue();
            System.out.println(i+":::"+s);

        }

    }
}

Map常用的子类

    |--HashTable:内部结构是哈希表，是同步的。不允许null作为键，null作为值。
            |--Properties:用来存储键值对型的配置文件信息，可以和IO技术相结合。
    |--HashMap:内部结构是哈希表，是不同步。允许null作为键，null作为值。
    |--TreeMap:内部结构是二叉树，是不同步的，可以对map集合中的键进行排序。

HashMap存储自定义对象

public class Student {
    private int age;
    private String name;
    public Student(){}
    public Student(String name,int age){
        this.age=age;
        this.name=name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }       
    //如果为true,视为相同元素，不存。
    //如果为false，那么视为不同元素，就进行存储



}


public class Map07_1 {
    public static void main(String[] args) {
        /*
         * 将学生对象和学生的归属地通过键与值存储到map集合中。
         * 
         * */
        HashMap<Student,String> hm=new HashMap<Student,String>(); 

        hm.put(new Student("lisi",38), "北京");
        hm.put(new Student("zhaoliu",24), "上海");
        hm.put(new Student("xiaoqiang",31), "沈阳");
        hm.put(new Student("wangcai",28), "大连");
        hm.put(new Student("zhaoliu",24), "铁岭");
/*      Set<Student>  keySet=hm.keySet();   
        Iterator<Student> it=keySet.iterator();*/

        Iterator<Student> it=hm.keySet().iterator();
        while(it.hasNext()){
            Student key=it.next();
            String value=hm.get(key);
            System.out.println(key.getName()+":"+key.getAge()+"----"+value);
        }
    }
}

TreeMap存储自定义对象

    public class Student implements Comparable{
    private int age;
    private String name;
    Student(){}
    Student(String name,int age){
        this.age=age;
        this.name=name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public int compareTo(Object o) {
        int temp=0;
        Student stu=(Student) o;
        temp=this.age-stu.age;
        return temp;
    }



}



public class Map08_1 {
        public static void main(String[] args) {
            TreeMap<Student,String> tm=new TreeMap<Student,String>(new ComparatorByName()); 

            tm.put(new Student("lisi",38), "北京");
            tm.put(new Student("zhaolius",24), "上海");
            tm.put(new Student("xiaoqiang",31), "沈阳");
            tm.put(new Student("wangcai",28), "大连");
            tm.put(new Student("zhaoliu",24), "铁岭");

            Set<Map.Entry<Student,String>> entry=tm.entrySet();

            Iterator<Map.Entry<Student, String>>  it=entry.iterator();

            while(it.hasNext()){
            Map.Entry<Student, String>  me= it.next();
            Student student=me.getKey();
            String value=me.getValue();
            System.out.println(student.getName()+":"+student.getAge()+"---"+value);
            }
        }

}


//比较器
public class ComparatorByName implements Comparator<Student> {

    @Override
    public int compare(Student s1, Student s2) {
        int temp=0;
        temp=s1.getName().compareTo(s2.getName());
        return temp==0?s1.getAge()-s2.getAge():temp;
    }

}

LinkedHashMap

    public class Map09_1 {
        public static void main(String[] args) {
            HashMap<Integer, String>  hm=new LinkedHashMap<Integer, String>();
            hm.put(7, "zhouqi");
            hm.put(3,"zhangsan");
            hm.put(1, "qiangyi");
            hm.put(5, "wangwu");

            Set<Map.Entry<Integer,String>>  entry=hm.entrySet();
            Iterator<Map.Entry<Integer, String>>   it=entry.iterator();
            while(it.hasNext()){
                Map.Entry<Integer, String>  me=it.next();
                Integer key=me.getKey();
                String value=me.getValue();
                System.out.println(key+":"+value);
            }
        }
}
java 定义map集合_java基础-Map集合
weixin_36331312的博客
02-24 2816
java基础-Map集合作者：尹正杰版权声明：原创作品，谢绝转载！否则将追究法律责任。一.Map集合概述我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下：1>.Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储；2>.Map中的集合，元素是成对存在的，每个元素是成对存在的，每个元素由...
MAP集合
weixin_67696142的博客
03-26 1750
map集合的特点有哪些？ map集合是无序的，键值对，建不能重复，值可以重复，集合中的键可以为空 如何给map集合赋值？可以调用map.put()方法，进行赋值（注意！键不可以重复） 如何获取到map集合的值？ 可以调用map.get()方法，可以通过键获取值 运行结果 如何遍历map集合？便利map集合的方法有很多种方法如下 方法1：先获取所有建的set集合，在遍历（此方法通过建获取值） 运行结果如下 方法2：取出保存所有Entry的Set，在遍历set即可（..
Map集合5种遍历方式
小丁的博客
11-11 1万+
实现自定义数据类型的映射：Map集合中的键和值可以是任意对象，因此可以通过Map集合来实现自定义数据类型的映射。例如，在处理用户提交的表单数据时，可以使用Map集合来存储用户提交的数据，然后根据键值对的唯一性，进行去重操作。实现缓存一致性：在分布式系统中，使用Map集合可以方便地实现缓存一致性，其中不同节点上的Map集合存储相同的缓存数据，通过协调不同节点上的更新操作可以保证缓存数据的一致性。例如，在Web开发中，可以使用Map集合来缓存一些经常使用的数据，减少对数据库的访问次数，提高系统的性能。
java的Map集合 详解Map集合
热门推荐
weixin_46140377的博客
04-10 7万+
java 集合 Map， HashMap，LinkedHashMap，Hashtable， 详解Map集合
java集合框架（二）——Map集合
最新发布
2301_79325939的博客
08-16 2805
Map集合称为双列集合，格式:{key1=value1,key2=value2,key3=value3,…
Java基础进阶集合-map集合
qq_46096136的博客
09-04 7032
1、Map和Collection没有继承关系。map1集合对象。
kotlin的Map集合
笨鸟不会飞
09-04 6681
kotlin的Map集合只读Map可变的MapmutableMapOf kotlin的Map分为： 只读Map。 可变的MutableMap(MutableMap、HashMap、LinkedHashMap)。 只读Map 意味着我们创建出来的map是不可变的，即我们只能使用无法改变我们map中的数据，我们只能获取集合中的数据而无法对集合中的数据进行新增和修改。 /** * ...
Java——Map集合
程序员阿龙的博客
07-26 2708
Java——Map集合详述
Java Map集合
APCSZDDXM的博客
12-05 2407
Map 其实我之前已经写过Set和List以及Queue，本来是想写到一起，但是觉得Map和Collection接口是不同体系的，所以我这里单出一片文章来对Map进行一个记录。 Map集合的特点 1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value) 2.Map集合中的元素,key和value的数据类型可以相同,也可以不同 3.Map集合中的元素,key是不允许重复的,value是可以重复的 4.Map集合中的元素,key和value是一一对应 5.Map集合中的顺序是不被保证的 6
Java8中利用stream对map集合进行过滤的方法
08-27
Java8中利用Stream对Map集合进行过滤的方法 Java8中引入了Stream API，提供了对集合的高效处理方式。本文将详细介绍如何使用Stream对Map集合进行过滤，包括使用filter方法过滤null和空字符串，以及使用map方法对...
Java 遍历取出Map集合key-value数据的4种方法
08-25
Java 遍历取出Map集合key-value数据的4种方法 在Java中，Map集合是一种常用的数据结构，用于存储键值对数据。但是，在实际开发中，我们经常需要遍历取出Map集合中的键值数据。本文将介绍四种遍历取出Map集合key-...
Map 集合体系
01-20
1 特点 （Map是Map集合体系的根接口） （1）键值对存储（key-value）,一个键值对对应Map集合中的一个元素 （2）键 无序 无下标元素不允许重复 （3） 值 无序无下标 元素允许重复 常用方法： (1) put(K key, V value)...
局部变量和成员变量同名的时候
xdd_lmd的博客
11-25 2362
———– android培训、 java培训、java学习型技术博客、期待与您交流！ ——- class Car{ int num;//全局变量 //全局变量也叫成员变量，又可以分为类变量（也叫静态变量）和实例变量 String color="red"; void run(){ int num=9;//局部变量 System.out.println(
Android_组合式控件_自定义属性
xdd_lmd的博客
03-12 895
组合式控件概念:多个零散的控件当成一个控件来看 应用的场景:当我们的应用程序有几个页面,都是出现了相同的布局,这个时候,我们也不想把他抽取成为样式,就可以使用组合式控件来解决问题了.步骤: 抽取共用的控件代码，到一个布局里面 定义一个类，这个类继承有规定的，布局的根标签是什么类型，那么就必须继承什么类型 导入布局，把布局加入到容器里面 使用自定义的组合式控件 举一个使用组合式控件的例子:第一步:
基本数据类型对象包装类的一些理解
xdd_lmd的博客
05-17 713
基本数据类型对象包装类的作用: 为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。 用于描述该对象的类就称为基本数据类型对象包装类。基本数据类型对象包装类有那些: 基本数据类型 基本数据类型的包装类 byte Byte short
键盘的录入和转换流
xdd_lmd的博客
01-05 623
———– android培训、 java培训、java学习型技术博客、期待与您交流！ ——-读取一个键盘录入的数据,并打入在控制台上。键盘本身就是一个标准的输入设备 对于java而言，对于这种输入设备都有对应的对象。public class Io23_1 { public static void main(String[] args) throws IOException {
使用TCP协议传输信息演示
xdd_lmd的博客
01-11 617
演示1//客户端 class Client{ public static void main(String[] args){ //客户端发数据到服务端 /* * Tcp传输，客户端建立的过程。 * 1，创建tcp客户端socket服务。使用的是Socket对象。 * 建议该对象一创建就明确目的地
File对象的基本功能
xdd_lmd的博客
01-05 586
———– android培训、 java培训、java学习型技术博客、期待与您交流！ ——-File类 1.用来将文件或者文件夹封装成对象 2.方便对文件与文件夹的属性信息进行操作。 3.File对象可以作为参数传递给流的构造函数。 4.了解File类中的常用方法。 File对象-构造函数&字段 public class Io31_1 { public static void
Java Map集合的遍历方式
"Java编程中的Map集合操作演示" 在Java编程中，`Map`集合是一种存储键值对的数据结构，其中每个键都是唯一的，并且与一个值相关联。`Map`接口是Java集合框架的一部分，提供了多种实现，如`HashMap`、`TreeMap`、`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值