大数据预科班15

ゝ一世哀愁。 2022-06-08 10:52 198阅读 0赞

# 大数据预科班15 #

### 复习 ###

*  集合Collection 顶级接口
 *  List--有序；可重复 ArrayList，LinkedList，Vector（线程安全）--stack；
 *  Set--无序；不可重复 HashSet
 *  Collection--操作集合的工具类
 *  Comparator--比较器---\{类--Comparable\}

### Iterator迭代器 ###

*  用于迭代遍历，挪动指针和标记操作
 *  hasNext()
 *  next（）
 *  remove( )//移除正在迭代的元素--作用于原集合

迭代过程中不允许增删元素(list.add(s);list.remove(s);)

#  #

Iterator<String> it=list.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }

*  底层

#  #

1. 把原集合复制一份
    2. 操作并标记
    3. 原集合与备份的通过标记做对比，

### 使用增强for循环，类必须实现Iterable接口 ###

*  Iterator在迭代中不可增删原集合

### 增强for循环--jdk1.5特性之一 ###

### 泛型 ###

*  参数化类型
 *  顶级接口ParameterizedType--jdk1.5的特性之一
 *  发展历史

#  #

1. 早期
        元素类型同一位Object
        List list = new ArrayList();
        list.add(true);
        list.add("as");
        list.add(12);
        Iterator it=list.iterator();
    
        //遍历
        while(it.hasNext()){
            Object o=it.next();
            //instanceOf 判断--强转
        }
    2. 中期
        List list = new ArrayList<T>();
        只是建议，没有实质性作用
    3. 后期
        List list<T> = new ArrayList();
    4. 现在--只存储一种类型
        List list<T> = new ArrayList();

*  泛型的擦除

#  #

确定为具体的类型--编译期确定
    有泛型--编译效率略低--推导【type inference】重新确定为新的类型
    前编译中确定==后运行时确定<>diamond自动类型推导

### 自定义泛型类 ###

*  泛型定义--符合标识符命名
 *  习惯上--大写字母表示泛型
 *  T type类型
 *  E element元素
 *  K key键
 *  V value值
 *  R result结果

#  #

//泛型类
    class demo<T>{
        //定义变量
        private T t=null;
    
        //方法
        public void set(T t){
            this.t=t;
        }
        public T get(){
            return this.t;
        }       
    }

*  定义多个泛型时，用逗号隔开<T,E,R>
 *  为方法定义泛型（独属）-----【中转站：参数不确定时

#  #

//参数和返回值都可以不确定--工厂模式
    修饰符 <E> 返回值 方法名（参数列表）{
    
    }

*  泛型不兼容--向上造型不适用这里

#  #

1. List<Number> list = new ArrayList<Integer>();//编译报错
    2. 解决：继承--extends泛型的上限（传入类型的最高边界）
        ? extends 类//？表示的是类或者子类【注：接口也用extends】
        List<？ extends Number> list = new ArrayList<Integer>();
        可以添加null，但是不能添加除null之外的其他元素；
    3. 泛型?写在定义的方法中
    4. 泛型的下限：（传入的类型的最小边界）
        ？ super 类或接口
        能添加除null之外的其他子类元素；
    5. 同一个泛型不能同时规定上下限--解决：方法调用（上限方法调用下限方法或相反着调用）
    6. ？表示泛型的通配符

*  使用泛型但，但此时不确定类型，编译时不允许添加，运行时可以添加

#  #

List<?> list = new List<String>();

### 泛型接口同理 ###

### jdk1.5的10个特性 ###

### Map ###

*  映射:需要两个元素--成对出现（key-value）
 *  无序
 *  键重复，覆盖值
 *  需要两个泛型：Map<K,V>
 *  键唯一，值不唯一
 *  映射的顶级接口
 *  不是集合，但它是集合框架【Java Collections FrameWork：集合、映射、操作的工具】的一员
 *  Entry---代表键值对的接口---内部接口（隶属于Map接口）
    
     *  一个Map有多个entry组成
 *  方法
    
     *  添加put（key，value）
     *  toString方法被重写了
     *  删除元素--根据key删除键值对remove(key)
     *  获取value--get(key);键不存在，返回null
     *  clean()清空map
     *  containsKey（key）是否包含key
     *  containsValue（value）是否包含value
     *  equals
     *  isEmpty判断映射是否为空
     *  remove（key）移除该键的键值对
     *  size()获取键值对的个数
     *  values获取所有值，并放入Collecton集合中（value打印可重复）
 *  遍历Map

#  #

1. 第一种方式：先获取键，在遍历键获取值
        Set<String> keys = map.keySet();
        Iterator<String> it = keys.iterator();
        while (it.hasNext()) {
            System.out.println(map.get(it.next()).toString());
        }
    2. 第二种方式：获取键值对，再获取key和value
        for (Map.Entry<String, Integer> e : map.entrySet()) {
            System.out.println(e.getKey() + ":" + e.getValue());
        }

### HashMap ###

*  允许键为null
 *  允许值为null
 *  HashSet基于HashMap
 *  初始容量16，加载因子0.75f，每次扩容yibei
 *  异步式线程不安全【同一个时间：多个--异步；一个--同步】

### HashTable ###

*  元素非null-----键值都不允许为null；--NullPointException
 *  初始容量11，加载因子0.75f,扩容11,23,47
 *  同步式线程安全的映射
 *  效率最低的映射
 *  java最早的映射

### Dictionary低级映射父类--唯一子类：HashTable ###

### ConcurrentHashMap ###

*  异步式线程安全的映射

### 练习 ###

*  输入键值对（空格隔开），键正序，键相同时值相加

#  #

package com.peng.demo;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Scanner;
    
    public class TestListSet {
        public static void main(String args[]) {
            List<Integer> list = new ArrayList<Integer>();
            Scanner s = new Scanner(System.in);
            System.out.println("请输入键值对的个数");
            Map<Integer, Integer> map = new HashMap<Integer, Integer>();
            // nextInt默认的后面加空格
            int num = Integer.parseInt(s.nextLine());
            String str = "";
            for (int i = 0; i < num; i++) {
                System.out.println("请输入第" + (i + 1) + "键值对");
                str = s.nextLine();
                String[] temp_arr = str.split(" ");
                int arr1 = Integer.parseInt(temp_arr[0]);
                int arr2 = Integer.parseInt(temp_arr[1]);
                // 判断是否包含此键
                if (map.containsKey(arr1)) {
                    map.put(arr1, map.get(arr1) + arr2);
                } else {
                    map.put(arr1, arr2);
                    list.add(arr1);
                }
            }
            Collections.sort(list);
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i) + "=" + map.get(list.get(i)));
            }
            System.out.println(map);
    
        }
    
    }