失眠网 > 集合（容器）List Set Map 泛型 Lambda表达式

集合（容器）List Set Map 泛型 Lambda表达式

时间：2019-06-11 21:47:34

1. 集合架构

Collection 接口存储一组不唯一，无序的对象

List 接口存储一组不唯一，有序（索引顺序）的对象

Set 接口存储一组唯一，无序的对象

Map接口存储一组键值对象，提供key到value的映射

Key 唯一无序

value 不唯一无序

2.Collection：

创建集合：Collection coll = new ArrayList<>();

coll.add();添加数据

.addAll();添加一个集合

.size（）；查看集合的元素数量

.isEmpty（）；清空集合内的元素

.contaise（）；查看是否包含

3.ArrayList：

有序（添加顺序）不唯一

ArrayList list = new ArrayList<>();

list.add(11);添加元素

list.add(“你好”);

list.add(new Date().toLocaleString());

//将指定元素添加到指定位置

list.add(1, “世界”);

//判断指定元素是否在集合内

list.contains(“世界”)；

//获取指定位置的元素

Object o = list.get(2);

//删除指定的元素删除成功返回true

boolean b = list.remove(“你好1”);

//返回删除的元素

Object remove = list.remove(0);

list.size();

//ArrayList 集合下标 0开始数量-1结束或获取最后一个元素

list.get(list.size() - 1);

//清空集合的内容

list.clear();

System.out.println("list1: "+list1);

//有对应的值返回下标没有对应的值就返回-1

int index = list.indexOf(“你好1”);

//修改指定位置的值

list.set(0, 666);

//取两个集合的交集

list.retainAll(list2);

//Integer 类型的集合在删除元素时一定要手动进行包装

list.remove(Integer.valueOf(2));

4.LinkedList：

有序（添加顺序）不唯一

创建集合对象、链表、操作头尾的方法

list.addFirst(“范冰冰”);将数据添加到第一个

list.add(0, “李冰冰”);

//添加到最后

list.addLast(“迪丽热巴”);

list.add(list.size()-1, “古力娜扎”);

list.getFirst();

list.getLast();

//返回删除的元素

String first = list.removeFirst();

String last = list.removeLast();

//设置指定位置的元素

list.set(0, “孙丽”);

equals：底层采用的是一一对应进行比较

第二节ArrayList和LinkedList

5.理解 ArrayList的源码

ArrayList底层就是一个长度可以动态增长的Object数组；（StringBuilder底层就是一个长度可以动态增长的char数组）

JDK1.7中，使用无参数构造方法创建ArrayList对象时，默认底层数组长度是10。JDK1.8中，使用无参数构造方法创建ArrayList对象时，默认底层数组长度是0；第一次添加元素，容量不足就要进行扩容了。

容量不足时进行扩容，默认扩容50%。如果扩容50%还不足容纳新增元素，就扩容为能容纳新增元素的最小数量。（也就是1.5倍）（采用位运算 >>1 右移1位除以2 左移一位*2）

LinkedList增加了哪些方法

增加了对添加、删除、获取首尾元素的方法

addFirst()、addLast()、removeFirst()、removeLast()、getFirst()、getLast()、

6.理解LinkedList的底层源码

底层结构是一个双向链表。

有一个静态内部类Node，表示双向链表的节点。

LinkedList实现了Deque接口，所以除了可以作为线性表来使用外，还可以当做队列和栈来使用

7.ArrayList与LinkedList的区别

（1）底层存储的数据结构不一样

ArrayList：数组

LinkedList：链表

（2）在获取元素的时候

ArrayList：可以直接定位想要获取的元素

LinkedList：从头到尾进行遍历

（3）删除、添加的时候

ArrayList：牵一发而动全身，会有元素的移动

LinkedList：通过节点的增加或删除完成，不会影响其他的元素

（4）LinkedList：新增操作头尾的方法

8.使用 LinkedList 模拟栈和队列的操作

栈：后进先出

队列：先进先出

模拟栈的操作：

Deque deque = new LinkedList<>();

deque.push(10);

deque.push(20);

deque.push(30);

deque.pop();//出栈弹栈

System.out.println(deque.peek());获取

模拟队列：

Queue queue = new LinkedList();

queue.add(66);

queue.add(88);

queue.add(99);

queue.poll();//删除队头/首

System.out.println(queue.peek());//获取队头元素

9.Set集合：

无序、唯一（数据元素不重复）

HashSet：无序、唯一

