码迷，mamicode.com
首页 > 编程语言 > 详细

Java集合框架04

时间：2020-04-10 22:45:15      阅读：68      评论：0      收藏：0      [点我收藏+]

标签：数据   ace   iter   返回键   test   static   except   one   dip   

集合框架·Map 和 Collections集合工具类

Map集合的概述和特点

* A：Map接口概述
　　* 查看API可知：
　　　　* 将键映射到值的对象
　　　　* 一个映射不能包含重复的键
　　　　* 每个键最多只能映射到一个值

* B：Map接口和Collection接口的不同
　　* Map是双列的，Collection是单列的
　　* Map的键唯一，Collection的子体系Set是唯一的
　　* Map集合的数据结构值针对键有效，跟值无关；Collection集合的数据结构是针对元素有效
　　* Set底层依赖的是Map

技术图片 

 技术图片

 

Map集合的功能概述

* A：Map集合的功能概述
　　* a：添加功能
　　　　* V put (K key, V value)  ；添加元素
　　　　　　* 如果键是第一次存储，就直接存储元素，返回null
　　　　　　* 如果键不是第一次存储，就用替换原来的值，返回以前的值

　　* b：删除功能
　　　　* void clear() ：移除所有的键值对元素
　　　　* V remove(Object key) ：根据键删除键值对的元素，并把值返回

　　* c：判断功能
　　　　* boolean containsKey(Object key) ：判断集合是否包含指定的键
　　　　* boolean containsValue(Object value) ：判断集合是否包含指定的值
　　　　* boolean isEmpty() ：判断集合是否为空

　　* d：获取功能
　　　　* Set<Map.Entry<K, V>> entrySet()
　　　　* V get(Object key) ：根据键获取值
　　　　* Set<K> keySet() ：获取集合中所有键的集合
　　　　* Collection<V> values() ：获取集合中所有值的集合

　　* e：长度功能
　　　　* int size() ：返回集合中的键值对个数

技术图片 
package com.heima.map;

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

public class Demo1_Map {

    public static void main(String[] args) {
        // demo1(); // 添加元素
        // demo2(); // 删除元素
        // demo3();
    }

    public static void demo3() {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);

        Collection<Integer> c = map.values();
        System.out.println(c);

        System.out.println(map.size()); // 返回元素的值，一个键值对算作一个元素
    }

    public static void demo2() {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);

        Integer integer = map.remove("张三"); // 根据键删除元素，并且返回键对应的值
        System.out.println(map);
        System.out.println(integer);
        System.out.println(map.containsKey("张三")); // 判断是否包含指定键
        System.out.println(map.containsValue(24)); // 判断是否包含指定值
    }

    public static void demo1() {
        Map<String, Integer> map = new HashMap<String, Integer>(); // 创建双链集合对象
        Integer v1 = map.put("张三", 23); // 返回被覆盖的值，原先如果没有值，就返回null
        Integer v2 = map.put("李四", 24);
        Integer v3 = map.put("王五", 25);
        Integer v5 = map.put("张三", 26); // 相同的键不存储，替换值并返回原值

        System.out.println(map); //

        System.out.println(v1); // null
        System.out.println(v2); // null
        System.out.println(v3); // null
        System.out.println(v5); // 23
    }

}
Map

 

Map集合的遍历之根据键找值

* A：键找值的思路
　　* 获取所有键的集合
　　* 遍历键的集合，获取到每一个键
　　* 根据键找值

* B：案例演示
　　* Map集合的遍历之键找值

* C：Map集合不能直接迭代

技术图片

技术图片 
package com.heima.map;

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

