第15 天 Collection集合，迭代器，泛型，List接口 ,collection排序，lambda表达式，equlas,arrays.copyof，队列 Queue

Collection集合接口

集合就是一个容器，因为它是Object类型，所以可以存放各种引用数据类型的对象，如Integer…

Collection接口是继承关系中的顶级接口
表示泛型，来规定集合中可以存放哪些类型的元素。泛型中不能使用基本数据类型

list,set,map都是集合

Collection<String> collection = new ArrayList<>();
collection.add() 添加的元素类型是object型
collection.clear() 清空集合
collection.contains() 是否包含某一个元素，返回布尔值
collection.containsall() 是否包含集合中所有元素
containsall()括号内中的是一个List接口中的list
collection.isEmpty() 判断集合是否为空，返回布尔值
collection.remove(“元素名”) 移除集合中的元素 
collection.size() 获取长度，从1开始

System.out.println(collection) 打印整个集合

Collections 排序工具类 静态方法，直接用

Collections.sort(List 接口名) 对数字排序从小到大排序。是堆List类型进行排序
对英文字母或者中文排序时，按照阿斯克码来
排序时，元素必须实现Comparable 接口，对数字和字符来说已经默认实现，如果需要自己定义则需要实现Comparable接口

对自定义的比较时，使用重载的Collections.sort(List list,new Comparator ()) ，只调用一次Comparator接口则定义一个匿名内部类，会出现一个compare(o1,o2)方法 。return o1-o2 时升序 o2-o1 是降序

Collections.reverse(List 接口名) 反转list集合 第一个变成最后一个

泛型

集合中可以加入各种元素，泛型可给它们限定

Collection c = new ArrayList<>();//加入泛型后，只能放String类型的。后边的尖括号默认是String类型
Iterator it = c.iterator();//迭代器所指的泛型与集合的一致

it.next()获取时编辑器会自动强转

集合转数组

String[] array = collection的集合名.toArray((T) new String[5]);// 大写字母代表泛型
若集合中元素个数大于等于数组设定的元素个数（这里是5）则正常转换，该是几个是几个
若集合中的元素个数小于数组设定的个数，则在数组多余的部分补默认值null

数组打印时：sout(Arrays.toString(array))

数组转list

List list = Arrays.asList(数组名称) //直接将数组的地址传入，数组中的元素更改，集合中也更改
输出时直接写sout（list）
注意：使用list.add(“”)时，给集合加东西时，相当于给数组加。数组是定长的，不能加，会发生不支持操作异常

equals

使用equals时注意1.常量.equals(变量)，注意equals的前面不能是null 2. 当常量也是空怎么办？（a==b || a!=null && a.equlas(b)）这个可以简化为Objects.equals(a,b)

Arrays.copyOf

通常用于数组的扩容

data数组 = Arrays.copyOf(data,data.length+10需要扩容的长度)

System.arraycopy

将数组中的固定长度的数据复制到另一个数组中

System.arraycopy(data要复制的数组名,0从要复制的数组的哪一个下标开始复制,data1粘贴到的数组,0从粘贴到的数组的哪一位开始粘贴,5复制几个？)

List 接口

List接口是Collection接口的子接口，是实现Collection接口的一种方式。List是集合
只有List集和数组相关 array只能转为list
List接口的三大实现类 ：ArrayList、LinkedList、Vector
List接口的所有实现类都有的特点：
1.有序的集合
2.方法中具有索引
3.允许存储重复元素

List<String> list = new ArrayList<>();
list.add ("添加元素") 在末尾添加
list.add （索引，“添加的元素”）在固定的索引处添加元素
list.indexOf("需要查找的元素") 获取元素第一次出现时的索引，找不到返回-1
list.remove(索引) 删除索引处的元素
list.set(索引，“元素”) 修改指定索引处的元素
List<String> strings = list.subList(2,5) 截取索引为2，3，4的元素，包头不包尾

list.sort(new Comparator<>){
public int compare
return 
}//内部和Collections的排序方法一样，list本身自带的排序方法。可以用lamda表达式简化

List接口的实现类–ArrayList

有List的全部方法，是List的 实现类
特点
1.内部的数据结构是数组
2.内存是连续的
3.查询速度相对快
4.增删速度相对慢
5.是一个线程不安全的集合
初始化容量是10，在第一次添加元素时创建长度为10的数组
扩容是原来容量+原来容量/2

arrayList.get(元素索引下标下标从零开始) 根据下标获取元素
arrayList.set(下标，“要替换的元素”) 将指定元素设置到指定位置，并返回原来的元素
arrayList.remove(下标) 删除下标处的元素并将被删除的元素返回。打印的是数组格式
arrayList.add(下标，“元素”) 将元素插入到对应的下标处
arrayList.subList(开始的下标，结束的下标) 返回一个新List，包含开始的下标，不包含结束的下标。注意：对新的List数据进行操作，原来的List数据也更改，原来的更改，新生成的数据也会更改。因为他们指向一个对象.这里的更改主要指数据的变大变小。如果原集增删则不能对子集进行操作，因为载体变了，对子集进行增删，原集也一起增删。

ArrayList<Integer> arrayList = new ArrayList<>(); 或者 List<Integer> arrayList = new ArrayList<>();向上造型
        List<Integer> sub = arrayList.subList(3,8); //sub是子集
        arrayList.add(10);
        arrayList.trimToSize();//将ArrayList的容量缩小为当前元素的实际个数
        sout(list);打印list
        

