【4858.com】JAVA基础学习day16,Java当中的集纳框架Map

By admin in 4858.com on 2019年9月29日

4858.com 1

1.    Map 接口概述

一、Map简述

1.1、简述

public interface Map<K,V>

项目参数:
K
此映射所保险的键的类型 key

V
映射值的品类 value

该集结提供键–值的照耀。key不能够再度,一对对的仓库储存格局

将键映射到值的目标。多少个辉映不能够包括重复的键;各类键最七只好照射到二个值。

1.2、方法

嵌套类摘要

static interface

Map.Entry<K,V>
映射项(键-值对)。

 

格局摘要

void

clear()
现在映射中移除全部映射关系(可选操作)。

boolean

containsKey(Object key)
假如此映射满含钦命键的映照关系,则赶回 true

boolean

containsValue(Object value)
比如此映射将三个或五个键映射到钦命值,则赶回 true

Set<Map.Entry<K,V>>

entrySet()
回去此映射中包括的映照关系的 Set 视图。

boolean

equals(Object o)
正如内定的指标与此映射是还是不是等于。

V

get(Object key)
回去钦定键所映射的值;要是此映射不蕴含该键的映照关系,则赶回 null

int

hashCode()
重临此映射的哈希码值。

boolean

isEmpty()
如若此映射未包蕴键-值映射关系,则赶回 true

Set<K>

keySet()
回到此映射中包含的键的 Set 视图。

V

put(K key, V value)
将内定的值与此映射中的钦定键关联(可选操作)。

void

putAll(Map<? extends K,? extends V> m)
从钦命映射上校全部映射关系复制到此映射中(可选操作)。

V

remove(Object key)
要是存在贰个键的炫彩关系,则将其今后映射中移除(可选操作)。

int

size()
回去此映射中的键-值映射关周到。

Collection<V>

values()
回来此映射中富含的值的 Collection 视图。

【4858.com】JAVA基础学习day16,Java当中的集纳框架Map。 1.3、常用子类

HashTable:底层是哈希表,不得以存入Null键Null值,线程是一块的JDK1.0频率低

HashMap:基于哈希表数据结构。允许利用Null键Null值,但独有三个Null键,线程非同步的。JDK1.2作用高

TreeMap:二叉树,线程不一齐。能够用于给Map聚焦的key键举行排序。

和Sety集结很像,Set底层就是Map集结。

1.4、Put

添比索素,加多一样的键,那么后增加的值会覆盖的Vaule,put方法会重回被遮住的值。

 

 

 

简书小编:达叔同志(Wu 孟达先生)小生

java.util.Map 接口描述了炫酷结构, Map 接口允许以键集、值集合或键 – 值映射关系集的样式查看有些映射的开始和结果。

二、HashMap

2.1、常用方法

 

package com.pb.map.demo1;

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

public class MapDemo1 {

    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        //添加
        map.put("01", "zhangsan");
        System.out.println(map.put("01", "lisi002"));//zhangsan
        map.put("02", "wangwu03");
        map.put("03", "wangwu04");
        map.put(null, "ffff");
        map.put("04", "qqquqq");
        //判断有没有key
        System.out.println(map.containsKey("02"));//true
        //判断 有这有 这个value
        System.out.println(map.containsValue("ffff"));//true
        //获取
        System.out.println(map.get("03"));//wangwu04
        System.out.println(map.get(null));//ffff
        System.out.println(map.get("fdsfdsf"));//null
        System.out.println(map.remove("02"));//返回value的值
        System.out.println(map.remove("0fdsfd"));//没有就返回null
        System.out.println(map);//{null=ffff, 01=lisi002, 03=wangwu04, 04=qqquqq} 是无序的
    }

}

 

 

2.2、key和values

keySet:将map中全数的键
存入到Set集结。因为set具有迭代器。重回为set集结

         
能够迭代情势抽取全部的键,在依据get方法,获取每二个键一面如旧的值。

 

package com.pb.map.demo1;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo2 {

    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
            //添加
                map.put("09", "zhaoliu");    
                map.put("01", "zhangsan");            
                map.put("02", "wangwu03");
                map.put("03", "wangwu04");
                map.put("04", "qqquqq");
                //获取map集合中的所有键的集合
                Set<String> keySet=map.keySet();
                //迭代所有键来获取值
                Iterator<String> iterator=keySet.iterator();
                while(iterator.hasNext()){
                    String key=iterator.next();
                    //通过map.get(键)的方式来获取值
                    System.out.println(key+".........."+map.get(key));
                }
    }

}

 

 

