2019-05-28 Java学习日记 day18

集合框架

Map集合

　　将键映射到值的对象

　　一个映射不能包含重复的键

　　每个键最多只能映射到一个值

Map接口和Collection接口的不同

　　map是双列的。collection的单列的

　　map的键唯一，collection的子体系set是唯一的

　　map集合的数据结构值针对键有效，跟值无关，collection集合的数据结构是针对元素有效

map集合功能

*添加功能：

　　*V put（K key，V value）：添加元素

　　　　*如果键是第一个存储，就直接存储元素，返回null

　　　　*如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值

*删除功能

　　*void clear（）：移除所有的键值对元素

　　*V remove（object key）：根据键删除键值对元素，并把值返回

*判断功能

　　*boolean containsKey（object key）：判断集合是否包含指定的键

　　*boolean containsValue（object value）：判断集合是否包含指定的值

　　*boolean isEmpty（）：判断集合是否为空

*获取功能

　　*Set<Map.Entry<K.V>> entrySet（）：

　　*V get（object key）：根据键获取值

　　*set<K> keySet（）：获取集合中所有键的集合

　　*Collection<V> values（）：获取集合中所有值的集合

*长度功能

　　*int size（）：返回集合中的键值对的个数　　

public class demo2_Iterator {

    public static void main(String[] args) {
        Map<String, Integer> map=new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("六六", 26);
        
        Integer i1=map.get("张三"); //根据键获取值
        System.out.println(i1);
        
        //获取所有的键
        /*Set<String> keyset=map.keySet();  //获取所有键的集合
        Iterator<String> it1=keyset.iterator(); //获取迭代器
        while (it1.hasNext()) {                //判断集合中是个有元素
            String key=it1.next();            //获取每一个键
            Integer value =map.get(key);    //根据键卓取值
            System.out.println(key+","+value);
            
        }*/
        
        //使用增强for循环
        for(String key :map.keySet()){  //map.KeySet（）是所有键的集合
            System.out.println(key+"="+map.get(key));
        }
    }

}

public class demo3_Iterator {
    /*Map集合的第二种迭代，根据键值对对象，获取获取键和值
     * 键值对对象找键和值的思路：
     *     获取所有键值对对象的集合
     *     遍历键值对对象的集合，获取到每一个键值对对象
     *     根据键值对对象找键和值
     * */
    public static void main(String[] args) {
        Map<String, Integer> map=new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("六六", 26);
        
        //map.entry说明entry是map的内部接口，将键和值封装成了entry对象，并存储在set集合中
        //Set<Map.Entry<String, Integer>> en1=map.entrySet();
        
        /*//获取每一个对象
        Iterator<Map.Entry<String, Integer>> it1=en1.iterator();
        while (it1.hasNext()) {
        //获取每一个entry对象
            Map.Entry<String, Integer> en=it1.next();
            String key=en.getKey();  //根据键值对对象获取键
            Integer in1=en.getValue();    //根据键值对对象获取值
            System.out.println(key+"="+in1); 
        }*/
        for(Map.Entry<String, Integer> en:map.entrySet()){
            System.out.println(en.getKey()+"="+en.getValue());
        }

    }

}

 

统计字符串中每个字符出现的次数

public class test1 {

    public static void main(String[] args) {
        //定义一个需要被统计字符的字符串
        String s="aabbccccccbdbshcbd";
        
        //将字符串转换为字符数组
        char[] arr=s.toCharArray();
        
        //定义双列集合，存储字符串中字符以及字符出现的次数
        HashMap<Character, Integer> hm1=new HashMap<>();
        
        //遍历字符数组获取内一个字符，并将字符存储在双列集合中
        for(char c:arr){
            //存储过郑重要做判断，如果集合不包含这个键，就将该字符当作键，值为1存储，如果集合中包含这个键，就将值加1存储
            /*if(!hm1.containsKey(c)){  //如果不包含这个键
                hm1.put(c, 1);
                
            }else {
                hm1.put(c, hm1.get(c)+1);
            }*/
            hm1.put(c, !hm1.containsKey(c) ? 1: hm1.get(c)+1);
                   //如果不包含 就存1 ，包含就值+1存进去
        }

        //打印双列集合获取字符出现的次数
        for (Character key : hm1.keySet()) {     //hm1.keyset()代表所有键的集合
            System.out.println(key+ "="+hm1.get(key));    //hm1.get（key）根据键获取值
        }
    }

}

