Map接口、Entry键值对对象、可变参数、HashMap存储自定义、静态导入、Collections集合工具、集合嵌套

Map接口

map 常用集合HashMap集合、LinkedHashMap集合

HashMap<k,v>:存储数据用哈希表，元素存取顺序不能保证一致，哈希表可保证键的唯一、不重复，需要写hashCode()方法、equals()方法。

LinkedHashMap<k,v> :HashMap的子类，存储数据用哈希表结构+链表结构。链表结构保证元素存储顺序一致，哈希表结构保证键的唯一、不重复，需要写hashCode()、equals()

注：Map接口的集合都有两个泛型变量<k,v>,使用时为两个泛型变量赋予数据，<k,v数据可以相同，或不同>

Collection 集合只能存一列 是孤立存在（单身）单列集合

Map集合：双列集合。元素成对存在(夫妻)。 是key和value  组成，一个位置存两个值，通过键可找对所对应的值。

注意：键不可重复，每个键值能对应一个值 map是无下标  （set原理：重写哈希code和equals方法） 值可重复

Map接口中的常用方法

get（）：获取指定键对应的值

put（）:将指定的键与值对应起来，并添加到集合中，返回对应的值，无的话返回null

remove（）：移除

 Map集合遍历键找值方式

 keyset（）；取每一列的键

思路：

1.获取Map集合中所有键，键是唯一，返回一个Set集合存储所有的键

2.遍历键的Set集合，得到每一个键

3.根据键，获取键所对应的值

package com.oracle.demo01;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
//Map接口
public class Demo01 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        map.put("1","a");    
        map.put("2","a");    
        map.put("3","b");    
        map.put("3","c");
        //删除元素
        map.remove("3");//写的是key  就等于删除的是值
        /*//System.out.println(map.get("3"));
    //keySet  用增强for遍历集合
        //1.获取所有key的Set集合
        Set<String> set=map.keySet();
        //2.遍历Set集合取到每一个key
        for(String key:set){
            //根据每个key获取每个值
            System.out.println(key+"..."+map.get(key));
        }*/
    //keyset遍历集合 用（迭代器遍历）
        //1.获取所有key的集合
        Set<String> set=map.keySet();
        //2.获取迭代器对象
        Iterator<String> it=set.iterator();
        //3.判断容器中是否有值
        while(it.hasNext()){
            //获取每一个key值
            String key=it.next();
            //根据key值获取每一个Value值
            System.out.println(key+"..."+map.get(key));
        }
    }
}

Entry键值对对象：Map.Entry<K,V>

思路

1.获取集合中所有的键值对(Entry)对象，返回Set  

2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象

3.通过键值对(Entry)对象，获取Entry中的键与值

getKey()    返回Entry对象中的键

getValue()  返回Entry对象中的值

entrySet() 用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回

package com.oracle.demo01;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
//Entry
public class Demo02 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        map.put("1","a");    
        map.put("2","a");    
        map.put("3","b");    
        map.put("3","c");
        //entrySet遍历（增强for）
        //1.获取所有结婚证对象存在的Set集合
        Set<Map.Entry<String,String>> set=map.entrySet();
        //2.遍历所有结婚证取到每一个结婚证
        for(Map.Entry<String,String> entry:set){
            //3.通过每一个结婚证对象获取key
            String key=entry.getKey();
            //4.通过每一个结婚证对象获取value
            String value=entry.getValue();
            System.out.println(key+"..."+value);
        }
    }
}

pm

HashMap存储自定义类型键值

1、当给HashMap中存放自定义对象时，如果自定义对象是键存在，保证键唯一，必须复写对象的hashCode和equals方法。

2、如果要保证map中存放的key和取出的顺序一致，可使用LinkedHashMap集合来存放

package com.oracle.demo01;