entrySet:重临为Set<Map.Entry<k,v>>
entrySet:将Map集结中的照耀关系存入到Set
集合中,而这些涉及的数据类型就是Map.Entry

 

Map.entrySet()

 


 

 

 

格局摘要

boolean

equals(Object o)
比较钦赐对象与此项的相等性。

K

getKey()
再次来到与此项对应的键。

V

getValue()
回到与此项对应的值。

int

hashCode()
回去此映射项的哈希码值。

V

setValue(V value)
用钦赐的值替换与此项对应的值(可选操作)。

 

package com.pb.map.demo2;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * 学生属性:姓名,年龄
 * 注意姓名和年龄相同的视为同一个学生
 * 1.描述学生
 * 2.定义map容器,将学生做为键,地址作为值、值入
 * 3.获取map集合的元素
 */

//学生类
class Student implements Comparable<Student>{
    private String name;
    private int age;

    //让对象本身具备比较性
    @Override
    public int compareTo(Student s){
        int num=new Integer(this.age).compareTo(new Integer(s.age));
        if(num==0){
            return this.name.compareTo(s.name);
        }
        return num;
    }

    /*
     * 重写hash
     */
    @Override
    public int hashCode(){
        return name.hashCode()+age*33;
    }
    /*
     * 重写equals
     */
    @Override
    public boolean equals(Object obj){
        if(!(obj instanceof Student)){
            throw new ClassCastException("类型不匹配");
        }
        Student stu=(Student)obj;
        return this.name.equals(stu.name)&&this.age==stu.age;

    }

    public Student() {
        super();
    }
    public Student(String name, int age) {
        super();
        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;
    }
    public void show(){
        System.out.println(this.name+"...."+this.age);
    }

}
public class MapTest {

    public static void main(String[] args) {
        Map<Student,String> map=new HashMap<Student,String>();
        map.put(new Student("lisi01",21), "北京");
        map.put(new Student("lisi01",21), "上海");//覆盖第一个值
        map.put(new Student("lisi02",23), "深圳");
        map.put(new Student("lisi04",22), "武汉");
        map.put(new Student("lisi03",24), "天津");
        System.out.println("======keySet方法======");
        //第一种遍历方式
        Set<Student> keySet=map.keySet();
        Iterator<Student> it=keySet.iterator();
        while(it.hasNext()){
            Student stu=it.next();
            String add=map.get(stu);
            System.out.println(stu.getName()+"..."+stu.getAge()+"...."+add);
        }
        System.out.println("======entrySet方法======");
        //第二种遍历方式
        Set<Map.Entry<Student, String>> entrySet=map.entrySet();
        Iterator<Map.Entry<Student, String>> iter=entrySet.iterator();
        while(iter.hasNext()){
            Map.Entry<Student, String> student=iter.next();
            Student stu=student.getKey();
            String add=student.getValue();
            System.out.println(stu.getName()+"..."+stu.getAge()+"...."+add);
        }
    }

}

======keySet方法======
lisi01...21....上海
lisi02...23....深圳
lisi04...22....武汉
lisi03...24....天津
======entrySet方法======
lisi01...21....上海
lisi02...23....深圳
lisi04...22....武汉
lisi03...24....天津

 

 

 

 

Java在那之中的联谊框架Map

Java 自带了各样 Map 类。 那几个 Map 类可归为三种类型:

三、TreeMap

3.1、TreeMap排序

 

package com.pb.map.demo2;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
 * 学生属性:姓名,年龄
 * 注意姓名和年龄相同的视为同一个学生
 * 1.描述学生
 * 2.定义map容器,将学生做为键,地址作为值、值入,
 * 3.对学生排序按姓名排序
 * 3.获取map集合的元素
 * 
 */

//学生类
class Student implements Comparable<Student>{
    private String name;
    private int age;

    //让对象本身具备比较性
    @Override
    public int compareTo(Student s){
        int num=new Integer(this.age).compareTo(new Integer(s.age));
        if(num==0){
            return this.name.compareTo(s.name);
        }
        return num;
    }