HashSet嵌套HashSet

public class test2 {

    public static void main(String[] args) {
        HashMap<Student, String> hm1 =new HashMap<>();
        hm1.put(new Student("张三",23), "北京");
        hm1.put(new Student("李四",24), "上海");
        hm1.put(new Student("王五",23), "广州");
        hm1.put(new Student("六六",23), "深圳");
        
        
        HashMap<Student, String> hm2 =new HashMap<>();
        hm2.put(new Student("美丽",18), "马来西亚");
        hm2.put(new Student("漂亮",17), "印度尼西亚");
        hm2.put(new Student("beautiful",19), "广州");
        hm2.put(new Student("靓靓",20), "深圳");
        
        HashMap<HashMap<Student, String>,String> hm =new HashMap<>();
        hm.put(hm1, "第一期学生");
        hm.put(hm2, "第二期学生");
        
        //遍历双列集合
        for (HashMap<Student, String> h : hm.keySet()) {
            String value =hm.get(h);  //get（h）根据键对象获取值对象
            System.out.println(value);
            //遍历键的双列集合对象
            for(Student key : h.keySet()){  //h.keyset（）获取集合总所有的学生键对象
                String value2=h.get(key);
            
                System.out.println(key+","+value2+","+value);
                
            }
            
        }
    }

}

 

HashMap和Hashtable

public class demo8_Hashtable {

        /*hashMap和Hashtable的区别
         * 共同点：
         *     底层都是哈希算法，都是双列集合
         * 区别：
         *     HashMap是线程不安全的，效率高，JDK1.2版本
         *     Hashtable是线程安全的，效率低，JDK1.0版本
         *  
         *  HashMap可以存储null键和null值
         *  Hashtable不可以存储null键和null值
         * */
    public static void main(String[] args) {
        HashMap<String, Integer> hm =new HashMap<>();
        hm.put(null, 23);
        hm.put("李四", null);
        System.out.println(hm);
        
        Hashtable<String, Integer> ht =new Hashtable<>();
        ht.put(null, 23);
        System.out.println(ht);

    }

}

Collection

针对集合操作 的工具类

Collecitons中的常见方法
public static <T> void sort(List<T> list)
public static <T> int binarySearch(List<?> list,T key)
public static <T> T max(Collection<?> coll)
public static void reverse(List<?> list)
public static void shuffle(List<?> list)

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

public class demo1_Collection {

    public static void main(String[] args) {
        //demo1();
        //demo2();
        //demo3();
        //demo4();
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("f");
        list.add("g");
         Collections.shuffle(list);
         System.out.println(list);  //随机置换，可以洗牌
    }

    public static void demo4() {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("f");
        list.add("g");
        Collections.reverse(list);
        System.out.println(list);  //反转字符串
    }

    public static void demo3() {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("f");
        list.add("g");
        System.out.println(Collections.max(list)); //根据排序结果获取最大值
    }

    public static void demo2() {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("f");
        list.add("g");
        System.out.println(Collections.binarySearch(list, "c")); //查找字符串位置
        System.out.println(Collections.binarySearch(list, "e"));
    }

    public static void demo1() {
        ArrayList<String> list = new ArrayList<>();
        list.add("c");
        list.add("d");
        list.add("d");
        list.add("b");
        list.add("a");
        list.add("d");
        
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
    }

}

斗地主洗牌

public class test3 {