public class Demo2_Iterator {
    // Map集合不能直接得带
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);

        Integer i = map.get("张三"); // 根据键获取值
        System.out.println(i);

        demo1(map);
        System.out.println("---------");
        demo2(map);
    }

    public static void demo2(Map<String, Integer> map) {
        // 使用增强for循环
        for (String key : map.keySet()) { // map.KeySet() 是所有键的集合
            System.out.println(key + "=" + map.get(key));
        }
    }

    public static void demo1(Map<String, Integer> map) {
        // 获取所有键, 对键的集合迭代
        
        Set<String> keySet = map.keySet(); // 获取所有键的集合
        // System.out.println(keySet);
        Iterator<String> it = keySet.iterator(); // 获取键的集合的迭代器
        while (it.hasNext()) { // 判断集合中是否有元素
            String string = (String) it.next(); // 获取每一个键
            Integer valueInteger = map.get(string);
            System.out.println(string + "=" + valueInteger);
        }
    }
}
Map

 

Map集合的遍历之通过键值对对象找键和值

* A：键值对对象找键和值的思路
　　* 获取所有键值对对象的集合
　　* 遍历键值对对象的集合，获取到每一个键值对对象
　　* 根据键值对对象找键和值

* B：案例演示
　　* Map集合的遍历之键值对对象中键和值

技术图片

 技术图片

技术图片 
package com.heima.map;

public class Demo4_MapEntry {

    public static void main(String[] args) {
        
    }
}

interface Inter {
    interface Inter2 {
        public void show();
    }
}

class Demo implements Inter.Inter2 { // 实现 接口内的接口
    @Override
    public void show() { // 重写抽象方法
        System.out.println("show");
    }
    
}
类似Entry的定义
技术图片 
package com.heima.map;

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

public class Demo3_Iterator {
    // 根据键值对对象获取键和值
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);

        // demo1(map);
        // demo2(map);
    }

    public static void demo2(Map<String, Integer> map) { // 开发中推荐使用
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }
    }

    public static void demo1(Map<String, Integer> map) {
        // Map.Entry 说明 Entry是Map接口内的接口，将 键值对 封装成Entry对象，并存储在Set集合中
        
        //Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        //Iterator<Map.Entry<String, Integer>> it = entrySet.iterator;
        Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            String key = entry.getKey(); // 根据键值对对象 获取键
            Integer value = entry.getValue(); // 根据键值对对象 获取值

            System.out.println(key + "=" + value);
        }
    }
}
Entry

 

HashMap集合键是Student，值是String的案例

* A：案例分析
　　* HashMap集合键是Student，值是String的案例

技术图片 
package com.heima.map;

import java.util.HashMap;

import com.heima.bean.Student;

public class Demo5_HashMap {

    public static void main(String[] args) {
        HashMap<Student, String> hm = new HashMap<Student, String>();
        // 键是学生对象，代表每一个学生
        // 值是字符串对象，代表学生归属地
        hm.put(new Student("张三", 23), "北京");
        hm.put(new Student("张三", 23), "杭州"); // 自定义类的对象需要重写hashCode和equals
        hm.put(new Student("李四", 24), "上海");
        hm.put(new Student("王五", 25), "广州");
        hm.put(new Student("赵六", 26), "深圳");

        System.out.println(hm);
    }
}
HashMap

 

LinkedHashMap的概述和使用

* A：案例演示
　　* LinkedHashMap的特点
　　　　* 底层是链表实现的可以保证怎么存就怎么取

技术图片

技术图片 
package com.heima.map;

import java.util.LinkedHashMap;

public class Demo6_LinkedHashMap {

    public static void main(String[] args) {
        LinkedHashMap<String, Integer> lhm = new LinkedHashMap<String, Integer>();
        lhm.put("张三", 23);
        lhm.put("李四", 24);
        lhm.put("赵六", 26);
        lhm.put("王五", 25);
        
        System.out.println(lhm);
    }
}
LinkedHashMap 

 

TreeMap集合键是Student，值是String的案例

* A：案例演示
　　* TreeMap集合键是Student，值是String的案例

技术图片

技术图片 
package com.heima.map;

import java.util.Comparator;
import java.util.TreeMap;

import com.heima.bean.Student;

public class Demo7_TreeMap {

    public static void main(String[] args) {
        // demo1(); // 类中实现comparable接口，add方法调用compareTo方法
        // demo2(); // 集合的构造方法中使用比较器comparator，add方法调用compare方法
    }