    /*
     * 重写hash
     */
    @Override
    public int hashCode(){
        return name.hashCode()+age*33;
    }
    /*
     * 重写equals
     */
    @Override
    public boolean equals(Object obj){
        if(!(obj instanceof Student)){
            throw new ClassCastException("类型不匹配");
        }
        Student stu=(Student)obj;
        return this.name.equals(stu.name)&&this.age==stu.age;

    }

    public Student() {
        super();
    }
    public Student(String name, int age) {
        super();
        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;
    }
    public void show(){
        System.out.println(this.name+"...."+this.age);
    }

}
public class MapTest {

    public static void main(String[] args) {
        TreeMap<Student,String> map=new TreeMap<Student,String>(new StudentNameCom());

        map.put(new Student("lisi01",21), "上海");//覆盖第一个值
        map.put(new Student("lisi02",23), "深圳");
        map.put(new Student("a",56), "北京");
        map.put(new Student("lisi04",22), "武汉");
        map.put(new Student("lisi03",24), "天津");
        map.put(new Student("a",33), "北京");
        map.put(new Student("lisi01",21), "北京");
        System.out.println("======keySet方法======");
        //第一种遍历方式
        Set<Student> keySet=map.keySet();
        Iterator<Student> it=keySet.iterator();
        while(it.hasNext()){
            Student stu=it.next();
            String add=map.get(stu);
            System.out.println(stu.getName()+"..."+stu.getAge()+"...."+add);
        }
        System.out.println("======entrySet方法======");
        //第二种遍历方式
        Set<Map.Entry<Student, String>> entrySet=map.entrySet();
        Iterator<Map.Entry<Student, String>> iter=entrySet.iterator();
        while(iter.hasNext()){
            Map.Entry<Student, String> student=iter.next();
            Student stu=student.getKey();
            String add=student.getValue();
            System.out.println(stu.getName()+"..."+stu.getAge()+"...."+add);
        }
    }

}
class StudentNameCom implements Comparator<Student>{

    @Override
    public int compare(Student stu1, Student stu2) {
        int num=stu1.getName().compareTo(stu2.getName());
        if(num==0){
            return new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
        }
        return num;
    }

}

 

 

01

Map提供了八个聚众视图:

  1. 键集
  2. 值集
  3. 键-值 映射集

public String getWeek{ if(num<0 || num>7){  throw new NoWeekException(num+"没有对应的星期");  String[] weeks = {"","星期一"...."星期日"};  return weeks[num]; }}

SundayMondayTuesdayWednesdayThursdayFridaySaturday

   1. 通用 Map ,用于在应用程序中处理映射,日常在 java.util 程序包中达成

四、TreeMap使用

 

4.1、示例

 

package com.pb.map.demo2;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*
 * "sdfgzxcvasdfxcvdf"获取该字符串中的字母出次数
 * 1.使用map集合映射
 * 2.将字符中的字母做KEY,次数做value
 */
public class MapTest2 {

    public static void main(String[] args) {
        String str = "sdfgzxcvasdfxcvdf";
        TreeMap<String, Integer> map = getCount(str);
        Set<String> keySet = map.keySet();
        Iterator<String> it = keySet.iterator();
        while (it.hasNext()) {
            String s = it.next();
            Integer count = map.get(s);
            System.out.println(s + "...." + count);
        }

        String tmp = getCount2(str);
        System.out.println(tmp);
    }

    // 第一种
    public static TreeMap<String, Integer> getCount(String str) {
        TreeMap<String, Integer> map = new TreeMap<String, Integer>();

        for (int x = 0; x < str.length(); x++) {
            Set<String> keys = map.keySet();
            String s = str.substring(x, x + 1);
            if (keys.contains(s)) {
                Integer count = map.get(s);
                map.put(s, count + 1);
            } else {
                map.put(s, 1);
            }
        }

        return map;
    }