public class Person {
    private String name;
    private int age;    
    public Person(String name, int age) {
        super();
        //有参构造
        this.name = name;
        this.age = age;
    }//无参构造
    public Person() {
        super();
    }
    //get  set
    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;
    }
    //toString方法
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @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;
    }
    //哈西和equals
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) 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;
    }    
}
---------------------------------------------
package com.oracle.demo01;
//HashMap存储自定义类型键值
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo03 {
    public static void main(String[] args) {
        Map<Person,String> map=new HashMap<Person,String>();
        map.put(new Person("胸大",22),"java0322班");
        map.put(new Person("胸二",20), "java0222班");
        map.put(new Person("胸二",20), "java0262班");
        //遍历
        //1.获取装有所有key的Set集合
        Set<Person> set=map.keySet();
        //2.遍历set集合取到每一个key
        for(Person key:set){
            System.out.println(key+"..."+map.get(key));
        }
    }
}

LinkedHashmap

package com.oracle.demo01;
//LinkedHashmap
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class Demo04 {
    public static void main(String[] args) {
        Map<String,Person> map=new LinkedHashMap<String,Person>();
        //添加数据
        map.put("java0322",new Person("胸三",33));
        map.put("java0222",new Person("胸大",33));
        map.put("java0611",new Person("胸三",33));
        //遍历(entrySet迭代器)
    //1.获取所有结婚证存在的集合
        Set<Map.Entry<String,Person>> set=map.entrySet();
        //2.获取迭代器对象 
        Iterator<Map.Entry<String,Person>> it=set.iterator();
        //3.循环判断下个元素是否有值
        while(it.hasNext()){
            //4.获取每一个结婚证对象
            Map.Entry<String, Person> entry=it.next();
            //5.从结婚证对象中获取key
            String key=entry.getKey();
            //6.从结婚证对象中获取value
            Person value=entry.getValue();
            System.out.println(key+"..."+value);
        }
    }
}

静态导入     格式：

import static XXX.YYY;   导入后YYY可直接使用

package com.oracle.demo01;
import static java.lang.System.out;
import static java.lang.Math.PI;
public class Jingtai {
    public static void main(String[] args) {
        out.println("你好");
        out.println("Hello");
        out.print(2*PI);
    }
}

可变参数

修饰符 返回值类型 方法名(参数类型... 形参名){  }  = 修饰符 返回值类型 方法名(参数类型[] 形参名){  }

后面这种定义，在调用时必须传递数组，前者可以直接传递数据

package com.oracle.demo01;
//可变参数
public class Kebiancanshu {
    public static void main(String[] args) {
        int sum=add(1,2);
        System.out.println(sum);
    }
    //写方法，计算整数参数的和
    public static int add(int...a){
        int sum=0;
        //增强for
        /*for(int i:a){
            sum=sum+i;
        }        
        return sum;*/
        //或者用 for也可以实现  
        //获取长度
        for(int i=0;i<a.length;i++){
            sum=sum+a[i];
        }
        return sum;
    }

}

注意问题：

如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置

Collections集合工具类

shuffle()    随机置换（只能传list)

sort()    集合元素升序排列

package com.oracle.demo01;
import java.util.ArrayList;
import java.util.Collections;
//Collections集合工具 shuffle打乱顺序
public class Collections集合工具 {
    public static void main(String[] args) {
        ArrayList<String> arr=new ArrayList<String>();
        arr.add("a");
        arr.add("b");
        arr.add("c");
        arr.add("d");
        //增强for
        for(String s:arr){
            System.out.print(s+"  ");
        }
        System.out.println();
        //打乱集合中的元素顺序
        Collections.shuffle(arr);
        for(String s:arr){
            System.out.print(s+"  ");
        }
        System.out.println();
        //排序
        Collections.sort(arr);
        for(String s:arr){
            System.out.print(s+"  ");
        }
    }
}

集合嵌套

