Java的集合框架之Map的用法详解

Map有两种比较常用的实现:HashMapTreeMap

  • HashMap: HashMap 也是无序的,也是按照哈希编码来排序的,允许使用null 值和null 键
  • TreeMap: TreeMap 是有顺序的,按照用户的输入顺序进行排序,TreeMap 按照顺序村塾“键/值”对。值得注意的是 在TreeMap 中是不允许“键”重复的,但是可以允许“值”重复。下面通过一个简单的例子进行说明。
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test2 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String,Integer>();
        //Map<String,Integer> map = new TreeMap<String,Integer>();
        //添加元素
        map.put("tom",20);
        map.put("rose", 18);
        map.put("mike",18);
        map.put("black", 21);
        map.put("tom",19);//键 是不允许重复的,但是数值是可以重复的
        System.out.println(map);
        // 输出结果: {rose=18, tom=19, mike=18, black=21}

        //取出map中的元素
        int x = map.get("tom");
        System.out.println(x);//19
        //Map 集合的遍历方法
        //"键的集合"用到keySet 方法
        Set<String> set = map.keySet();//此时的set存放的都是字符串(键值)
        for(String s:set)
        {
            System.out.println(s+"="+map.get(s)+"  ");
        }
        System.out.println("-------------------------");

        //用迭代器进行遍历
        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext())
        {
            String s = iterator.next();
            System.out.println(s+"="+map.get(s)+"  ");
        }

        //"值的遍历",通过map.vaules()方法获取
        Collection<Integer> value = map.values();//返回值类型为Collection
    //"值的集合",通过map.vaules()方法获取
        Collection<Integer> value = map.values();//因为是对值的遍历,所以泛型也就定义成Integer
        System.out.println(value);

        //值的遍历
        Iterator<Integer> iterator = value.iterator();
        while(iterator.hasNext())
        {
            int v = iterator.next();
            System.out.println(v+" ");
        }

        //键值对 的集合,通过map.entrySet()方法获取
        Set<Map.Entry<String, Integer>> set = map.entrySet();//注意此处的泛型要和上面map的类型保持一致
        System.out.println(set);
        for (Map.Entry<String, Integer> me:set)
        {
            String key = me.getKey();
            Integer value = me.getValue();
            System.out.println(key+"="+value+"  ");
        }
        System.out.println("--------------------------");
        Iterator<Map.Entry<String, Integer>> iterator = set.iterator();
        while(iterator.hasNext())
        {
            Map.Entry<String, Integer> entry = iterator.next();
            System.out.println(entry.getKey()+" "+entry.getValue()+" ");
        }

    }

}

set 和map 的几个小例子

创建一个TreeSet 对象,并在其中添加一些员工对象(Empoyee),其姓名和工资分别是:张三 8000,李四6000,王五 5600,马六 7500 。最后按照工资的大小,降序输出。(提示:让Employee 对象实现 Comparable接口)


public class Employee implements Comparable{
    private String name;
    private int salary;
    public Employee(String name, int salary) {//对生成的属性进行初始化,生成带有参数的方法
        super();
        this.name = name;
        this.salary = salary;
    }
    public Employee() {//生成不带参数的方法,其实这里的作用也是为了在测试类中更好的调用此方法
        super();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getSalary() {
        return salary;
    }
    public void setSalary(int salary) {
        this.salary = salary;
    }
    @Override
    public int compareTo(Object p) {
        // TODO Auto-generated method stub
        Employee p1 = (Employee)p;
        if (this.salary>p1.salary)//用当前当前的salary 和p1的salary 进行比较
        {
            return -1; //返回的是后面一个数减去前面一个数的“位差”

        }
        else if (this.salary < p1.salary)
        {
            return 1;

        }
        else
            return 0;

    }

}


import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        //TreeSet 是用户自定义的顺序(默认)
        Set<Employee> set = new TreeSet<Employee>();//用set集合来完成“一个类”的操作(这个地方可以和)
        Employee p1 = new Employee("张三",8000);
        Employee p2 = new Employee("李四",6000);
        Employee p3 = new Employee("王五",5600);
        Employee p4 = new Employee("马六",8000);
        set.add(p1);//add 方法自动调用compare 方法,因为重新写了此方法,所以此处可以进行比较
        set.add(p2);
        set.add(p3);
        set.add(p4);
        for (Employee e:set)
        {
            System.out.println(e.getName()+":"+e.getSalary());
        }
        System.out.println("--------------------------------");
        Iterator<Employee> iterator = set.iterator();
        while(iterator.hasNext())
        {
            Employee p = iterator.next();
            System.out.println(p.getName()+":"+p.getSalary());
        }

    }

}