    // 第二种
public static String getCount2(String str){
    //转换为字符数组
    char[] chs=str.toCharArray();
    //定义TreeMap容器来存放
    TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
    //定义变量来存放次数
    int count=0;
    for(int x=0;x<chs.length;x++){
        if(!(chs[x]>='a' &&chs[x]<='z' || chs[x] >= 'A'&&chs[x]<='Z')){
            continue;
        }
        Integer value=tm.get(chs[x]);
        if(value!=null){
            count=value;
        }
        count++;
        tm.put(chs[x], count);
        count=0;
    }
    //声明变长sb对象
    StringBuilder sb=new StringBuilder();
    //获取Map.Entry对象
    Set<Map.Entry<Character, Integer>> entrySet=tm.entrySet();
    Iterator<Map.Entry<Character, Integer>> it=entrySet.iterator();
    //遍历添加
    while(it.hasNext()){
        Map.Entry<Character, Integer> m=it.next();
        Character c=m.getKey();
        Integer value=m.getValue();
        sb.append(c+"("+value+")");
    }
    return sb.toString();

}
}

 

结果:

 

a....1
c....2
d....3
f....3
g....1
s....2
v....2
x....2
z....1
a(1)c(2)d(3)f(3)g(1)s(2)v(2)x(2)z(1)

 

 

java.util接口 Map<K,V>参数:K为此映射的键V为此映射的值

知晓的子接口:

Bindings,ConcurrentMap<K,V>,ConcurrentNavigableMap<K,V>,LogicalMessageContext,MessageContext,NavigableMap<K,V>,SOAPMessageContext,SorteMap<K,V>

精通的兑现类:

AbstractMap,Attributes,AuthProvider,ConcurrentHashMap,ConcurrentSkipListMap,EnumMap,HashMap,Hashtable,IdentityHashMap,LinkedHashMap,PrinterStateReasons,Properties,Provider,RenderingHints,SimpleBindings,TabularDataSupport,TreeMap,UIDefaults,WeakHashMap

兑现的接口:

public interface Map<K,V>

在光彩夺目中不能够有再度的键,各种键只可以照射在一个值上

Map集结中的特点:

  1. 其间存款和储蓄的形式是以键-值对的花样
  2. Map中的键要具备独一性

嵌套类:

方法 说明
Map.Entry<K,V> static interface,静态 接口,映射模式键-值对

Map方法:

方法 说明
clear() 类型为void,在映射中移除所有的映射关系
containsKey(Object key) 返回boolean类型,如果映射中包含指定的键的映射关系,返回为true,反之为false
containsValue(Object value) 返回boolean类型,如果映射中一个或多个键映射到指定的值上,返回为true,反之为false
entrySet() 返回类型为Set<Map.Entry<K,V>> 返回此映射中包含的映射关系
equals 返回类型为boolean,比较指定对象与映射是否相等
get(Object key) 返回值,返回指定键所映射的值,如果此映射不包含该键的映射关系,返回为null,代表没有
hasCode() 返回为Int类型,返回此映射的哈希码值
isEmpty() 返回类型为boolean,如果此映射没有键-值的映射关系,返回为true,反之为false
keySet() 返回类型为Set<E>,返回此映射中包含的所有键的Set视图
put(K key, V value) 将对应的键与值,建立映射关系,添加映射关系的方法
putAll(Map<? extends K, ? extends V> m) 返回类型为void,从指定的映射关系中将所有的映射关系复制到此映射中
remove(Object key) 如果存在这个键的映射关系就将其移除
size() 返回类型为Int类型,返回此映射关系中的键-值映射关系的数目
values() 返回类型为Collection<V>,返回此映射中包含的值的Collection视图

          * HashMap

五、Map扩展

5.1、Map中嵌套Map或然聚众

 

package com.pb.map.demo3;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

class Person{
    private String name;
    private int age;
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        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;
    }

}
public class MapTest1 {

    public static void main(String[] args) {

        HashMap<String,ArrayList<Person>> map=new HashMap<String,ArrayList<Person>>();

        ArrayList<Person> persons1=new ArrayList<Person>();
        persons1.add(new Person("张三",33));
        persons1.add(new Person("李四",33));
        persons1.add(new Person("王五",33));
        ArrayList<Person> persons2=new ArrayList<Person>();
        persons2.add(new Person("赵六",33));
        persons2.add(new Person("钱七",33));
        persons2.add(new Person("刘八",33));


        map.put("SB001", persons1);
        map.put("SB002", persons2);


        Iterator<String> it=map.keySet().iterator();
        while(it.hasNext()){
            String room=it.next();
            System.out.println(room);
            ArrayList<Person> p=map.get(room);
            getInfos(p);
        }


    }