package com.oracle.demo01;
//集合嵌套
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Jihe嵌套 {
    public static void main(String[] args) {
        HashMap<String,HashMap<Person,String>> map=new HashMap<String, HashMap<Person,String>>();
        //第一个小map
        HashMap<Person,String> map1=new HashMap<Person,String>();
        map1.put(new Person("袁移民",21),"java0322");
        map1.put(new Person("韩振宇",21),"java0322");
        //第二个小map
        HashMap<Person,String> map2=new HashMap<Person,String>();
        map2.put(new Person("阿斯蒂芬",21),"java03");
        map2.put(new Person("大剁手党",21),"php0705");
        //向大的map中存数据
        map.put("java班",map1);
        map.put("php班",map2);
    //用增强for遍历
        //1.获取大map中所有的key所在的set集合
        Set<String> bigkeys=map.keySet();
        //2.遍历所有key取到每一个key
        for(String bigkey:bigkeys){
        //根据bigkey获取小map对象得value值
        HashMap<Person,String> smallmap=map.get(bigkey);
        //3.在走1.获取小map中所有的key所在的set集合
        Set<Person> smallkeys=smallmap.keySet();
        //2.遍历小map中所有的key取到每一个key
        for(Person smallkey:smallkeys){
        //3.根据smallkey获取对应的value值
        System.out.println(bigkey+"..."+smallkey+"..."+smallmap.get(smallkey));
        }            
    }
    //2.用迭代器遍历
        //获取大的Key集合
        /*Set<String> bigkeys=map.keySet();
        //获取迭代器对象
        Iterator<String> bigkey=bigkeys.iterator();
        //判断
        while(bigkey.hasNext()){
        //获取迭代器中每个key值
        String bigkey1=bigkey.next();
        //根据bigkey1获取小的对象
        HashMap<Person,String> smallmap=map.get(bigkey1);
        //获取小的key的集合
        Set<Person> smallkeys=smallmap.keySet();
        //获取迭代器对象
        Iterator<Person> smallkey=smallkeys.iterator();
        //判断
        while(smallkey.hasNext()){
        //获取每个小key
        Person smallkey1=smallkey.next();
            System.out.println(bigkey1+"..."+smallkey1+"..."+smallmap.get(smallkey1));
            }
        }*/
    //3.EntrySet遍历（增强for遍历）
        //获取大的键值对所在的集合
        /*Set<Map.Entry<String,HashMap<Person,String>>> bigkeys=map.entrySet();
            //增强for循环遍历
            for(Map.Entry<String,HashMap<Person,String>> entry:bigkeys){
                //通过每个键值对获取每个大key
                String bigkey=entry.getKey();
                //获取每个小Map
                HashMap<Person,String> smallmap=entry.getValue();
                //获取每个小map的小key所在的集合
                Set<HashMap.Entry<Person,String>> smallkeys=smallmap.entrySet();
                //增强for
                for(HashMap.Entry<Person,String> smallkey:smallkeys){
                    //获取每个小key
                    Person smallkey1=smallkey.getKey();
                    //获取每个value
                    String value =smallkey.getValue();
                    System.out.println(bigkey+"..."+smallkey+"..."+value);
                    }    
                }*/
        //4、EntrySet迭代器遍历
                //获取大的键值对所在的集合
                Set<Map.Entry<String,HashMap<Person,String>>> bigmaps=map.entrySet();
                //获取迭代器对象
                Iterator<Map.Entry<String,HashMap<Person,String>>> bigmap=bigmaps.iterator();
                //判断
                while(bigmap.hasNext()){
                    //获得每一个键值对
                    Map.Entry<String,HashMap<Person,String>> bigmap1=bigmap.next();
                    //获取大key
                    String bigkey=bigmap1.getKey();
                    //获取小map
                    HashMap<Person,String> smallmap=bigmap1.getValue();
                    //获取小的键值对所在的集合
                    Set<HashMap.Entry<Person,String>> smallkeys=smallmap.entrySet();
                    //获取迭代器对象
                    Iterator<HashMap.Entry<Person,String>> smallkey=smallkeys.iterator();
                    //判断
                    while(smallkey.hasNext()){
                        //获取小键值对
                        HashMap.Entry<Person,String> smallkey1=smallkey.next();
                        //获取小key
                        Person smallkey2=smallkey1.getKey();
                        //获取小value
                        String value=smallkey1.getValue();
                        System.out.println(bigkey+"..."+smallkey1+"..."+value);
                    }
                }
    }
}