set接口相较于Collection接口，并没有新增任何方法

.clear（）清空集合

.remove（）删除

理解 HashSet的源码

HashSet的底层使用的是HashMap，所以底层结构也是哈希表

HashSet的元素到HashMap中做key，value统一是同一个Object()

LinkedHashSet：有序（按照添加的顺序）、唯一

.isEmpty（）当集合内没有元素时返回true

TreeSet：有序（自然循序）、唯一

理解 TreeSet的源码

TreeSet的底层使用的是TreeMap，所以底层结构也是红黑树

TreeSet的元素e是作为TreeMap的key存在的，value统一为同一个 Object()

10.hash表的结构或：

顺序表+ 链表

1.计算要存入数据的hash码 hashCode()

2.根据hash码来计算在hash表内顺序表中的位置

3.添加

（1）对应位置没有数据直接添加

（2）对应位置有数据进行比较 equals() 当要添加的数据和已经存在的数据不重复 "向后"添加

（3）对应位置有数据进行比较 equals() 当要添加的数据和已经存在的数据重复不添加

（4）要想使用HashSet LinkedHashSet 实现唯一效果必须重写hashCode（）和 equals() 方法

11.Map集合:

HashMap：

无序、唯一

底层默认容量为16

HashMap<Integer,String> map = new HashMap<>();

Integer:指的是键，也就是key String：指的是值，也就是value

1.存储的是键值对2.key是不能重复的，当key重复了后出现的value会覆盖前面的value

3.value是可以重复的

添加

map.put(1, “英国”);

map.put(2, “China”);

//通过key获取value

String in = map.get(“in”);

//返回删除的键值对

String en = map.remove(“en”);

//获取所有的key

Set keys = map.keySet();

//获取所有的value

Collection values = map.values();

含有多少元素不含重复的

int size = map.size();

判断值是否为空

boolean empty = map.isEmpty();

//替换指定key的value

map.replace(“in”, “印度”)；

LinkedHashMap：有序（添加的顺序）、唯一

//Entry 中存储的就是键值对

Set<Map.Entry<Integer, String>> entries = map.entrySet();

TreeMap：

有序（按key的自然顺序）、唯一

如果在key的位置添加自定义数据则必须使用内部比较器或外部比较器

每个节点的结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TcYBO9i1-1595140509331)(E:\有道云图片\qq433A8C57C88B51E6DF4A4B18D16012EA\c20ac39f46b840b4a6bd8144f24875aa\clipboard.png)]

键值左边的正确的根源颜色

遍历：

方式一：

//存储的是map中所有的key

Set keys = map.keySet();

for(Integer key:keys){

System.out.println(key+" : "+map.get(key));

}

方式二：

Iterator iterator = keys.iterator();

while (iterator.hasNext()){

Integer key = iterator.next();

System.out.println(key+" : "+map.get(key));

}

方式三：

Set<Map.Entry<String,String>> entries = map.entrySet();拿到键值对

for(Map.Entry ele : entries){

System.out.println(ele);

System.out.println(ele.getKey()+"<=====>"+ele.getValue());

}

12.Iterator集合

Iterator专门为遍历集合而生，集合并没有提供专门的遍历的方法

Iterator实际上迭代器设计模式的实现

Iterator的常用方法

boolean hasNext(): 判断是否存在另一个可访问的元素

Object next(): 返回要访问的下一个元素

void remove(): 删除上次访问返回的对象。

哪些集合可以使用Iterator遍历

层次1：Collection、List、Set可以、Map不可以

层次2：提供iterator()方法的就可以将元素交给Iterator;

层次3：实现Iterable接口的集合类都可以使用迭代器遍历

for-each循环和Iterator的联系

for-each循环(遍历集合)时，底层使用的是Iterator

凡是可以使用for-each循环(遍历的集合)，肯定也可以使用Iterator进行遍历

for-each循环和Iterator的区别

for-each还能遍历数组，Iterator只能遍历集合

使用for-each遍历集合时不能删除元素，会抛出异常ConcurrentModificationException使用Iterator遍历合时能删除元素

Iterator是一个接口，它的实现类在哪里？

在相应的集合实现类中 ,比如在ArrayList中存在一个内部了Itr implements Iterator

为什么Iterator不设计成一个类，而是一个接口

不同的集合类，底层结构不同，迭代的方式不同，所以提供一个接口，让相应的实现类来实现

ListIterator

ListIterator和Iterator的关系

public interface ListIterator<E> extends Iterator<E>