    public static void demo2() {
        TreeMap<Student, String> tm = new TreeMap<Student, String>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getName().compareTo(o2.getName());
                return num == 0 ? o1.getAge() - o2.getAge() : num;
            }
        });
        tm.put(new Student("张三", 23), "北京");
        tm.put(new Student("李四", 24), "上海");
        tm.put(new Student("赵六", 26), "深圳");
        tm.put(new Student("王五", 25), "广州");
        
        System.out.println(tm);
    }

    public static void demo1() {
        TreeMap<Student, String> tm = new TreeMap<Student, String>();
        tm.put(new Student("张三", 23), "北京");
        tm.put(new Student("李四", 24), "上海");
        tm.put(new Student("赵六", 26), "深圳");
        tm.put(new Student("王五", 25), "广州");

        System.out.println(tm);
    }
}
TreeMap

 

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

* A：案例演示
　　* 需求：统计字符串中每个字符出现的次数

技术图片 
package com.heima.test;

import java.util.HashMap;
import java.util.Scanner;

public class Test1 {
    /*
     * 分析：
     * 1、创建键盘录入对象
     * 2、录入字符串
     * 3、将字符串转换为字符数组
     * 4、定义双列集合，存储字符串中的字符以及字符出现的次数
     * 5、遍历字符数组，获取每一个字符，并将字符存储在双列集合中
     * 6、存储过程中做判断，如果集合中不包含这个键，就把这个字符作为键，值存储为1；如果包含，就将值加1存储
     * 7、打印双列集合
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in); // 创建键盘录入对象
        String line = sc.nextLine(); // 录入字符串
        char[] arr = line.toCharArray();// 将字符串转换为字符数组
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();// 没有特殊要求就用HashMap，因为它是所有Map中效率最高的
        for (char c : arr) { // 遍历字符数组，获取每一个字符
            /*if (!map.containsKey(c)) { // 如果不包含
                map.put(c, 1); // 键为字符，值为1
            } else { // 如果包含
                map.put(c, map.get(c) + 1); // 键为字符，值为原值加一
            }*/
            map.put(c, !map.containsKey(c) ? 1 : map.get(c) + 1); // 做判断，并存储
        }        
        System.out.println(map); // 打印双列集合
    }
}
Test1

 

集合框架之HashMap嵌套HashMap

* A：案例演示
　　* 集合嵌套之HashMap嵌套HashMap

技术图片 
package com.heima.map;

import java.util.HashMap;

import com.heima.bean.Student;

public class Demo8_HashMap {

    public static void main(String[] args) {
        // 定义88期基础班
        HashMap<Student, String> hm88 = new HashMap<Student, String>();
        hm88.put(new Student("张三", 23), "北京");
        hm88.put(new Student("李四", 24), "北京");
        hm88.put(new Student("王五", 25), "上海");
        hm88.put(new Student("赵六", 26), "广州");
        // 定义99期基础班
        HashMap<Student, String> hm99 = new HashMap<Student, String>();
        hm99.put(new Student("唐僧", 1023), "花果山");
        hm99.put(new Student("悟空", 1024), "长安城");
        hm99.put(new Student("八戒", 1025), "高老庄");
        hm99.put(new Student("沙僧", 1026), "流沙河");
        // 定义双元课堂
        HashMap<HashMap<Student, String>, String> hm = new HashMap<HashMap<Student, String>, String>();
        hm.put(hm88, "第88期基础班");
        hm.put(hm99, "第99期基础班");

        for (HashMap<Student, String> hMap : hm.keySet()) { // hm.KeySet()代表的是双链集合中键的集合
            String valString = hm.get(hMap); // get(hMap)根据键对象获取值对象
            for (Student s : hMap.keySet()) { // 遍历键的双列集合对象，hMap.KeySet()获取集合中所有的学生键对象
                String val2String = hMap.get(s);
                System.out.println(s + "=" + val2String + "=" + valString);
            }
            System.out.println("---------------------------");
        }
    }
}
HashMap

 

HashMap和Hashtable的区别