例子(12)

对于上例中的排序这里做简要说明:这里是重写了compareTo 方法,因为原来是方法是无法对salaryname进行排序的,这样重写了,就可以实现排序的效果。return返回的是 位差 如果前面的数比后面的数大,且位差是正数则说明后面的比前面的还要大,并按此位差进行插入。依次类推。

@Override
public int compareTo(Object p) {
  // TODO Auto-generated method stub
  Employee p1 = (Employee)p;
  if (this.salary>p1.salary)//用当前当前的salary 和p1的salary 进行比较
  {
    return -1; //返回的是后面一个数减去前面一个数的“位差”

  }
  else if (this.salary < p1.salary)
  {
    return 1;

  }
  else
    return 0;

}

例子(13)

创建一个Customer类,类中的属性有姓名(name)、年龄(age)、性别(gender),每个属性分别有get/set 方法。然后创建两个Customer 对象:张立、18、女和王猛、22、男。把这两个对象存储在ArrayList 对象中,然后从ArrayList 对象读取出来。

package yjlblog.www.ch01;

public class Customer {
    private  String name;
    private int age;
    private String gender;
    public Customer(String name, int age, String gender) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    public Customer() {
        super();
    }
    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;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }

}
package yjlblog.www.ch01;

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

public class SetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet();
        set.add("first");
        set.add("second");
        set.add("third");
        set.add("forth");
        //set 中的顺序和插入顺序是不一致的
        //HashSet 按照哈希码来排序
        //TreeSet 按照字典序排序
        //set 中不允许出现相同的元素
        for(int i = 0;i <set.size();i++){
            System.out.println();
        }
    }

}
//set 也是用循环来实现遍历的
package yjlblog.www.ch01;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        Customer c1 = new Customer("张立",18,"女");
        Customer c2 = new Customer("王猛",18,"男");
        ArrayList<Customer> list = new ArrayList<Customer>();//泛型引用的是Customer类
        list.add(c1);                                        //来向”“动态数组ArrayList”中存放自己定义的属性方法
        list.add(c2);
        for(Customer c:list){//注意此处的c 的类型是和list的类型一致的
            System.out.println("姓名"+c.getName());
            System.out.println("年龄"+c.getAge());//用get方法来说的得到数据
            System.out.println("性别"+c.getGender());
        }
    }//遍历都是使用循环的,不管事动态数组还是链表。实质可以看成是数组

}

例子(11)

创建一个HashMap 对象,并在其中添加一些员工的姓名和工资:张三,8000,李四 6000.然后从HashMap对象中获取这两个人的薪水并打印出来,接着把张三的工资改为8500,再把他们的薪水显示出来。

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class TEST1 {
public static void main(String[] args) {
    Map<String,Integer> map=new TreeMap<String,Integer>();
    map.put("张三",8000);
    map.put("李四", 6000);
    map.put("张三", 8500);
    //从HashMap对象中获取两个人的薪水并打印
      Set<String> set=map.keySet();//此时set中存放的是字符串(键值)
      System.out.println(set);
      for(String s:set){
      System.out.print(s+"="+map.get(s)+"  ");
 }
}
}