    public static void getInfos(ArrayList<Person> list){
        Iterator<Person> it=list.iterator();
        while(it.hasNext()){
            Person p=it.next();
            System.out.println(p.getName()+"..."+p.getAge());
        }
    }

}
//结果

SB001
张三...33
李四...33
王五...33
SB002
赵六...33
钱七...33
刘八...33

 

put

V put (E key, V value)

将相应的键与值,创建映射关系,增多映射关系的主意,要是在此以前就有那些映射关系,就能够将钦定的值替换掉旧的值。

参数:

key – 为钦定的涉嫌的键
value – 为内定的涉嫌的值

会抛出的谬误:

UnsupportedOperationException:不支持put操作ClassCastException:不允许用映射关系NullPointerException:将指定的键或者值为null,而此映射却不允许存储IllegalArgumentException:指定的键或者值不允许存储到映射中

相似用的完毕类:

HashMap

java.util类 HashMap<K,V>java.lang.Object -> java.util.AbstractMap<K,V>  -> java.util.HashMap<K,V>

参数:

K-为所对应的键V-为所对应的值

已落到实处的接口:

Serializable,Cloneable,Map<K,V>

已知的子类:

LinkedHashMap,PrinterStateReasons

所以:

public class HashMap<K,V> extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializable

          * Hashtable

 

02

Map例子:

import java.util.HashMap;public class MapDemo { public static void main(String[] args){  // 建立map  Map<String,String> map = new HashMap<String,String>(); // 添加元素  map.put("星期一", "Monday");  mpa.put( ...// 自行添加 );  map.put("星期日", "Sunday");  // 添加元素时,如果键相同,值会覆盖  map.put("星期日", "SundayDemo");  // 值被覆盖 // 获取值 String value = map.get("星期日"); // 键存在,返回值,反之返回null,为空 // 删除元素 String s = map.remove("星期日"); // 删除对应的键值对关系,这样在Map集合中就少了这一对键值对 }}

怎样赢得具备的键

Map<String,String> map = new HashMap<String,String>();map.put("星期一", "Monday");map.put("星期日", "Sunday");

使用keySet

Set<String> keySet = map.keySet();for(Iterator<String> it = keySet.iterator(); it.hasNext{ String key = it.next(); String value = map.get; System.out.println(key + " : " + value);}

能够动用foreach循环

for(String key : keySet){ System.out.println(key + " = " + map.get;}

entrySet

Set<Map.Entry<K,V>> entrySet()

功效为回去此映射中富含的映照关系Set的视图,将map聚集中映射关系存款和储蓄到set集合中。

辉映关系:指键和值对应的涉及,数据类型Map.Entry波及的种类

Set<Map.Entry<String,String>> entrySet = map.entrySet();Iterator< Map.Entry<String,String> > it = entrySet.iterator();while(it.hasNext{ Map.Entry<String,String> m = it.next(); // 获取键 String key = m.getKey(); // 获取值 String value = m.getValue(); System.out.println(key + " : " + value);}

Map.Entry<K,V>

java.util接口 Map.Entry<K,V>

接口达成类:

AbstractMap.SimpleEntry , AbstractMap.SimpleImmutableEntry

接口:

public static interface Map.Entry<K,V>// 为映射项 - 键-值 对

Map.Entry<K,V>方法

方法:

方法 说明
equals 返回类型为boolean,比较指定对象与此项的相等性
getKey() 返回为此项对应的键
getValue() 返回为此项对应的值
hashCode() 返回类型为int,返回为此项的哈希码值
setValue 用指定的值去换此项对应的值
for(Map.Entry<String,String> m : map.entrySet{ String key = m.getKey(); String value = m.getValue(); System.out.println(key + " : " + value);}

interface Map{ public static interface Entry();}

values()

归来类型为Collection<V>,重临此映射中包括的值的Collection视图

Collection<String> values = map.values();for(String value : values){ System.out.println("value:"+value);}

总结:Map -> entrySet() getKey() getValue() -> keySet() get -> values()

          * Properties

03

4858.com 2

Hashmap

public class HashMapDemo { public static void main(String[] args){  Map<Student,String> map = new HashMap<Student,String>(); // 添加元素 map.put(new Student("da",12), "1"); map.put(new Student("shu",13), "2"); map.put(new Student("dashu",14), "3"); // 取出数据 // Set<Student> keySet = map.keySet(); // for(Student key : keySet){} for(Student key : map.keySet{  String value = map.get;  System.out.println(key.toString() + " : " + value); } }}

public class Student implements Comparable<Student>{ private String name; private int age; public Student(){  super(); } public Student(String name, int age){  super();  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{  this.age = age; } @Override  public String toString() {  return "Student [name = " + name +",age = " + age + "]"; } @Override public int hasCode() {  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 =  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(Student o){  int temp = this.age - o.age;    return temp == 0? this.name.compareTo : temp; }}

TreeMap

public class TreeMapDemo{ public static void main(String[] args){   Map<Student, String> map = new TreeMap<Student, String>(new ComparatorByName; // 添加元素 map.put(new Student("da",12), "1"); map.put(new Student("shu",13), "2"); map.put(new Student("dashu",14), "3"); // 取出数据 for(Map.Entry<String,String> m : map.entrySet{  Student key = m.getKey();  String value = m.getValue();  System.out.println(key + " : " + value); } }}

public class ComparatorByName implements Comparator<Student>{ @Override public int compare(Student o1, Student o2){  int temp = o1.getName().compareTo(o2.getName;  return temp == 0 ? o1.getAge() - o2.getAge() : temp; }}

           * LinkedHashMap

04

实例:

public class CollectionsDemo {   public static void main(String[] args) {      Map m = new HashMap();       m.put("da", "8");      m.put("shu", "9");      m.put("dashu", "10");      m.put("dashucoding", "12");      System.out.println;   }}

Java Map 集合类

最常用的会集类便是ListMapList的落实类包涵ArrayListVector,能够变大小的列表,符合构建,存储,和操作任何类型对象元素的列表。

Map是比较通用的,Map集合类是用来存储成分对的,为键-值对,各种键映射到三个值,从掌握上可以将List作为数值键的Map,但双边未有啥样关联。

有着键值对 — entrySet()
所有键 — keySet()
值 — values()

Iterator keyValues = map.entrySet().iterator();Iterator keys = map.keySet().iterator();Iterator values = map.values().iterator();

entrySet():返回 Map 中所包罗 映射 的 Set 视图。
keySet():返回 Map 中所富含 键 的 Set 视图。
values():返回 Map 中所富含 值 的 Collection 视图。

现在余生,唯独有你
简书小编:吴孟达(Ng Man Tat)同志小生
90后秀气小伙,非凡的支出习贯;独立观念的力量;主动况兼擅长调换
简书博客:

          * IdentityHashMap

结语

  • 下边我将三回九转对 别的知识 深刻讲明 ,有意思味能够继续关注
  • 小礼品走一走 or 点赞

          * TreeMap

          * WeakHashMap

          * ConcurrentHashMap

   2. 专项使用 Map ,您常常不必亲自创制此类 Map ,而是经过一些别的类对其开展访谈

          * java.util.jar.Attributes

          * javax.print.attribute.standard.PrinterStateReasons

          * java.security.Provider

          * java.awt.RenderingHints

          * javax.swing.UIDefaults

   3. 四个用以救助完毕您本人的 Map 类的抽象类

          * AbstractMap

 

接口中的首要方法如下:

1,  覆盖的格局

equals(Object o)               // 相比钦点对象与此 Map 的等价性

hashCode()                     // 再次来到此 Map 的哈希码

 

2,  Map 更新方法,可以更换 Map 的剧情。

put(Object key, Object value)  // 增加键值对,若键已存在,则覆盖旧值。

putAll(Map t)               // 将点名 Map 中的全体映射复制到此 map

remove(Object key)             // 从 Map 中除去与 key 关联的 value

clear()                       // 从 Map 中删去全数映射

 

3,  再次来到视图的 Map 方法:使用那些办法重返的指标,你能够遍历和删除 Map 的成分。

Set keySet()                // 再次回到 Map 中所满含键的 Set 视图。

// 删除 Set 中的 key 成分还将去除 Map 中相应的绚烂(键和值)

Collection values()         // 重临 map 中所满含值的 Collection 视图。

// 删除 Collection 中的 value 成分还将去除 Map 中相应的投射(键和值)

Set
entrySet()             // 再次回到 Map 中所包罗映射的 Set 视图(键值对)。

Set 中的每种元素都以一个 Map.Entry 对象,可以使用 getKey() 和 getValue() 方法(还会有四个 setValue() 方法)访谈 Map.Entry 对象的键成分和值成分

 

关于 Map.Entry 接口

Map 的 entrySet() 方法重临二个兑现 Map.Entry 接口的靶子会集。群集中每一个对象都以底层 Map 中八个一定的键 / 值对。通过这些集合的迭代器,您可以取得每八个条款 ( 独一得到格局 ) 的键或值并对值进行改变。

(1) Object getKey(): 重临条目款项标要紧字

   (2) Object getValue(): 重返条约标值

   (3) Object setValue(Object
value): 将相关印象中的值改为 value ,何况重回旧值

当条约通过迭代器重临后,除非是迭代器自个儿的 remove() 方法可能迭代器再次来到的条文的 setValue() 方法,其他对源 Map 外界的修改都会促成此条目集变得不算,同临时候发出条款行为未定义。

 

4858.com ,4,  Map 访谈和测量检验方法:那些点子寻找有关 Map 内容的新闻但不更动 Map 内容。

get(Object
key)             // 再次来到与钦点键关联的值 及此指标,如果未有,再次回到 null 。

boolean containsKey(Object
key)     // 即便 Map 包蕴钦定键的投射,则赶回 true

boolean containsValue(Object
value)  // 若此 Map 将叁个或三个键映射到内定值,重回 true

isEmpty()                // 假若 Map 不富含键 – 值映射,则赶回 true

int size()                  // 再次回到 Map 中的键 – 值映射的多少

 

 

大致全数通用 Map 都利用哈希映射。 那是一种将成分映射到数组的特简单的体制,您应询问哈希映射的劳作规律,以便丰硕利用 Map 。

哈希映射结构由一个囤积成分的里边数组组成。 由于在那之中选取数组存储,因而一定期存款在三个用于鲜明自便键访谈数组的目录机制。 实际上,该机制亟待提供三个低于数组大小的整数索引值(即余数)。 该机制称作哈希函数。 在 Java 基于哈希的 Map 中,哈希函数将对象调换为二个切合内部数组的整数。您不用为寻觅一个轻易使用的哈希函数而大伤脑筋: 种种对象都包涵一个回去整数值的 hashCode() 方法。 要将该值映射到数组,只需将其转移为三个正在,然后在将该值除以数组大小后取余数就可以。

哈希函数将随机对象映射到八个数组地点,但假诺五个不一致的键映射到一样的岗位,景况将会如何? 那是一种自然产生的事态。 在哈希映射的术语中,那称作争论。 Map 管理那一个争持的主意是在索引地点处插入三个链接列表,并简要地将成分增加到此链接列表。

 

图示:

  4858.com 3

迭代器(Iterator)

  迭代器是一种设计情势,它是三个指标,它可以遍历并采用种类中的对象,而开采人士无需明白该种类的平底结构。迭代器常常被叫做“轻量级”对象,因为创建它的代价小。

  Java中的Iterator成效相比较轻易,何况不得不单向活动:

  (1)
使用格局iterator()须要容器重返二个Iterator。第贰回调用Iterator的next()方法时,它回到种类的率先个要素。注意:iterator()方法是java.lang.Iterable接口,被Collection承袭。

  (2)
使用next()得到体系中的下八个成分。

  (3)
使用hasNext()检查种类中是或不是还恐怕有元素。

  (4)
使用remove()将迭代器新回到的要素删除。

  Iterator是Java迭代器最简便的贯彻,为List设计的ListIterator具备更加的多的意义,它能够从多个样子遍历List,也足以从List中插入和删除成分。

  

 

  List接口有四个有意识的主意,listIterator。

   使用Iterator迭代器短处:

 

    1. ListIterator有add()方法,能够向List中丰盛对象,而Iterator不可能

  2. ListIterator和Iterator都有hasNext()和next()方法,能够兑现顺序向后遍历,不过ListIterator有hasPrevious()和previous()方法,能够实现逆向(顺序向前)遍历。Iterator就不可以。

  3. ListIterator得以一定当前的目录地方,nextIndex()和previousIndex()能够兑现。Iterator未有此功效。

  4. 都可达成删除对象,不过ListIterator能够兑现指标的修改,set()方法可以兑现。Iierator仅能遍历,不可能修改。

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有