Java 集合三 Map相关

Map

1、双列集合的的顶层接口（k,v）

2、描述一个数据到另一个数据的映射

3、map的特点：

　　1、Key是唯一的，value不是惟一的，Value会发生覆盖现象

　　2、每个key对应的是唯一的值

4、map与collection的区别：

　　1、map是双列集合，collection是单列集合

　　2、map的键唯一，collection的子接口set的元素值唯一

　　3、Set的底层结构是map

5、常用方法：

　　1、增 put(K key ,V value)

　　2、删 remove(K key) clear()

　　3、获取方法 size()  get()

　　4、判断方法：　containsKey(Object key)  containsValue(V value)

6、map的遍历

　　1、keySet()  得到一个所有key的Set集合，可以通过遍历集合获取键的值

　　2、entrySet() 得到一个键值对一体的Set集合（Map.Entry）,通过遍历集合，使用getKey()获取键，getValue()获取值

7、练习

/*
 * 001 Person(name age)
 * 002 Person(name age)
 *    使用Map的两种遍历方式分别遍历
 */
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Demo02 {

    public static void main(String[] args) {
        Map<String,Person> map = new HashMap<>();
        map.put("001", new Person("qq",20));
        map.put("002", new Person("ww",22));
        map.put("003", new Person("33",32));
        printAll1(map);
        System.out.println("===================");
        printAll2(map);
    }
    public static void printAll1(Map<String,Person> map) {
        Set<String> set = map.keySet();
        for(String i:set) {
            Person p = map.get(i);
            System.out.println(i+" "+"Person("+p.name+" "+p.age+")");
        }
    }
    public static void printAll2(Map<String,Person> map) {
        Set<Entry<String, Person>> set = map.entrySet();
        Iterator<Entry<String, Person>> iterator = set.iterator();
        while(iterator.hasNext()) {
            Entry<String, Person> next = iterator.next();
            System.out.println(next.getKey()+" "+"Person("+next.getValue().name+" "+next.getValue().age+")");
        }
    }
}
class Person{
    String name;
    int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
}

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

/*
 * 键盘录入字符，最后打印成aaabbcccdsflkhdddd  拼接样式使用StringBuilder
 */
public class Demo03 {
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s1 = sc.nextLine();
        Map<Character,Integer> map = new TreeMap<Character, Integer>();
        for(int i=0;i<s1.length();i++) {
            if(map.containsKey(s1.charAt(i))) {
                                //如果键值已经存在，则key值+1
                map.put(s1.charAt(i), map.get(s1.charAt(i))+1);
            }else {
                map.put(s1.charAt(i), 1);
            }        
        }
        printAll(map);
        sc.close();
    }
    
    public static void printAll(Map<Character,Integer> map) {
        Set<Character> set = map.keySet();
        StringBuilder sb = new StringBuilder();
        for(Character i:set) {
            sb.append(i+"("+map.get(i)+")");
        }
        System.out.println(sb.toString());
    }

}        

8、HashMap

　　哈希表     HashSet的底层是HashMap  HashSet和HashMap的键一列保证元素唯一的保证方式一样。

　　hashCode()  equals()

9、TreeMap 二叉树

　　TreeSet的底层是TreeMap  TreeSet的元素唯一和TreeMap键一列保证元素唯一方式是一致，有两种方式

　　　　一种是元素本身具有比较性

　　　　另一种是集合具有比较性

10、LinkedHashMap

　　是HashMap的子类，存储和取出顺序一致

11、HashMap和Hashtable的关系

　　1.都是使用哈希表来存储数据
　　2.不同点：
　　　　1.版本不同：Hashtable jdk1.0 HashMap jdk1.2
　　　　2.线程安全程序不同：Hashtable是线程安全的，HashMap是线程不安全的。
　　　　3.Hashtable不能存储null键和null值，HashMap可以
　　　　4.命名规则不同：Hashtable早期没有形成严格命名规范。

12、Collections工具类常用方法

　　1.binarySearch(List<? extends Comparable<? super T>> list, T key)//使用二分搜索法搜索指定列表，以获得指定对象。
　　2.frequency(Collection<?> c, Object o)//返回指定 collection 中等于指定对象的元素数。
　　3.max min//最大值、最小值
　　4.replaceAll(List<T> list, T oldVal, T newVal)//使用另一个值替换list列表中出现的所有某一指定值
　　5.fill(List<? super T> list, T obj)//使用指定元素替换指定列表中的所有元素。
　　6.reverse(List<?> list)//反转指定列表中元素的顺序。
　　7.shuffle(List<?> list)//使用默认随机源对指定列表进行置换。
　　8.swap(List<?> list, int i, int j)//在指定列表的指定位置处交换元素
　　9.sort(List<T> list, Comparator<? super T> c) //根据指定比较器产生的顺序对指定列表进行排序。
　　10.sort(List<T> list) //根据元素的自然顺序 对指定列表按升序进行排序

//模拟三人斗地主
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class PlayPuKe {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<String> list = new ArrayList<>();
        String[] str1 = {"黑桃","红桃","梅花","方块"};
        String[] str2 = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

        for(int i=0;i<str1.length;i++){
            for(int j=0;j<str2.length;j++) {
                list.add(str1[i]+str2[j]);
            }
        }
        list.add("大王");
        list.add("小王");
        Collections.shuffle(list);
        playForThree(list);
        
        
    }
    public static void playForThree(List<String> list) {
        Set<String> p1 = new TreeSet<>(new MyCompare());
        Set<String> p2 = new TreeSet<>(new MyCompare());
        Set<String> p3 = new TreeSet<>(new MyCompare());
        Set<String> dipai = new TreeSet<>(new MyCompare());
        add(list,p1,p2,p3,dipai);
        Random r = new Random();
        int result = r.nextInt(3)+1;
        if(result==1) {
            p1.addAll(dipai);
        }else if(result==2) {
            p2.addAll(dipai);
        }else {
            p3.addAll(dipai);
        }
        System.out.println("玩家1:"+p1);
        System.out.println("玩家2:"+p2);
        System.out.println("玩家3:"+p3);
        System.out.println("底牌:"+dipai);
    }
    public static void add(List<String> list,Set<String> s1,Set<String> s2,Set<String> s3,Set<String> s4) {
        for(int i=0;i<51;i+=3) {
            s1.add(list.get(i));
            s2.add(list.get(i+1));
            s3.add(list.get(i+2));
        }
        for(int i=53;i>50;i--) {
            s4.add(list.get(i));
        }
    }
    
}
class MyCompare implements Comparator<String>{
    @Override
    public int compare(String o1, String o2) {
        if(o1.length()==3&&o2.length()==3) {
            return new Character(o1.charAt(2)).compareTo(new Character(o2.charAt(2)))>=0?1:-1;
        }else if(o1.length()>3&&o2.length()<=3) {
            return -1;
        }else if(o1.length()<=3&&o2.length()>3) {
            return 1;
        }else{
            return 1;
        }
    }
}