* A： 面试题
　　* HashMap和Hashtable的区别
　　　　* Hashtable是JDK1.0版本出现的，是线程安全的，效率低；HashMap是JDK1.2版本出现的，是线程不安全的，效率高
　　　　* Hashtable不可以存储null键和null值，HashMap可以存储null键和null值

* B：案例演示
　　* HashMap和Hashtable的区别

技术图片 
package com.heima.map;

import java.util.HashMap;
import java.util.Hashtable;

public class Demo9_HashTable {
    /* 面试题
     * HashMap和Hashtable的区别：
     * 共同点：底层都是哈希算法，都是双列集合
     * 区别：前者线程不安全，效率高，JDK1.2版本出现；后者线程安全，效率相对较低，JDK1.0版本出现
     *              前者可以存储null键和null值；后者不可以
     */
    public static void main(String[] args) {
        HashMap<String, Integer> hm = new HashMap<String, Integer>();
        hm.put(null, null);
        hm.put("张三", null);
        System.out.println(hm);
        
        Hashtable<String, Integer> ht = new Hashtable<String, Integer>();
        //ht.put(null, 23); // NullPointerException
        //ht.put("张三", null);
    }
}
Differences

 

 Collections工具类的概述和常见方法讲解

* A：Collections类概述
　　* 针对集合操作的工具类

* B：Collections成员方法

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)

技术图片

技术图片 
package com.heima.collections;

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

public class Demo1_Collections {

    public static void main(String[] args) {
        // demo1();
        // demo2();
        // demo3();
    }

    public static void demo3() {
        ArrayList<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
        list.add("g");

        System.out.println(Collections.max(list)); // 底层会先排序，因此即使是无序的也能max
        Collections.reverse(list); // 反转集合
        Collections.shuffle(list); // 将元素打乱，可以用来洗牌
        System.out.println(list);
    }

    public static void demo2() {
        ArrayList<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
        list.add("g");

        System.out.println(Collections.binarySearch(list, "s"));
    }

    public static void demo1() {
        ArrayList<String> list = new ArrayList<String>();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("a");
        list.add("c");
        list.add("a");

        System.out.println(list);
        Collections.sort(list); // 排序，底层调用compareTo或compare方法，重复的保留
        System.out.println(list);
    }

}
Collections

 

 模拟斗地主洗牌和发牌

* A：案例演示
　　* 模拟斗地主洗牌和发牌，牌没有顺序

技术图片 
package com.heima.test;

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

public class Test2 {
    /*
     * 分析：
     * 1、买一副扑克，其实就是自己创建一个集合对象，将扑克牌存储进去
     * 2、洗牌，调用Collections.shuffle方法
     * 3、发牌，每个人17张，
     * 4、看牌
     */
    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<String>(); // 定义扑克牌集合
        // 拼接花色和数字
        for (String s1 : color) { // 遍历花色数组
            for (String s2 : num) { // 遍历牌面数组
                poker.add(s1.concat(s2)); // 字符串拼接
            }
        }
        poker.add("大王");
        poker.add("小王");
        
        Collections.shuffle(poker); // 洗牌
        
        ArrayList<String> gaojin = new ArrayList<String>();
        ArrayList<String> longwu = new ArrayList<String>();
        ArrayList<String> me = new ArrayList<String>();
        ArrayList<String> dipai = new ArrayList<String>();

        for (int i = 0; i < poker.size(); i++) { // 发牌
            if (i >= poker.size() - 3) {
                dipai.add(poker.get(i)); // 将三张底牌存储在底牌集合中
            } else if (i % 3 == 0) {
                gaojin.add(poker.get(i));
            } else if (i % 3 == 1) {
                longwu.add(poker.get(i));
            } else {
                me.add(poker.get(i));
            }

        }
        
        System.out.println(dipai); // 看牌
        System.out.println(gaojin);
        System.out.println(longwu);
        System.out.println(me);
    }
}
Test2

　　* 模拟斗地主洗牌和发牌，牌有顺序

技术图片

技术图片 
package com.heima.test;

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