List接口的实现类–LinkedList

特点：
1.内部的数据结构是双向链表
2.内存是不连续的
3.查询速度相对慢
4.首尾增删速度相对快
5.是一个线程不安全的集合
6.链表没有初始化容量

计算机底层只能记住链表首和尾的地址，中间的地址不知道

LinkedList<String> linkedList = new LinkedList<>();

linkedList.add("添加元素")
linkList.get() 根据下标获取元素
linkList.set() 将指定元素设置到指定位置，并返回原来的元素
linkList.getFirst() 获取头节点的值
linkList.getLast() 获取尾节点的值
linkList.addFirst(“要添加的值”) 在第一个位置添加值
linkList.getLast(“要添加的值”) 在最后一个位置添加的值
linkList.pollFirst() 删除并返回头节点的值
linkList.pollLast() 删除并返回尾结点的值
linkList.removeFirst() 没有这个元素异常

linkList.pollFirst() 删除并返回尾结点

List接口的实现类–Vector

特点：

1. 内部数据结构是数组
2. 查询速度快
3. 增删速度慢
4. 线程安全的集合，效率不高
5. 在创建对象时，默认长度为10
6. 每次默认扩容，是原来容量的1倍

Vector<String> vector = new Vector<>(5,6)
vector.add("中国");

Vector类的子类—Stack实现类

Stack是栈结构
栈的结构是LIFO（先进后出）

压栈/入栈：从栈顶到栈底的过程
出栈/弹栈：从栈底到栈顶的过程

底层数据结构是数组

Stack<String> stack = new Stack<>();
stack.add(" ");//压栈

String pop = stack.pop();
sout(pop)//弹栈 最上面的元素会从栈中弹出
sout(stack)//栈中会少一个元素

stack.push("  ")//入栈

String peek = stack.peek();//获取栈顶的元素
sout(stack)//栈中不会少元素


//查找指定的元素出现的位置
//是从栈顶向栈底查找，用1作为基数，返回一个数值
int search = stack.search("要查找的元素");

lambda

为了简化代码
匿名内部类转为lambda要求 1.接口中要求实现的类必须重写的方法（静态方法，默认方法default不算）只有一个

lambda把方法名和接口名都已经隐掉

格式：
（方法中的参数列表）->{
方法体
}
lambda表达式中参数类型可以不写，方法体中只有一句话可以不写

:: lambda的简写形式

:: 是方法引用
何时用？ 箭头左边的参数和右边的语句的参数相同，左边和右边的返回值一样，或者没有返回值时

读的时候需要把四饼看成点（.）什么社么的方法，左边参数，箭头，右边语句的参数都消失

集合

集合和数组一样，可以保存一组数据，集合提供了很多方法，比数组的操作更加方便

集合框架中的相关接口：
1）java.util.Collection接口：是所有集合的顶级接口，封装了所有集合所共有的方法，下面有很多实现类

2）Collection接口下有两种常见的子接口
2.1）java.util.List:线性表，可以重复集合，并且无序
2.2）java.util.Set:不可重复集合，大部分实现类是无序的

Collection c = new ArrayList(); 向上造型
c.add(1)//add括号内的值是object类型，与基本类型没有关系，能够写1是因为自动装箱为Integer类型
集合重写了Object的toString()方法，输出不是hashcode

add() :自动扩容，添加元素
contains():集合中是否包含元素，使用重写后的equals判断
remove():删除括号内equals相等的值，如果有重复的也只删一次
.clear():清空集合

集合装的不是对象，而是对象的地址

addAll():添加集合
c1.addAll(c2) : 将c2追加到c1末尾
containsAll():检查集合中是否有这个集合的所有元素
c1.retainAll(c3):在c1中取两个交集取都有的，c3不变
c1.removeAll(c3):在c1中删除与c3共有的

集合的遍历

Collection接口提供了统一遍历集合的方式：迭代器模式
通过iterator()方法获取一个用于遍历当前元素集合的迭代器（Iterator接口）

java.util.Iterator接口

Interator a = 集合名.iterator();

# Queue 队列
先进先出
声明：Queue<String> queue = new LinkedList<>();
加入元素：queue.add("")//queue.offer("")
删除第一个元素：queue.remove()//queue. poll()
返回队列第一个元素：queue.peek()//queue. element()

## 迭代器的常用方法
1.boolean 类型hasnext()：询问集合是否还有“下一个”元素可以替代。必要操作
迭代器默认开始位置在集合第一个的前面，无论调用多少次hasNext(),迭代器的位置都不会改变，只是指向下一个问有没有
2. Object 类型next():取出元素。必要操作
经过hasNext()询问，如果有迭代器向后移动一个位置指向集合的下一个元素并将其获取。不必要操作
3. void类型 迭代器名称.remove(); 删除迭代器所获取的元素。不能用集合的remove（）方法，只能用迭代器的。



# 增强for循环
解决了数组遍历用for，集合遍历用迭代器。双方不能通用的问题
内部是iterator实现，不能动态增删元素。只能查看

for（要取的数组或集合中的元素的类型 取回的变量名：要取的数组或集合名）{
			循环体;
}
#



new一个对象，对象. 的都是实例方法
类名直接点的是静态方法