Java基础知识（7）
（包括：Arrays工具类，Lambda表达式，单列集合）
目录
一.Arrays工具类。
1.public static String toString(数组) 把数组拼接成一个字符串
2.public staticint binarySearch(数组，查找的元素) 二分查找法查找元素
3.public staticint[]copyof(原数组,新数组长度) 拷贝数组
4.public staticint[]copyofRange(原数组,起始索引,结束索引) 拷贝数组(指定范围)
5.public static void fill(数组,元素) 填充数组
6.public static void sort(数组) 按照默认方式进行数组排序
7.public static void sort(数组，排序规则) 按照指定的规则排序（//简单理解:o1 -02 :升序排列，o2-01 :降序排序）
二. Lambda表达式
1. 函数式编程
(1)函数式编程(Functional programming)是一种思想特点。
(2)函数式编程思想，忽略面向对象的复杂语法，强调做什么，而不是谁去做,而我们要学习的Lambda表达式就是函数式思想的体现。
2. Lambda表达式的标准格式
(1)Lambda表达式是IDK8开始后的一种新语法形式，
如：()->{
}
1）() 对应着方法的形参
2）->固定格式
3）{} 对应着方法的方法体
（2）例子
1）Arrays.sort(arr, new comparator<Integer>(){
@override
public int compare(Integer ol,Integer o2){
return o1-02;
}
})
可以转换为：
Arrays.sort(arr,(Integer ol,Integer o2)->{
return o1 -02;
}
）；
2）注意点:
/1/Lambda表达式可以用来简化匿名内部类的书写
/2/Lambda表达式只能简化函数式接口的匿名内部类的写法
/3/函数式接口:有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@Functionallnterface注解
3.小结
（1）Lambda表达式的基本作用
简化函数式接口的匿名内部类的写法
（2）Lambda表达式的使用前提
必须是接口的匿名内部类，接口中只能有一个抽象方法
（3）Lambda的好处
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码，它可以写出更简洁、更灵活的代码，作为一种更紧凑的代码风格，使Java语言表达能力得到了提升。
4. lambda的省略规则:
（1）参数类型可以省略不写。
（2）如果只有一个参数，参数类型可以省略，同时()也可以省略。
（3）如果Lambda表达式的方法体只有一行，大括号，分号，return可以省略不写，需要同时省略。
（4）如：Arrays.sort(arr,(o1，o2)->o1-o2)；
三.单列集合
1. 单列集合体系结构
| Collection | ||||
| List | Set | |||
| ArrayList | LinkedList | Vector | HashSet | TreeSet |
| LinkedHashSet | ||||
(1)List系列集合:添加的元素是有序、可重复、有索引
(2)Set系列集合:添加的元素是无序(存和取的顺序可能不一样),不重复、无索引
2. Collection
（1）Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的
（2）方法
1）public boolean add(E e) 把给定的对象添加到当前集合中
2）public void clear() 清空集合中所有的元素
3）public boolean remove(E e) 把给定的对象在当前集合中删除
4）public boolean contains(object obj) 判断当前集合中是否包含给定的对象
5）public boolean isEmpty() 判断当前集合是否为空
6）public int size() 返回集合中元素的个数/集合的长度
（3）Collection遍历方式
1）迭代器遍历。
2）增强for遍历
/1/增强for的底层就是迭代器，为了简化迭代器的代码书写的。
/2/它是JDK5之后出现的，其内部原理就是一个lterator迭代器
/3/所有的单列集合和数组才能用增强for进行遍历。
/4/修改增强for中的变量，不会改变集合中原本的数据
/5/格式:
for(元素的数据类型 变量名:数组或者集合){
}
for(string s:list){
System.out.println(s);
}
3）Lambda表达式遍历
/1/得益于IDK 8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。
/2/方法名称：default void forEach(Consumer<? super T> action)；
/3/例子
Collection<String>coll= new ArrayList<>();
co11.forEach(new Consumer<string>(){
@0verride
//s依次表示集合中的每一个数据
public void accept(string s){
System.out.println(s);
}
})；
3. Collection迭代器
（1）迭代器在Java中的类是Iterator，迭代器是集合专用的遍历方式。
（2）Collection集合获取迭代器
Iterator<E>iterator()：返回迭代器对象，默认指向当前集合的0索引
（3）Iterator中的常用方法
1）boolean hasNext()判断当前位置是否有元素，有元素返回true,没有元素返回false
2）E next()：获取当前位置的元素，并将迭代器对象移向下一个位置。
3）remove（） 删除元素
Iterator<string>it=list.iterator();
while(it.hasNext()){
String str =it.next();
System.out.println(str);
}
（4）细节注意点:
1）报错NoSuchElementException
2）迭代器遍历完毕，指针不会复位
3）循环中只能用一次next方法
4）迭代器遍历时，不能用集合的方法进行增加或者删除，如果实在要删除:那么可以用达代器提供的remove方法进行删除，如果要添加，暂时没有办法。4.List
（1）List集合的特有方法
1）Collection的方法List都继承了
2）List集合因为有索引，所以多了很多索引操作的方法。
3）方法
/1/void add(int index,E element) 在此集合中的指定位置插入指定的元素
/2/E remove(int index) 删除指定索引处的元素，返回被删除的元素
/3/E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
/4/E get(int index) 返回指定索引处的元素
（2）List集合的遍历方式
1）迭代器遍历
2）列表迭代器遍历
/1/add（），remove（）
/2/hasPrevious()与hasNext()相反，从后往前
/3/ previous（）与next()相反，从后往前
3）增强for遍历
4）Lambda表达式遍历
5）普通for循环(因为List集合存在索引)
5. ArrayList
（1）ArrayList底层是数组结构
（2）利用空参创建的集合，在底层创建一个默认长度为0的数组
（3）添加第一个元素时，底层会创建一个新的长度为10的数组
（4）存满时，会扩容1.5倍
（5）如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准
（6）使用List中的方法即可
6. LinkedList
（1）特有方法（基本用不到，使用List中的方法即可）
底层数据结构是双链表，查询慢，首尾操作的速度是极快的，所以多了很多首尾操作的特有API。
1）public void addFirst(E e) 在该列表开头插入指定的元素
2）public void addLast(E e) 将指定的元素追加到此列表的末尾
3）public E getFirst() 返回此列表中的第一个元素
4）public E getLast() 返回此列表中的最后一个元素
5）public E removeFirst() 从此列表中删除并返回第一个元素
6）public EremoveLast() 从此列表中删除并返回最后一个元素
7. 泛型深入
（1）泛型简介
1）是IDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。
2）泛型的格式:<数据类型>
3）注意:泛型只能支持引用数据类型
（2）泛型的好处
1）统一数据类型。
2）把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为在编译阶段类型就能确定下来
（3）泛型的细节
1）泛型中不能写基本数据类型
2）指定泛型的具体类型后，传递数据时，可以传入该类类型或者其子类类型
3）如果不写泛型，类型默认是Object
（4）泛型类
1）使用场景:当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类
2）格式:
修饰符 class 类名<类型>{
}
举例:
public class ArrayList <E> {
}
此处E可以理解为变量，但是不是用来记录数据的，而是记录数据的类型，可以写成:K、V等，创建该类对象时，E就确定类型
（5）泛型方法
1）方法中形参类型不确定时
方案①:使用类名后面定义的泛型 所有方法都能用
方案②:在方法申明上定义自己的泛型 只有本方法能用
2)格式:
修饰符 <类型> 返回值类型 方法名(类型 变量名){
举例:
public <T> void show (T t){
}
(6) 泛型接口
1)格式:
修饰符 interface 接囗名<类型>{
}
举例:
public interface List<E>{
}
2）重点: 如何使用一个带泛型的接口
方式1: 实现类给出具体类型
public class MyArrayList2 implements list<string>{
}
方式2:实现类延续泛型，创建对象时再确定
public class MyArraylist3<E> implements List<E>{
}
（7）泛型的继承和通配符
1）泛型不具备继承性但是数据具备继承性。
Eg:泛型不具备继承性:
public static void method(ArrayList<Animal> list){}
此处只能传递Animal，不能传递子类。
数据具备继承性:
ArrayList<Ye>list1 = new ArrayList<>();
list1.add(new Ye());
list1.add(new Fu());
list1.add(new zi());
此处可以传递子类。
2）通配符
?表示不确定的类型，可以进行类型的限定
?extends E:表示可以传递E或者E所有的子类类型
?super E:表示可以传递E或者E所有的父类类型
3）使用场景
/1/定义类、方法、接口的时候，如果类型不确定，就可以定义泛型
/2/如果类型不确定，但是能知道是哪个继承体系中的，可以使用泛型的通配符
8.Set
(1)Set系列集合
无序:存取顺序不一致
不重复:可以去除重复
无索引:没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素
(2)Set集合的实现类
Hashset:无序、不重复、无索引
LinkedHashset:有序、不重复、无索引
Treeset:可排序、不重复、无索引
(3)方法
Set接口中的方法上基本上与collection的API一致。
9. Hashset
（1）Hashset底层原理
Hashset集合底层采取哈希表存储数据
哈希表是一种对于增删改查数据性能都较好的结构
（2）哈希表组成
JDK8之前:数组+链表
JDK8开始:数组+链表+红黑树
（3）哈希值:对象的整数表现形式
根据hashcode方法算出来的int类型的整数
该方法定义在0bject类中，所有对象都可以调用，默认使用地址值进行计算
一般情况下，会重写hashcode方法，利用对象内部的属性值计算哈希值
（4）对象的哈希值特点
如果没有重写hashcode方法，不同对象计算出的哈希值是不同的
如果已经重写hashcode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。(哈希碰撞)
（5）注意：
如果储存的是自定义对象，一定要重写Hashcode方法和equals方法。
10.LinkedHashset
（1）LinkedHashset底层原理：
有序、不重复、无索引。
这里的有序指的是保证存储和取出的元素顺序一致
原理:底层数据结构是依然哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序
(2)方法：
方法上基本上与collection的API一致。
（3）在以后如果要数据去重，使用哪个?
默认使用HashSet，如果要求去重且存取有序，才使用LinkedHashSet（因为LinkedHashSet的效率低）
11. Treeset
（1）Treeset的特点
不重复、无索引、可排序
可排序:按照元素的默认规则(有小到大)排序
Treeset集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好.
（2）Treeset集合默认的规则
对于数值类型:Integer，Double，默认按照从小到大的顺序进行排序。
对于字符、字符串类型:按照字符在ASCI码表中的数字升序进行排序。
（3）利用Treeset存储自定义对象并排序
继承Comparable接口，重写方法（此接口只有一个方法）
@override
public int compareTo(student o){
//指定排序的规则
//只看年龄，我想要按照年龄的升序进行排列
return this.getAge()-o.getAge();
}
this:表示当前要添加的元素
o:表示已经在红黑树存在的元素
返回值:
负数:认为要添加的元素是小的，存左边
正数:认为要添加的元素是大的，存右边
认为要添加的元素已经存在，舍弃
（4）Treeset的两种比较方式
/1/方式-:默认排序/自然排序:Javabean类实现Comparable接口指定比较规则
/2/方式二:比较器排序:创建TreeSet对象时候，传递比较器Comparator指定规则
/3/使用原则:默认使用第一种，如果第一种不能满足当前需求，就使用第二种（两者同时出现，方法二的优先级更高）
/4/例子
o1:表示当前要添加的元素
o2:表示已经在红黑树存在的元素
返回值规则跟之前是一样的
TreeSet<String>ts = new TreeSet<>(new Comparator<String>(){
@Override
public int compare(string o1, string o2){
// 按照长度排序
int i=o1.length()- o2.length();
//如果一样长则按照首字母排序
i=i==0 ? o1.compareTo(o2):i;
return i;
}
12.小结
（1）如果想要集合中的元素可重复
用ArrayList集合，基于数组的。(用的最多)
（2）如果想要集合中的元素可重复，而且当前的增删操作明显多于查询
用LinkedList集合，基于链表的，
（3）如果想对集合中的元素去重
用Hashset集合，基于哈希表的。(用的最多)
（4）如果想对集合中的元素去重，而且保证存取顺序
用LinkedHashset集合，基于哈希表和双链表，效率低于HashSet，
（5）如果想对集合中的元素进行排序
用Treeset集合，基于红黑树。后续也可以用List集合实现排序，
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