都可以遍历List

ListIterator和Iterator的区别

使用范围不同

Iterator可以应用于更多的集合，Set、List和这些集合的子类型。

ListIterator只能用于List及其子类型。

遍历顺序不同

Iterator只能顺序向后遍历; ListIterator还可以逆序向前遍历

Iterator可以在遍历的过程中remove();ListIterator可以在遍历的过程中remove()、add()、set()

ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。

Collentions：

//添加元素

List list = new ArrayList();

Collections.addAll(list, 10, 50, 30, 90, 85, 100);

//排序

Collections.sort(list);//默认按照内部比较器

//查找元素(元素必须有序)

int index = Collections.binarySearch(list, 500);//不存在返回负数

//获取最大值和最小值

int max = Collections.max(list);

int min = Collections.min(list);

//填充集合

Collections.fill(list, null);

//复制集合

List list2 = new ArrayList();

Collections.addAll(list2, 10, 20, 30, 50);

dest.size >= src.size 目标列表的长度至少必须等于源列表。

Collections.copy(list, list2);

//同步集合

//StringBuffer 线程安全效率低 StringBuilder 线程不安全，效率高

//Vector 线程安全效率低 ArrayList 线程不安全，效率高

//难道是要性能不要安全吗，肯定不是。

//在没有线程安全要求的情况下可以使用ArrayList

//如果遇到了线程安全的情况怎么办

//方法1：程序员手动的将不安全的变成安全的

//方法2：提供最新的线程安全并且性能高的集合类

//将list3转换成线程安全的集合类

list3 = Collections.synchronizedList(list3);

13.泛型：

T:type E：element K：key V：value

规定输入数据的类型

（1)声明在接口处，就是泛型接口

public interface Iterable

(2)泛型类：将泛型的声明放到类的声明处

public class LinkedList

（3）泛型方法：将泛型放到方法的返回值前

public staticvoid add( t)

（4）上限和下限

上限：<?extends E>最大只能是E

下限：<?superE>最小值能是E

任意类型：

位置类型：<?>

（5）存在编译阶段，运行时泛型会消失叫泛型擦除

14.旧的集合类：

Vector：线程安全扩容到原来的2倍

ArrayList：线程不安全扩容到原来的1.5倍

Hashtable：线程安全键值不能为nullHashMap：线程不安全键可以为null，值不可以为null

15.新一代并发集合类：

ConcurrentHashMap: 分段（segment）锁定+Lock锁

CopyOnWriteArrayList ：CopyOnWrite+Lock锁

CopyOnWrite原理：添加时，写时复制再加锁，读不需要加锁

· CopyOnWriteArraySet：CopyOnWrite+Lock锁，写的时候加锁

16.集合和数组的比较

数组不是面向对象的，存在明显的缺陷，集合完全弥补了数组的一些缺点，比数组更灵活更实用，可大大提高软件的开发效率而且不同的集合框架类可适用于不同场合。具体如下：

1 : 数组容量固定且无法动态改变，集合类容量动态改变。

2：数组能存放基本数据类型和引用数据类型的数据，而集合类中只能放引用数据类型的数据。

3：数组无法判断其中实际存有多少元素，length只告诉了array容量；集合可以判断实际存有多少元素，而对总的容量不关心

4：集合有多种数据结构（顺序表、链表、哈希表、树等）、多种特征（是否有序，是否唯一）、不同适用场合（查询快，便于删除、有序），不像数组仅采用顺序表方式

5：集合以类的形式存在，具有封装、继承、多态等类的特性，通过简单的方法和属性调用即可实现各种复杂操作，大大提高软件的开发效率。

17.Lambda表达式

语法：

(parameters) -> expression或 (parameters) ->{ statements; }

参数：要重写的方法的形参列表

-> ：lambda运算符

表达式/语句体：要重写的方法的方法体

无参数无返回值

一个参数无返回值

多个参数无返回值

有参数有返回值

总结：

->左面：

参数类型可以省略不写！->类型推断

如果只有一个参数，()可以省略不写

->右侧：

{}将方法体的具体内容包裹起来

只有一个方法体执行语句的话，{}可以省略不写

如果一句执行语句是return语句，return可以省略不写

18.函数接口：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zyo72CDT-1595140509344)(E:\有道云图片\qq433A8C57C88B51E6DF4A4B18D16012EA\aa25239d727c46138de4c926194c2c68\7noh~nd}tp%5zs@bn_z0bog.png)]