    public static void main(String[] args) {
        String [] num= {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        String [] color={"红桃","黑桃","方片","梅花"};
        ArrayList<String> poker = new ArrayList<>();
        
        //并接花色和数字
        for(String s1 :color){
            for(String s2 : num){
                poker.add(s1.concat(s2));  //cancat连接两个字符串
            }
        }
        poker.add("小王");
        poker.add("大王");
        //洗牌
        Collections.shuffle(poker);
        //发牌
        ArrayList<String> tan = new ArrayList<>();
        ArrayList<String> jung = new ArrayList<>();
        ArrayList<String> jun = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();
        
        for (int i = 0; i < poker.size(); i++) {
            if ( i >=poker.size()-3) {
                dipai.add(poker.get(i));  //将三张底牌存储在底牌集合中
            } else if(i % 3==0){
                tan.add(poker.get(i));
            }else if(i % 3 ==1){
                jung.add(poker.get(i));
            }else{
                jun.add(poker.get(i));
            }
        }
        //看牌
        System.out.println(tan);
        System.out.println(jung);
        System.out.println(jun);
        System.out.println(dipai);
    }

}

import java.awt.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

import javax.swing.event.TreeSelectionEvent;

public class test4 {
    public static void main (String args []){
        String [] num= {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        String [] color={"红桃","黑桃","方片","梅花"};
        HashMap<Integer, String> hm =new HashMap<>(); //存储索引和扑克牌
        ArrayList<Integer> list = new ArrayList<>(); //存储索引
        int index =0;
        
        //拼接扑克牌并索引和扑克牌存储在hm中
        for(String s1: num){  //获取数字
            for(String s2 : color){ //获取颜色
                hm.put(index, s2.concat(s1));
                list.add(index);   //将索引0到51添加到list集合
                index++;
            }
        }
        //将小王添加到双列集合中
        hm.put(index, "小王");
        list.add(index);  //将52索引添加到集合中
        index++;
        hm.put(index, "大王");
        list.add(index);    //将53索引添加到集合中
        
        //洗牌
        Collections.shuffle(list);
        
        //发牌
        TreeSet<Integer> tan = new TreeSet<>();
        TreeSet<Integer> jung = new TreeSet<>();
        TreeSet<Integer> jun = new TreeSet<>();
        TreeSet<Integer> bootom = new TreeSet<>();
        
        for (int i = 0; i < list.size(); i++) {
            if (i>=list.size() - 3) {
                bootom.add(list.get(i));   //将三张底牌存储在底牌集合中
            }else if(i %3 ==0){
                tan.add(list.get(i));
            }else if (i % 3 == 1) {
                jung.add(list.get(i));
            }else {
                jun.add(list.get(i));
            }
        }
        //看牌
        lookpoker(hm, tan, "谭某");
        lookpoker(hm, jung, "某人");
        lookpoker(hm, jun, "俊");
        lookpoker(hm, bootom, "底牌");
        
    }
    public static void lookpoker(HashMap<Integer, String> hm,TreeSet<Integer> ts,String name){
            System.out.print(name+"的牌是: ");
            for (Integer i :ts) {   //i代表双列集合中的每一个键
                System.out.print(hm.get(i)+" ");
            }
            System.out.println();
        }
}

 

泛型固定下边界

import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;

import tan.jung.test.BaseStudent;
import tan.jung.test.Student;
        /* 泛型固定下边界
         *  ？ super E
         * 泛型固定上边界
         *     ？ extends E
         * */
public class demo2_Genric {

    public static void main(String[] args) {
        //demo();
        TreeSet<Student> ts1 =new TreeSet<>(new CompareByAge());
        ts1.add(new Student("张三",23));
        ts1.add(new Student("里斯",18));
        ts1.add(new Student("王五",25));
        ts1.add(new Student("赵六",13));
        ts1.add(new Student("好奇",33));
        System.out.println(ts1);
        
        TreeSet<BaseStudent> ts2 =new TreeSet<>(new CompareByAge());
        ts2.add(new BaseStudent("张三",23));
        ts2.add(new BaseStudent("里斯",18));
        ts2.add(new BaseStudent("王五",25));
        ts2.add(new BaseStudent("赵六",13));
        ts2.add(new BaseStudent("好奇",33));
        System.out.println(ts2);
    }

    public static void demo() {
        ArrayList<Student> list1 =new ArrayList<>();
        list1.add(new Student("张三",23));
        list1.add(new Student("李四",24));
        
        ArrayList<BaseStudent> list2 =new ArrayList<>();
        list2.add(new BaseStudent("四四",23));
        list2.add(new BaseStudent("1四",24));
        
        list1.addAll(list2);
    }

}
class CompareByAge implements Comparator<Student>{

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