java的集合框架set 和map的深入理解的更多相关文章

  1. java学习——集合框架(泛型,Map)

    泛型: ... Map:一次添加一对元素.Collection 一次添加一个元素. Map也称为双列集合,Collection集合称为单列集合. 其实map集合中存储的就是键值对. map集合中必须保 ...

  2. 理解java集合——集合框架 Collection、Map

    1.概述: @white Java集合就像一种容器,可以把多个对象(实际上是对象的引用,但习惯上都称对象)"丢进"该容器中. 2.Java集合大致可以分4类: @white Set ...

  3. 牛客网Java刷题知识点之Java 集合框架的构成、集合框架中的迭代器Iterator、集合框架中的集合接口Collection(List和Set)、集合框架中的Map集合

    不多说,直接上干货! 集合框架中包含了大量集合接口.这些接口的实现类和操作它们的算法. 集合容器因为内部的数据结构不同,有多种具体容器. 不断的向上抽取,就形成了集合框架. Map是一次添加一对元素. ...

  4. java的集合框架最全详解

    java的集合框架最全详解(图) 前言:数据结构对程序设计有着深远的影响,在面向过程的C语言中,数据库结构用struct来描述,而在面向对象的编程中,数据结构是用类来描述的,并且包含有对该数据结构操作 ...

  5. java.util 集合框架集合

    java的集合框架为程序提供了一种处理对象组的标准方式.设计了一系列标准泛型接口: ⑴Collection ()接口,扩展了Iterable接口,位于集合层次结构的顶部,因此所有的集合都实现Colle ...

  6. Java基础——集合框架

    Java的集合框架是Java中很重要的一环,Java平台提供了一个全新的集合框架.“集合框架”主要由一组用来操作对象的接口组成.不同接口描述一组不同数据类型.Java平台的完整集合框架如下图所示: 上 ...

  7. 浅谈Java的集合框架

    浅谈Java的集合框架 一.    初识集合 重所周知,Java有四大集合框架群,Set.List.Queue和Map.四种集合的关注点不同,Set 关注事物的唯一性,List 关注事物的索引列表,Q ...

  8. Java 高级-集合框架

    参考资料 参考 HashMap 类似 C++ 中的 STL 标准模板库,Java 也在 java.util 包中封装了一套常用数据结构及其算法,称为集合框架.所有的集合框架都包含如下内容: 接口:代表 ...

  9. java的集合框架之一

    java是一套很成熟的东西,很多商用的东西都喜欢用它,用的人多,稳定.不过一般也不怎么说起它,因为太常见了,私下里说,写java应用层得就像农民工,每一处都是搭积木,根据设计师的东西如何优雅地搭好积木 ...

随机推荐

  1. idea使用转载【别人的专栏】

    维C果糖

  2. Android 之json解析

    JSON(JavaScript Object Notation) 定义:字符串 键值对 解析方法有JSON,谷歌GSON,阿里巴巴FastJSON(推荐) 一种轻量级的数据交换格式,具有良好的可读和便 ...

  3. IBAction&IBOutlet

    IB:Interface Builder 1>IBAction 需要操作,例如按钮的点击 2> IBOutlet 需要获得.修改该属性 然后就可以与Storyboard建立起联系

  4. ACM学习之路___HDU 5723(kruskal + dfs)

    Abandoned country Time Limit: / MS (Java/Others) Memory Limit: / K (Java/Others) Total Submission(s) ...

  5. PuTsangTo-单撸游戏开发03 碰撞与跳跃瑕疵版

    继续上一部分,游戏的定位是横版平台动作类游戏,所以得有跳跃动作,首先想到的就是物理引擎,不过在2D游戏里,仅为了角色的跳跃而引入物理引擎,目前想来有些不至于,仅使用cocos默认带有的碰撞系统也足够了 ...

  6. WILL吃桃_KEY

    WILL 吃桃 (peach.pas/c/cpp) [ 题目描述] Will 很喜欢吃桃, 某天 Will 来到了一片森林, 森林中有 N 颗桃树, 依次编号为 1,2,„,N.每棵树上有数量不等的桃 ...

  7. MongDB开启权限认证

    在生产环境中MongoDB已经使用有一段时间了,但对于MongoDB的数据存储一直没有使用到权限访问(MongoDB默认设置为无权限访问限制),最近在酷壳网看了一篇技术文章(https://cools ...

  8. 理解ES6——Promise

    浏览器的控制台真是个好东西,啥都能干: 这就是Promise,能看出来啥? 1.是个构造函数,可以new实例. 2.自身有一些方法:all.race.reject.resolve... 3.原型上有c ...

  9. 深入理解计算机系统chapter9

    从概念上来讲:虚拟存储器被组织为一个存放在磁盘上的N个连续的字节大小的单元组成的数组. 磁盘上数组的内容被缓存到主存中 1. 读写内存的安全性 物理内存本身是不限制访问的,任何地址都可以读写,而操作系 ...

  10. [ASP.NET教程] 防止表单重复提交

    第一种方法:javascript控制.缺点,一般用户使用没问题,但是懂点js的还是可以强行重复提交.而且,后退再提交,你也没啥办法.第二种方法:服务器控制.后台生成一个token,存入session或 ...