Java第一阶段（day12）集合

新增(自动封装)       查询

数据在数据库在缓存

集合:
  将多个数据(元素)存储在一起。也是一个容器。
  理论上存储任意多个"不同数据类型"的数据。 只能存储 "引用数据类型的数据"
  底层已经封装好了空间不足或者移动位置等这些操作。
  //实际开发中  存储还是相同类型的数据(避免出现类型转换的异常)
 
  
数组: 
  一个容器。存储相同数据类型指定length个数据。
  空间固定   数据类型必须相同。
  数组可以存储什么类型的数据?
      int[] String[] Bike[] "所有的类型都可以。"
  优势:
    查询/修改性能最快。index
  弊端:
    新增/删除性能比较低。
    空间固定----> 一值新增 手动扩容
    数据是连贯的---->后面的数据向左移动位置

数组  VS  集合
相同点:容器。存储很多元素/数据。
不同点:
   数组: 空间固定   数据类型必须相同
   集合: 空间可变   数据类型可以相同

1. 集合分类

Collection  VS Map

	元素	元素是否可重复
Collection	存储的是单值 元素(一次存储一个)	具体看子级List/set
Map	存储的是一组元素(key-value)	key必须唯一  value可重复的

2. Collection

	元素是否有序(索引位置)	元素是否可重复
List	有序	可重复
Set	无序	不可重复

2.1 常用方法