public class Test3 {
    /*
     * 分析：
     */
    public static void main(String[] args) {
        String[] num = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2" }; // 定义牌面大小
        String[] color = { "红桃", "黑桃", "方块", "梅花" }; // 定义花色
        HashMap<Integer, String> hm = new HashMap<Integer, String>(); // 定义双链集合，存储索引和扑克牌
        ArrayList<Integer> list = new ArrayList<Integer>(); // 存储索引，方便洗牌
        int index = 0; // 定义索引
        for (String s1 : num) {
            for (String s2 : color) {
                hm.put(index, s2.concat(s1)); // 拼接扑克牌，并将索引和扑克牌 存储在双链集合中
                list.add(index); // 存储索引值
                index++; // 索引值加加
            }
        }
        
        hm.put(index, "小王"); // 添加小王
        list.add(index++); // 先添加小王索引，再加加
        hm.put(index, "大王"); // 添加大王
        list.add(index); // 添加大王索引

        Collections.shuffle(list); // 洗牌

        TreeSet<Integer> gaojin = new TreeSet<Integer>(); // 定义TreeSet使牌自动排序
        TreeSet<Integer> longwu = new TreeSet<Integer>();
        TreeSet<Integer> me = new TreeSet<Integer>();
        TreeSet<Integer> dipai= new TreeSet<Integer>();

        for (int i = 0; i < list.size(); i++) { //发牌
            if (i >= list.size() - 3) {
                dipai.add(list.get(i)); // 将三张底牌存储在底牌集合中
            } else if (i % 3 == 0) {
                gaojin.add(list.get(i));
            } else if (i % 3 == 1) {
                longwu.add(list.get(i));
            } else {
                me.add(list.get(i));
            }
        }
        
        kanpai(hm, dipai); // 看牌        
        kanpai(hm, gaojin);        
        kanpai(hm, longwu);
        kanpai(hm, me);
    }
    /*
     * 看牌：
     * 1、返回值类型是void
     * 2、参数列表HashMap键值关系，TreeMap牌的索引
     */
    public static void kanpai(HashMap<Integer, String> hm, TreeSet<Integer> dipai) {
        for (Integer integer : dipai) {
            System.out.print(hm.get(integer)+"    ");
        }
        System.out.println();
    }
}
Test3

 

 泛型固定下边界

* ？super E

技术图片 
package com.heima.collections;

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

import com.heima.bean.BaseStudent;
import com.heima.bean.Student;

public class Demo2_Genric {
    /*
     * ? super E 泛型固定下边界          儿子可以调用父亲的，存储子类的集合可以调用父类的comparator  comparator
     * ? extends E 泛型固定上边界    儿子的是父亲的，存储子类的集合可以添加到存储父类的集合中中   addAll
     */
    public static void main(String[] args) {
        // demo1();
        TreeSet<Student> ts1 = new TreeSet<Student>(new CompareByName());
        ts1.add(new Student("张三", 23));
        ts1.add(new Student("李四", 13));
        ts1.add(new Student("王五", 23));
        ts1.add(new Student("赵六", 43));
        
        System.out.println(ts1);
        
        TreeSet<BaseStudent> ts2 = new TreeSet<BaseStudent>(new CompareByName());
        ts2.add(new BaseStudent("张三", 23));
        ts2.add(new BaseStudent("李四", 13));
        ts2.add(new BaseStudent("王五", 23));
        ts2.add(new BaseStudent("赵六", 43));
        
        System.out.println(ts2);
    }

    public static void demo1() {
        // ? extends E 泛型固定上边界
        ArrayList<Student> list1 = new ArrayList<Student>();
        list1.add(new Student("张三", 23));
        list1.add(new Student("李四", 24));

        ArrayList<BaseStudent> list2 = new ArrayList<>();
        list2.add(new BaseStudent("张三", 23));
        list2.add(new BaseStudent("李四", 24));
        
        list1.addAll(list2); // 把子类对象添加到父类中
    }
}

class CompareByName implements Comparator<Student> {

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

 

Java集合框架04

标签：数据   ace   iter   返回键   test   static   except   one   dip   

原文地址：https://www.cnblogs.com/zhaochuming/p/12673783.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！