day18

作者: 姗婷 | 来源:发表于2020-12-06 17:55 被阅读0次

    1:Map(掌握)

    (1)将键映射到值的对象。

    一个映射不能包含重复的键;每个键最多只能映射到一个值。

    (2)Map和Collection的区别?

    A:Map 存储的是键值对形式的元素,键唯一,值可以重复。夫妻对
    B:Collection 存储的是单独出现的元素,子接口Set元素唯一,子接口List元素可重复。光棍

    (3)Map接口功能概述(自己补齐)

    Map集合的功能概述:
    1:添加功能
    V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你,等会讲
    如果键是第一次存储,就直接存储元素,返回null
    如果键不是第一次存在,就用值把以前的值替换掉,返回以前的值
    2:删除功能
    void clear():移除所有的键值对元素
    V remove(Object key):根据键删除键值对元素,并把值返回
    *3:判断功能
    boolean containsKey(Object key):判断集合是否包含指定的键
    boolean containsValue(Object value):判断集合是否包含指定的值
    boolean isEmpty():判断集合是否为空
    4:获取功能
    Set<Map.Entry<K,V>> entrySet():
    V get(Object key):根据键获取值
    Set<K> keySet():获取集合中所有键的集合
    Collection<V> values():获取集合中所有值的集合
    5:长度功能
    int size():返回集合中的键值对的对数

    (4)Map集合的遍历

    A:键找值
    a:获取所有键的集合
    b:遍历键的集合,得到每一个键
    c:根据键到集合中去找值
    B:键值对对象找键和值
    a:获取所有的键值对对象的集合
    b:遍历键值对对象的集合,获取每一个键值对对象
    c:根据键值对对象去获取键和值

            代码体现:
                Map<String,String> hm = new HashMap<String,String>();
                
                hm.put("it002","hello");
                hm.put("it003","world");
                hm.put("it001","java");
                
                //方式1 键找值
                Set<String> set = hm.keySet();
                for(String key : set) {
                    String value = hm.get(key);
                    System.out.println(key+"---"+value);
                }
                
                //方式2 键值对对象找键和值
                Set<Map.Entry<String,String>> set2 = hm.entrySet();
                for(Map.Entry<String,String> me : set2) {
                    String key = me.getKey();
                    String value = me.getValue();
                    System.out.println(key+"---"+value);
                }
    

    (5)HashMap集合的练习

    A:HashMap<String,String>
    B:HashMap<Integer,String>
    C:HashMap<String,Student>
    D:HashMap<Student,String>

    (6)TreeMap集合的练习

    A:TreeMap<String,String>
    B:TreeMap<Student,String>

    (7)案例

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

    public class TreeMapTest1 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String s = sc.nextLine();
    
            TreeMap<Character,Integer> tm = new TreeMap<Character, Integer>();
    
            char[] chars =s.toCharArray();
            for (char ch:chars) {
                Integer i = tm.get(ch);
                if(i == null){
                    tm.put(ch,1);
                }else
                {
                    i++;
                    tm.put(ch,i);
                }
            }
    
            StringBuilder sb = new StringBuilder();
    
            Set<Character> set = tm.keySet();
            for (Character c:set) {
                Integer integer = tm.get(c);
                sb.append(c).append("(").append(integer).append(")");
            }
            String restlt = sb.toString();
            System.out.println(restlt);
        }
    }
    

    B:集合的嵌套遍历
    a:HashMap嵌套HashMap
    b:HashMap嵌套ArrayList
    c:ArrayList嵌套HashMap
    d:多层嵌套

    2:Collections(理解)

    (1)是针对集合进行操作的工具类

    (2)面试题:Collection和Collections的区别

    A:Collection 是单列集合的顶层接口,有两个子接口List和Set
    B:Collections 是针对集合进行操作的工具类,可以对集合进行排序和查找等

    (3)常见的几个小方法:

    A:public static <T> void sort(List<T> list)
    B:public static <T> int binarySearch(List<?> list,T key)
    C:public static <T> T max(Collection<?> coll)
    D:public static void reverse(List<?> list)
    E:public static void shuffle(List<?> list)

    (4)案例

    A:ArrayList集合存储自定义对象的排序
    B:模拟斗地主洗牌和发牌
    C:模拟斗地主洗牌和发牌并对牌进行排序

    1:集合(自己补齐)

    Collection(单列集合)
    List(有序,可重复)
    ArrayList
    底层数据结构是数组,查询快,增删慢
    线程不安全,效率高
    Vector
    底层数据结构是数组,查询快,增删慢
    线程安全,效率低
    LinkedList
    底层数据结构是链表,查询慢,增删快
    线程不安全,效率高
    Set(无序,唯一)
    HashSet
    底层数据结构是哈希表。
    哈希表依赖两个方法:hashCode()和equals()
    执行顺序:
    首先判断hashCode()值是否相同
    是:继续执行equals(),看其返回值
    是true:说明元素重复,不添加
    是false:就直接添加到集合
    否:就直接添加到集合
    最终:
    自动生成hashCode()和equals()即可
    LinkedHashSet
    底层数据结构由链表和哈希表组成。
    由链表保证元素有序。
    由哈希表保证元素唯一。
    TreeSet
    底层数据结构是红黑树。(是一种自平衡的二叉树)
    如何保证元素唯一性呢?
    根据比较的返回值是否是0来决定
    如何保证元素的排序呢?
    两种方式
    自然排序(元素具备比较性)
    让元素所属的类实现Comparable接口
    比较器排序(集合具备比较性)
    让集合接收一个Comparator的实现类对象
    ##Map(双列集合)
    A:Map集合的数据结构仅仅针对键有效,与值无关。
    B:存储的是键值对形式的元素,键唯一,值可重复。

        HashMap
            底层数据结构是哈希表。线程不安全,效率高
                哈希表依赖两个方法:hashCode()和equals()
                执行顺序:
                    首先判断hashCode()值是否相同
                        是:继续执行equals(),看其返回值
                            是true:说明元素重复,不添加
                            是false:就直接添加到集合
                        否:就直接添加到集合
                最终:
                    自动生成hashCode()和equals()即可
            LinkedHashMap
                底层数据结构由链表和哈希表组成。
                    由链表保证元素有序。
                    由哈希表保证元素唯一。
        Hashtable
            底层数据结构是哈希表。线程安全,效率低
                哈希表依赖两个方法:hashCode()和equals()
                执行顺序:
                    首先判断hashCode()值是否相同
                        是:继续执行equals(),看其返回值
                            是true:说明元素重复,不添加
                            是false:就直接添加到集合
                        否:就直接添加到集合
                最终:
                    自动生成hashCode()和equals()即可
        TreeMap
            底层数据结构是红黑树。(是一种自平衡的二叉树)
                如何保证元素唯一性呢?
                    根据比较的返回值是否是0来决定
                如何保证元素的排序呢?
                    两种方式
                        自然排序(元素具备比较性)
                            让元素所属的类实现Comparable接口
                        比较器排序(集合具备比较性)
                            让集合接收一个Comparator的实现类对象
    

    2:到底使用那种集合(自己补齐)

    看需求。
    是否是键值对象形式:
    是:Map
    键是否需要排序:
    是:TreeMap
    否:HashMap
    不知道,就使用HashMap。
    否:Collection
    元素是否唯一:
    是:Set
    元素是否需要排序:
    是:TreeSet
    否:HashSet
    不知道,就使用HashSet
    否:List
    要安全吗:
    是:Vector(其实我们也不用它,后面我们讲解了多线程以后,我在给你回顾用谁)
    否:ArrayList或者LinkedList
    增删多:LinkedList
    查询多:ArrayList
    不知道,就使用ArrayList
    不知道,就使用ArrayList

    3:集合的常见方法及遍历方式

    Collection:

    add()
    remove()
    contains()
    iterator()
    size()
    遍历:
    增强for
    迭代器
    |--List
    get()
    遍历:
    普通for
    |--Set

    Map:

    put()
    remove()
    containskey(),containsValue()
    keySet()
    get()
    value()
    entrySet()
    size()
    遍历:
    根据键找值
    根据键值对对象分别找键和值
    作业:
    我讲解过的任意一个集合,我要求你存储什么,你就能够存储什么。并且,还要能够遍历出来。

    4:ArrayList,LinkedList,HashSet,HashMap(掌握)

    存储字符串和自定义对象数据并遍历

    5:集合的嵌套遍历(理解)

    相关文章

      网友评论

          本文标题:day18

          本文链接:https://www.haomeiwen.com/subject/qxaowktx.html