方法	功能
boolean``add(E e)`	将指定的数据添加集合中
void``clear()	清空集合里面所有的元素
boolean``contains(Object o)	判断集合里面是否包含指定的数据
boolean``isEmpty()	判断集合是否是空
Iterator``iterator()	获得集合对象的迭代器对象(遍历集合元素)
boolean``remove(Object o)	删除集合里面元素
int``size()	获得集合元素个数
Object[]``toArray()	集合转数组
T[]``toArray(T[] a)
default boolean``removeIf(Predicate filter)	删除满足条件的多个元素
Stream``parallelStream()	获得集合对象的并行化Stream对象
default Stream``stream()	获得集合串行化Stream对象
default void``forEach(Consumer action)	(遍历集合元素)

Iterator

boolean hasNext()  判断指针/光标后面是否有更多的数据需要迭代】

E next() 获得指针之后的元素数据

default void remove()  
从底层集合中删除此迭代器返回的最后一个元素（可选操作）。

2.2 使用方法

 private static void demo1() {
        //创建集合对象 增删改查集合元素
        Collection collection = new ArrayList();
        //System.out.println(collection.isEmpty());
        System.out.println(collection);//[]
        //1.新增元素---> 存储不同类型的数据
        collection.add(100);
        collection.add("hello");
        collection.add("hello");
        collection.add("hello");
        collection.add(true);
        collection.add(null);
        collection.add(new UserInfo());
        collection.add(100.123);

        System.out.println(collection);
        System.out.println("集合的元素个数:" + collection.size());

        //2.删除集合元素
       /* collection.remove("hello");
        collection.remove("hello");
        collection.remove("hello");*/
        //循环 遍历集合里面的每个元素  删除满足条件的数据
        /*collection.removeIf(new Predicate() {
            @Override
            public boolean test(Object data) {
                return Objects.equals(data, "hello");
            }
        });*/

        //面向函数式编程----> 面向方法编程---->重写的那个方法
        //lamda:  ()->{}
        //类名/引用::方法名
        //collection.removeIf(a -> Objects.equals(a, "hello"));
        //collection.removeIf("hello"::equals);

        //判断集合里面是否包含指定的数据
        //System.out.println(collection.contains(100));
        //清空集合元素
        //collection.clear();

        //集合转数组
        //Object[] array = collection.toArray();
        //System.out.println(Arrays.toString(array));
        System.out.println(collection);
        System.out.println(collection.size());
    }

2.3 遍历集合元素

private static void demo2() {

    Collection collection = new ArrayList();
    collection.add(1);
    collection.add(10);
    collection.add(2);
    collection.add("abc");
    collection.add(null);

    //循环遍历输出集合里面的每个元素数据
    //增强for
    /*for(Object data:collection){
        System.out.println(data);
    }*/
 /*  //1.获得集合对象的迭代器对象
    Iterator it = collection.iterator();//集合里面的所有的数据都在it
    //2.判断指针之后是否有更多的数据需要迭代
    while (it.hasNext()) {
        //3.获得指针之后的数据
        Object data = it.next();
        System.out.println(data);
    }*/

    //1.8+  forEach
    /*collection.forEach(new Consumer() {
        @Override
        public void accept(Object obj) {
            System.out.println(obj);
        }
    });*/

    //使用lamda替换上面的匿名内部类
    //::
    // collection.forEach(o->System.out.println(o));
    collection.forEach(System.out::println);

    //遍历Collection:
    //1.增强for循环
    //2. iterator()
    //3. forEach();

2.4 集合_泛型

public static void main(String[] args) {

    //使用泛型修饰集合
    //泛型+集合: 限定集合元素数据类型。 只存储一种类型的数据。
    Collection nameCollection = new ArrayList<>();
    //泛型只在编译期间有效 在运行期间其实泛型还是Object---->反射  泛型擦除
    nameCollection.add("张三");
    nameCollection.add("李四");
    nameCollection.add("王五");
    nameCollection.add("赵六");

    //遍历集合元素
    /*for (String name : nameCollection) {
        System.out.println(name);
    }*/

    //nameCollection.forEach(System.out::println);
   /* Iterator it = nameCollection.iterator();
    while (it.hasNext()) {
        String str = it.next();
        System.out.println(str);
    }*/

    //nameCollection.remove("张三");
    //nameCollection.removeIf("张三"::equals);
    System.out.println(nameCollection);

    //集合转数组
    //无参的toArray()不推荐  返回值类型Object[]  需要进行手动类型转换
    /*Object[] array1 = nameCollection.toArray();
    for (Object o : array1) {
         String s= (String) o;
    }*/
    // T[] toArray(T[] a);
    //集合转数组: 推荐数组的空间  0
    //length>size 有很多null  很容易NPE  空间内存浪费
    //size0 并发的时候 多次将集合转数组  GC进行回收无用的数组引用
    //length==0
    String[] strings1 = nameCollection.toArray(new String[0]);
    System.out.println("strings1:" + Arrays.toString(strings1));
    
}

3. 泛型<>

  T  K  V 一般都是使用 A-Z。 限定泛型里面参数化的数据类型。

只能是引用数据类型。

作用:  实现类型的自动转换。

泛型修饰类   ----> 泛型类 
泛型修饰方法  ----> 泛型方法
泛型修饰接口 ---->  泛型接口

3.1 问题(使用变量维护不定类型的数据)

@Data
public class MyClass {

    private Integer id;
    private String name;

    //使用data维护了一个不定类型数据
    private Object data;
}

 private static void demo1() {
        //创建MyClass类对象 对属性进行取值以及赋值
        MyClass myClass = new MyClass();
        myClass.setId(1001);
        myClass.setName("zhangsan");
        myClass.setData(100);


        //每次获取数据的时候  都要手动进行类型的强制转换
        //有可能会出现类型转换的异常
        Integer id = myClass.getId();
        String name = myClass.getName();
        Integer data = (Integer) myClass.getData();
        data = data + 100;

        MyClass myClass1 = new MyClass();
        myClass1.setData("hello");
        String d = (String) myClass1.getData();
    }

可以满足使用data变量维护不同类型的数据。但是每次获得数据的时候 都要进行类型的强制转换  进而实现其他的功能

在这种情况下:

• 就会有可能出现类型转换的异常
• 每次都进行手动的转换  代码不是很优雅

3.2 泛型类解决

目标:  不使用类型的强制转换      实现类型的自动转换    。

使用泛型进行解决。

//MyClass 代表是一个泛型类。T：参数化类型
//不清楚T的真实的数据类型。Object
@Data
public class MyClass {

    private Integer id;
    private String name;

    //使用data维护了一个不定类型数据
    private Object data;

    //参数化数据类型---->指定好的规则  A-Z    T  E  K V
    private T data1;

    //实例方法: 对象/引用.方法
    //参数化到底是什么类型?  创建对象的时候 指定的参数化类型具体是什么类型
    public T a(T t) {
        return null;
    }
}

public static void main(String[] args) {

    //需求: "实现类型的自动转换"
    //一般类  接口是泛型类或者泛型接口   一般都会指定参数化类型
    MyClass myClass = new MyClass<>();
    myClass.setData1("hello");
    String data1 = myClass.getData1();

    MyClass myClass1 = new MyClass<>();
    myClass1.setData1(100);
    Integer data11 = myClass1.getData1();


}

3.3 泛型方法

在任意一个类里面  都可以使用泛型修饰方法。

使用参数化类型修饰方法  这个方法就是泛型方法。

//K:是一个参数化类型  不指定  默认Object
public class FanXingClass {
    private K a;

    //只是参数化类型 充当形参和返回值
    //K类型是固定的  只能是一种 创建对象的时候 指定的数据类型
    public K getA() {
        return a;
    }

    public void setA(K a) {
        this.a = a;
    }

    //泛型方法
    //T: 不定类型
    //K: 创建对象的时候类型  m1是一个实例方法
    public  void m1(T abc, K bb) {
    }

    //静态方法
    //是否可以使用参数化数据类型? 创建对象的时候指定参数化类型
    //在泛型类里面 提供了很多静态的方法  里面使用参数化类型 这些静态方法都是"泛型方法"
    public static   void m2(K aaa) {

    }

    //一个泛型类里面 有很多的静态的方法 这个类一般都是工具类 用来封装一些的数据。


}

3.4 泛型接口

//后期有很多模块:  User  Product
// 新增 删除  修改  查询
//T  就是 User  Product....
class User {
}

class Product {
}
public interface BaseDao {
    void add(T t);

    void delete();

    void update();

    T findOne();

    Collection findAll();
}

class ProductDaoImpl implements BaseDao{

    @Override
    public void add(Product product) {
        
    }

    @Override
    public void delete() {

    }

    @Override
    public void update() {

    }

    @Override
    public Product findOne() {
        return null;
    }

    @Override
    public Collection findAll() {
        return null;
    }
}
class UserDaoImpl implements BaseDao{

    @Override
    public void add(User user) {
        
    }

    @Override
    public void delete() {

    }

    @Override
    public void update() {

    }

    @Override
    public User findOne() {
        return null;
    }

    @Override
    public Collection findAll() {
        return null;
    }
}

3.5 上限和下限

//使用 T extends 具体类型 规定参数化类型的上限
//只能:Number以及Number类型所有的子类
public class DemoTest {


    //?是一个通配符 统配任意一个类型
    //下限: ?只能是String以及String的父级类型。
    public static void a(Collection collection) {

    }
}

class Test3 {
    public static void main(String[] args) {

        Collection collection = new ArrayList<>();
        DemoTest.a(collection);

    }
}

3.List

有序可重复。  index:  0-size()-1

3.1 常用实现类

	数据结构	性能	安全
ArrayList	动态数组	查询/修改最快     新增/删除慢	不安全
LinkedList	双向链表	新增/删除最快     查询/修改慢	不安全
Vector	动态数组	一般	安全 sync
CopyOnWriteArrayList	动态数组	很慢	安全 sync

链表:
   单向链表: 一个元素的引用会“记着下一个元素引用” 以及当前元素数据
   双向链表:  当前元素的引用会“记着下一个元素引用”  还会记着“上一个元素的引用”   
             以及当前元素数据

3.2 常用方法

方法	作用
void``add(int index, E element)	指定索引位置新增新的数据
E``get(int index)	获得指定索引数据
ListIterator``listIterator()	遍历list集合
E``remove(int index)	删除指定索引的元素数据
E``set(int index, E element)	修改指定索引的元素数据
default void``sort(Comparator c)	排序
List``subList(int fromIndex, int toIndex)	截取

3.3 使用方法

3.4 ArrayList

public class ArrayList
extends AbstractList
implements List, RandomAccess, Cloneable, Serializable

RandomAccess: 快速随机访问接口  标记接口   查询性能最快  O(1)
    使用普通循环遍历方式  性能最快。

1. 构造方法

ArrayList() 构造一个初始容量为十的空列表。  array.length

ArrayList(int initialCapacity) //推荐  10
initialCapacity:  存储集合元素个数/负载因子+1   扩容
    
ArrayList(Collection c)

transient Object[] elementData;//就是存储ArrayList集合元素数据  
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

2. 分析add

 protected transient int modCount = 0;//维护操作集合元素次数。(add/remove)
 private int size;//维护集合元素的个数
 private static final int DEFAULT_CAPACITY = 10;//默认容量

public boolean add(E e) {
    modCount++;
    add(e, elementData, size);
    return true;
}

private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)//size的数据超出数组length的时候  
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }

 private Object[] grow() {
        return grow(size + 1);//1
    }

 private Object[] grow(int minCapacity) {//1
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
    }

private int newCapacity(int minCapacity) {//1
        // overflow-conscious code
        int oldCapacity = elementData.length;//获得原数组的长度  0
        int newCapacity = oldCapacity + (oldCapacity >> 1);
          //计算新数组的容量 1.5
        if (newCapacity - minCapacity <= 0) {
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return minCapacity;
        }
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
    }

3. 分析get

E elementData(int index) {
    return (E) elementData[index];
}

4. 分析set

public E set(int index, E element) {
    Objects.checkIndex(index, size);
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

5. 分析remove

public boolean remove(Object o) {
    final Object[] es = elementData;
    final int size = this.size;
    int i = 0;
    found: {//找指定元素所在的索引位置
        if (o == null) {
            for (; i < size; i++)
                if (es[i] == null)
                    break found;
        } else {
            for (; i < size; i++)
                if (o.equals(es[i]))
                    break found;
        }
        return false;
    }
    fastRemove(es, i);//带着index  带着数组  快速删除元素数据
    return true;
}

private void fastRemove(Object[] es, int i) {
    modCount++;
    final int newSize;
    if ((newSize = size - 1) > i)
        System.arraycopy(es, i + 1, es, i, newSize - i);//真正删除操作
    es[size = newSize] = null;//Gc回收无用对象
}

3.5 LinkedList

元素  数据  节点

public class LinkedList
extends AbstractSequentialList
implements List, Deque, Cloneable, Serializable

LinkedList()

1. 分析add

public boolean add(E e) {
    linkLast(e);
    return true;
}

transient Node last;//null
 transient Node first;//null
transient int size = 0;

void linkLast(E e) {//100
    
    final Node l = last;//null
    final Node newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)//第一次新增数据的时候  将第一个节点对象赋值给first
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

手动编写双向链表。

private static class Node {//维护LinkedList底层的双向链表的数据结构
    E item;//数据
    Node next;//下一个节点的引用
    Node prev;//上一个节点的引用

    Node(Node prev, E element, Node next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

void linkBefore(E e, Node succ) {// e 新的元素数据  succ: 指定索引的节点对象
    // assert succ != null;
    final Node pred = succ.prev;//获得指定索引对象的上一个  
    final Node newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)//指定索引为0的时候
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

2. 分析get

Node node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

3. 分析set

public E set(int index, E element) {
    checkElementIndex(index);
    Node x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

4.分析remove

public boolean remove(Object o) {
    if (o == null) {
        for (Node x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);//解除节点与节点之间的关系
                return true;
            }
        }
    }
    return false;
}

5. 特有方法

//将元素添加到首尾
linkedList.add(0, 101);
linkedList.addFirst(1);
linkedList.addLast(400);
linkedList.push(1111);

//获得链表首尾元素
System.out.println(linkedList.get(0));// Node.item
System.out.println(linkedList.getFirst());
System.out.println(linkedList.getLast());
System.out.println(linkedList.element());
System.out.println(linkedList.peek());
System.out.println(linkedList.peekFirst());
System.out.println(linkedList.peekLast());

//删除首尾元素
System.out.println(linkedList.remove());
System.out.println(linkedList.removeFirst());
System.out.println(linkedList.removeLast());
System.out.println(linkedList.poll());
System.out.println(linkedList.pollFirst());
System.out.println(linkedList.pollLast());
System.out.println(linkedList.pop());

3.6 Vector

线程安全。 synchronized

package com.javasm;

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.TimeUnit;

/**
 * @author: Lisa
 * @className: VectorDemo
 * @description:
 * @date: 2022/3/2 16:11
 * @version: 0.1
 * @since: jdk11
 */
public class VectorDemo {


    //使用一个成员变量维护存储很多数据
    //每个线程共同操作同一个集合对象
    private static Vector list = new Vector<>();

    public static void main(String[] args) {
        //并发环境
        //创建10个线程  都操作同一个集合对象 list
        List threadList = new ArrayList<>(10);

        for (int i = 0; i < 10; i++) {
            threadList.add(new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    list.add(1);
                }
            }));
        }
        threadList.forEach(Thread::start);

        threadList.forEach(thread -> {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        //等待着前面10个子线程执行完毕---->等待着子线程死亡
        //获得集合里面的元素个数
        //让主线程休眠 5

        System.out.println(list.size());//10000
    }
}

3.7 CopyOnWriteArrayList

public boolean add(E e) {
    synchronized (lock) {//底层安全的实现方式
        Object[] es = getArray();
        int len = es.length;
        es = Arrays.copyOf(es, len + 1);
        es[len] = e;
        setArray(es);
        return true;
    }
}

3.8 迭代器模式

遍历期间不能删除。

4.Set

4.1常用实现类

常用的数据结构:  数组   链表  哈希表  红黑树

	数据结构	元素是否可以为null	线程安全
HashSet	哈希表(底层就是HashMap 位桶+哈希+红黑树)	ok	不安全
LinkedHashSet	链表+哈希表(LinkedHashMap)	ok	不安全
TreeSet	红黑树(TreeMap)	不可以	不安全
CopyonWriteArraySet	数组	不可以	安全

4.2 常用方法

Set接口里面的方法与父接口Collection的功能一模一样。

4.3 HashSet

常用构造

HashSet() 
构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。 
HashSet(int initialCapacity) 
构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。

元素特征:

private static void testHashSet() {
        HashSet set = new HashSet<>();
        set.add(50);
        set.add(3);
        set.add(1);
        set.add(10);
        set.add(2);
        //无序:  元素没有索引  新增的顺序与遍历的顺序不一致的
        System.out.println(set);
        //遍历set集合
        /*for (Integer num : set) {
            System.out.println(num);
        }*/
       /* Iterator it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }*/
        set.forEach(System.out::println);
    }

4.4 LinkedHashSet

常用构造

LinkedHashSet(int initialCapacity) 
构造一个具有指定初始容量和默认负载因子（0.75）的新的，空的链接散列集。

元素特征:  元素有序   新增顺序与遍历输出顺序是一致。

private static void testLinkedHashSet() {

        LinkedHashSet set = new LinkedHashSet<>();
        set.add(50);
        set.add(3);
        set.add(1);
        set.add(10);
        set.add(2);
        set.add(2);
        set.add(null);
        System.out.println(set);
    }

4.5 TreeSet

TreeSet集合元素的数据类型 必须有排序规则。

1.保证集合元素数据类型实现Comparable接口  内部比较器

2.自定义提供排序规则 实现Comparator  外部比较器

常用构造

TreeSet() 
    
TreeSet(Comparator comparator)

元素特征：  元素有序。 都会按照自然顺序排列。(升序/降序)

Comparable解决排序:

//类实现Comparable:  类与接口的耦合比较高  一般不使用内部比较器。推荐使用外部比较器
public class UserInfo implements Comparable {
     @Override
    public int compareTo(UserInfo o) {
        return this.age-o.age;
    }
}

TreeSet userInfoSet = new TreeSet<>();
userInfoSet.add(new UserInfo(1, "张三", 20));
userInfoSet.add(new UserInfo(2, "李四1", 180));
userInfoSet.add(new UserInfo(3, "李四1", 181));
userInfoSet.add(new UserInfo(4, "李四1", 118));
userInfoSet.add(new UserInfo(5, "李四1", 108));
userInfoSet.forEach(System.out::println);

Comparator解决排序:

public class UserInfo {}//类很单一

private static void testSet1() {
        //TreeSet: 集合元素数据类型必须实现Comparable  排序
        //数据唯一的问题: 只看排序的规则(哪个属性参与排序  元素唯一就看那个属性)。 与重写equals+hashcode没有关系。底层的数据结构是树结构。
        /*TreeSet userInfoSet = new TreeSet<>(new Comparator() {
            @Override
            public int compare(UserInfo o1, UserInfo o2) {
                return o2.getAge()-o1.getAge();
            }
        });*/
        //TreeSet userInfoSet = new TreeSet<>((user1,user2)->user1.getAge()-user2.getAge());
       /* TreeSet userInfoSet = new TreeSet<>(Comparator.comparing(new Function() {
            @Override
            public Integer apply(UserInfo userInfo) {
                return userInfo.getAge();
            }
        }).reversed());*/
        TreeSet userInfoSet = new TreeSet<>(Comparator.comparing(UserInfo::getAge).reversed());

        userInfoSet.add(new UserInfo(1, "张三", 20));
        userInfoSet.add(new UserInfo(2, "李四1", 180));
        userInfoSet.add(new UserInfo(3, "李四1", 181));
        userInfoSet.add(new UserInfo(4, "李四1", 118));
        userInfoSet.add(new UserInfo(5, "李四1", 108));
        userInfoSet.forEach(System.out::println);
    }

4.6 CopyonWriteArraySet

public boolean addIfAbsent(E e) {
    Object[] snapshot = getArray();
    return indexOfRange(e, snapshot, 0, snapshot.length) < 0
        && addIfAbsent(e, snapshot);
}

5. Map

存储的是一组数据。 key---value   key值必须唯一   value可以重复的。

在开发中:  key的类型一般就是String/Integer/Long

5.1 常用方法

static interface  Map.Entry   维护了map集合里面的每组数据。

方法	作用
V``put(K key, V value)	新增一组元素
V``remove(Object key)	根据key删除value  没有找到key返回null
boolean``remove(Object key, Object value)	根据指定的key/value删除元素
V``replace(K key, V value)	根据指定的key修改value
boolean``replace(K key, V oldValue, V newValue)	根据指定的key/value，使用新的value进行修改
V``get(Object key)	根据key获得value
V``getOrDefault(Object key, V defaultValue)	根据key获得value 找不到特定的key 返回值的是默认值
void``forEach(BiConsumer action)	遍历map集合元素
Set>``entrySet()	获得map集合里面 每组数据  都存储set集合中
Set``keySet()	获得map里面所有的key
boolean``containsKey(Object key)

5.2 使用方法

private static void demo1() {
    //创建map集合对象
    //使用map集合维护一个用户完整信息  id=20  name=张三  age=20  pass=1234
    Map userInfoMap = new LinkedHashMap<>();
    //1.新增数据----> key值重复 等价新值会覆盖旧的数据
    userInfoMap.put("id", 1001);
    userInfoMap.put("name", "张三");
    userInfoMap.put("age", 20);
    userInfoMap.put("pass", "1234");

    //2.删除 根据key删除  key是唯一
    //System.out.println(userInfoMap.remove("pass"));
    //System.out.println(userInfoMap.remove("pass", "12345"));

    //3.修改
    //System.out.println(userInfoMap.replace("pass", "12345"));
    //System.out.println(userInfoMap.replace("pass", "1234","12345"));

    //4.查询
    //System.out.println(userInfoMap.get("name1"));
    //前提: 集合存储相同类型的数据
    //System.out.println(userInfoMap.getOrDefault("name1", ""));

    //5.判断
    System.out.println(userInfoMap.isEmpty());
    System.out.println(userInfoMap.size());
    System.out.println(userInfoMap.containsKey("name"));

    System.out.println(userInfoMap);


}

5.3 遍历map

private static void demo2() {
    Map userInfoMap = new LinkedHashMap<>();
    userInfoMap.put("id", 1001);
    userInfoMap.put("name", "张三");
    userInfoMap.put("age", 20);
    userInfoMap.put("pass", "1234");

    //遍历map集合元素
    /* userInfoMap.forEach(new BiConsumer() {
            @Override
            public void accept(String key, Object value) {
                System.out.println(key + "----" + value);
            }
        });*/
    //userInfoMap.forEach((key, value) -> System.out.println(key + "----" + value));
    //jdk1.8之前的遍历方式

    /*Set> entrySet = userInfoMap.entrySet();//推荐
        //将map集合里面的每组数据都依次的封装成一个个的entry对象 再将entry对象存储set集合中
        for (Map.Entry entry : entrySet) {// map集合中每组数据  都在entry里面
            String key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + "----" + value);
        }*/

    /* Set keySet = userInfoMap.keySet();//获得map集合里面每个key 存储set集合中
        for (String key : keySet) {
            System.out.println(key + "----" + userInfoMap.get(key));
        }*/


}

5.4 Map_案例

private static void demo3() {
    String str = "djhdf77gggaf6t3gdshgfsa";
    //使用map集合实现: 统计每个字符出现的次数  a=2
    Map map = new HashMap<>();
    //1.获得字符串里面的每个字符
    int length = str.length();
    for (int index = 0; index < length; index++) {
        String s = String.valueOf(str.charAt(index));//获得每个字符数据
        // V merge(K key, V value, BiFunction remappingFunction)
        map.merge(s, 1, Integer::sum);
        /*//判断这个s字符是否存在于map集合中
            Integer num = map.get(s);
            if (num != null) {
                num += 1;
            } else {
                num = 1;
            }
            //第一次存储字符
            map.put(s, num);
            //之前存储过相同的字符  获得之前的次数+1*/
    }
    System.out.println(map);

}

5.5 常用实现类

	数据结构	key以及value是否可以为null	线程安全
HashMap	位桶+链表+红黑树	k/v都可以为null	否
LinkedHashMap	链表+哈希表	都可以为null	否
TreeMap	红黑树	key:不能为null  value:可以	否
HashTable	哈希表	都不能为null	是 syn
ConcurrentHashMap	哈希表	都不能为null	是 CAS

5.6 HashMap

HashMap() 
构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。 

HashMap(int initialCapacity) 
构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。

static final float DEFAULT_LOAD_FACTOR = 0.75f;
final float loadFactor;//0.75
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//16
static final int MAXIMUM_CAPACITY = 1 << 30;
static final int TREEIFY_THRESHOLD = 8;//链表转数结构的阈值
static final int UNTREEIFY_THRESHOLD = 6;//树结构转链表结构
static final int MIN_TREEIFY_CAPACITY = 64;//链表转数结构的一个条件  数组的length
transient Node[] table;//位桶 数组 
int threshold;//执行再次扩容的阈值  0  12 

public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

1. put

解决hashmap的hash冲突的方案:
   1. hash一致 key值得数据一致   新的value会覆盖掉oldvalue
   2. hash一致 key的数据不同  使用单向链表解决。
       链表元素个数>=TREEIFY_THRESHOLD-1的时候  && length>64  将链表结构转树结构
   3.使用树结构TreeNode解决。

public V put(K key, V value) {// 1  1
    return putVal(hash(key), key, value, false, true);
}

//计算key的哈希值  采取的方式高16位的位运算  目的: 减少hash的碰撞
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node[] tab; Node p; int n, i;
    // n就是的数组长度 length   i维护索引值
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)//采取位运算求索引 
        tab[i] = newNode(hash, key, value, null);
    else {//解决hash冲突的问题
        
        Node e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;// key的hash一致 且key的数据一致  
        else if (p instanceof TreeNode)
            e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
        else {
            //key的hash是一样的   但是key的数据不同的
            //使用单向链表解决hash冲突的问题
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    //链表里面的元素个数>=7  数组的length>=64
                    //会将链表结构的数据转换成树结构的数据
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key 
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;//新的value覆盖旧的value
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)//新增元素的个数>阈值 执行扩容
        resize();
    afterNodeInsertion(evict);
    return null;
}

2. resize

第一次执行put的时候。

final Node[] resize() {
        Node[] oldTab = table;//旧数组
        int oldCap = (oldTab == null) ? 0 : oldTab.length;//旧容量
        int oldThr = threshold;//旧阈值
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            //第一次put的时候  执行else逻辑
            newCap = DEFAULT_INITIAL_CAPACITY;//16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//12
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node[] newTab = (Node[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node loHead = null, loTail = null;
                        Node hiHead = null, hiTail = null;
                        Node next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

在HashMap里面  何时会执行扩容?

1. put:
    1. 第一次put的时候  初始化数组空间
    2. size>threhold  会执行再次扩容
2. 链表转树结构的时候：  treefyBin()
        
扩容:  2倍

6. Stream+lamda

是jdk1.8+之后新特性。作用: 操作集合Collection元素。聚合数据

使用lamda的原因： 简化 匿名内部类(接口)操作、接口必须是个@FunctionalInterface

6.1 获得Stream实例

private static void demo1() {
        //1.获得集合对象Collection
        List list = List.of(1, 2, 3, 4);

        //2.获得Stream的实例
        //Collection集合的方法
        Stream stream = list.parallelStream();//并行化流
        Stream stream1 = list.stream();//串行化stream
        //并行  VS 串行
        //计算机计算的能力。
        //案例: 1000个数字 求最大值。
        //串行: 类似于冒泡排序 max  有序
        //并行: 同时执行多个任务。 将1000个数据  放到多个任务中(多个线程)。
        //10   每个任务: 随机分配100个数据   10个最值

        //Stream stream2 = Stream.of(1, 2, 3, 4);

        //随机数 Random
        Random random = new Random();
        //随机获得5个随机的数字  1000-10000
        IntStream intStream = random.ints(5, 1000, 10000);
        //提供对于基本数据类型封装Stream---> 减少过多的拆箱+装箱
        intStream.forEach(System.out::println);

        //Arrays
        Stream stream2 = Arrays.stream(new Integer[]{1, 2, 3});
    }

6.2 常用的功能方法

1. distnict/sort

 private static void demo2() {
        List list = new ArrayList<>(1000);
        for (long i = 10000000; i >= 0; i--) {
            list.add(i);
        }
        //需求: 对list集合元素去重并升序/降序排列
        long begin1 = System.nanoTime();
//        TreeSet treeSet = new TreeSet<>();
//        list.forEach(treeSet::add);
        long begin2 = System.nanoTime();
//        System.out.println(begin2 - begin1);//3709702827  1036846933


        //Stream类似于Iterator
        //parallelStream 性能没有 stream 快
        begin1 = System.nanoTime();
        //Stream stream = list.stream();//list集合里面的数据都在stream
        //List list1 = stream.distinct().sorted().collect(Collectors.toList());//使用Stream 聚合数据

        List list1 = list.stream().sorted().distinct().collect(Collectors.toList());

        //是否可以再次使用stream? 无法使用第二次
        //System.out.println(stream.count());

        //获得运算之后的结果
        begin2 = System.nanoTime();
        System.out.println(begin2 - begin1);
    }

2. filter

 private static void demo4() {

        List list = List.of(10, 20, 40, 60, 60, 50);
        //留下来集合元素>30的数据  存储到另外一个集合里面
        List newList = new ArrayList<>(10);
        for (Integer num : list) {
            if (num > 30) {
                newList.add(num);
            }
        }
        System.out.println(newList);

        //Stream.filter 留下来满足条件的数据
        /*list.parallelStream().filter(new Predicate() {
            @Override
            public boolean test(Integer num) {//stream每个元素
                return num>30;
            }
        })*/

        List collect = list.parallelStream().filter(num -> num > 30).distinct().sorted().collect(Collectors.toList());
        System.out.println(collect);
    }

private static void demo5() {

        List userInfoList = new ArrayList<>(10);
        Collections.addAll(userInfoList,
                new UserInfo(1, 20, "jim"),
                new UserInfo(2, 20, "tom"),
                new UserInfo(3, 20, "zhangsan")
        );

        //查询名称里面包含m一个信息
        List collect = userInfoList.parallelStream().filter(userInfo -> userInfo.getName().contains("m")).collect(Collectors.toList());
        System.out.println(collect);


    }

3. map/peek

一对一

  private static void demo6() {
        List nameList = Arrays.asList("jim", "tom", "zhangsan", "lily", "lilei", "hanmeimei");
        //将集合里面的每个元素都装大写
        /*List upperNameList = new ArrayList<>(10);
        for (String name : nameList) {
            upperNameList.add(name.toUpperCase());
        }
        System.out.println(upperNameList);*/

        //Stream  一对一: Stream里面的每个元素都要执行相同的逻辑
        /*nameList.parallelStream().map(new Function() {
            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        });*/

        //List collect = nameList.parallelStream().map(String::toUpperCase).collect(Collectors.toList());

        List collect = nameList.parallelStream().peek(new Consumer() {
            @Override
            public void accept(String s) {
                s = s.toUpperCase();
                System.out.println(s);
            }
        }).collect(Collectors.toList());
        System.out.println(collect);

    }

private static void demo7() {
    List userInfoList = new ArrayList<>(10);
    Collections.addAll(userInfoList,
            new UserInfo(1, 21, "jim"),
            new UserInfo(2, 22, "tom"),
            new UserInfo(3, 23, "zhangsan")
    );
    //所有人年龄+1
   /* List