java进阶
java进阶
第一章 继承
1.概述
子类可以继承父类中有的成员变量和成员方法
好处 : 提高代码的复用性
2.继承的机制
关键字 extends
构造方法不会被继承,子类要写自己的构造方法
父类中私有的成员可以被继承,被继承的成员依然是只能被父类访问;
3.继承时成员访问顺序
变量或者方法被调用时,系统会先在本类中寻找,本类中没有就会访问父类中的变量
4.this和super
1.修饰变量
this 调用本类成员变量
super 调用父类成员变量
2.修饰方法
```java
this 本类方法的引用,谁调用,this代表调用的处对象 this.method(); 相当于method
super 父类方法的引用, super.method();
```
3.修饰构方法
this(); 调用本类构造方法
super(); 调用父类构造方法
tip
(1) this 和 super 只能写在构造方法的第一行
(2) 如果构造方法没有写明,构造方法第一行默认有一句super();
5.继承的内存图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jc797JP6-1631766334597)(3.继承的内存图.png)]
在内存中,创建子类对象时,会在子类对象内存空间先创建父类对象, 供子类对象使用
6.方法的重写
1.子类中的方法与父类中的一模一样(参数,返回值类型,方法名,修饰符)
2.重写后子类调用时有限使用子类自己的方法
3.这样使得子类即可以继承父类的方法又可以有自己特有的功能
7.继承的注意事项
1.继承必须有类的所属于父类的关系,子类属于父类才能继承
2.类只支持单继承,一个类只能有一个父类
3.类可以多层继承,一个类有父类,父类还可以有自己的父类,多层继承依然遵循继承的使用规则
第二章 抽象类
1.概述
1.方法体不是具体的
2.没有实例,不能创建对象
3.关键字 abstract
2.格式
public abstract class 类名{
}
3.抽象类的成员
普通类能写的都能写
成员变量
构造方法
成员方法
抽象方法
public abstract 返回值类型 method();
只有方法的定义,没有方法体
4.注意事项
1.抽象类中可以有抽象方法,也可以没有
2.有抽象方法的类必须是抽象类
3.抽象类不能创建对象
4.抽象类一定是一个父类,抽象类的子类要么重写抽象方法,要么也是抽象方法
5.抽象类不能创建对象,构造方法用来给子类创建对象调用
5.抽象类的作用
给子类提供抽象方法,子类可以通过重写方法定义具体的实现方式
6.final关键字
1.final修饰变量
基本数据类型 存的是数据值
不能再次被赋值,变量定义为常量 Math.PI
引用数据类型 存的是地址值
引用地址不可以改变,地址值
2.final修饰方法
被final修饰的方法不能被重写
final和abstract排斥 private 和 abstract
3.final 修饰类
被修饰的类不能被继承
第三章 接口和多态
一.static
1.作用
1.1修饰成员变量
作用: 被static修饰的成员变量属于类,被类的所有对象共享
调用: 对象.成员变量
类名.成员变量
推荐 类名调用 (static修饰的成员属于类,在内存中存放在静态方法区)
1.2修饰成员方法
作用: static修饰成员方法,方便调用
调用: 对象.成员方法
类名.成员方法
推荐 类名调用
2.访问规则
静态方法不能直接访问(间接创建对象)非静态成员,成员方法可以直接访问类的静态成员和非静态成员
3.内存图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wK1jUcGT-1631766334603)(D:/java/%E7%AC%94%E8%AE%B0/se%E8%BF%9B%E9%98%B6/2.%E9%9D%99%E6%80%81%E7%9A%84%E5%86%85%E5%AD%98%E5%9B%BE.png)]
二.接口
1.概述
接口是一种规范
定义格式
public interface 接口名{
}
实现
public class 类名 implements{
}
2.接口的成员
1.抽象方法 public abstract 返回值 方法名(); (public abstract 可以省略)
2.常量 默认被public static final 修饰;
JDK8加入
3.默认方法 public default 返回值类型 方法名 (){ ( public 可以省略)
}
(JDK9加入
4.私有方法 私有成员方法,私有静态方法
3.接口的注意事项
1.常量默认修饰符 public static fianl
2.抽象方法默认修饰符 public abstract
3.接口不能创建对象
4.接口不能有构造方法
5,接口的实现类必须重写抽象方法或者实现类也是抽象类
4.接口使用场景
作用: 定义一种规范
在在开发中定义好方法的返回值,方法名,参数
三.多态
1.概述
一种事务的多种形态
student 既是Student类也是Person类
java中 父类引用指向子类对象
2.多态使用前提
必须有继承extends 或者 实现 implements 关系
3.访问规则
成员变量 编译看左边,执行看左边
成员方法 编译看左边,执行看右边
4.多态优缺点
缺点:
不能使用子类特有的成员(成员变量和成员方法)
优点:
提高了程序的扩展性
父类作为方法的参数,可以传入子类对象调用子类重写的方法
5.多态的类型转换
1.向上转型 (自动转换)
多态 父类引用指向子类对象
Animal a = new Cat();
2.向下转型 (强制转换)
cat c = (cat)a;
四.内部类
1.成员内部类
格式:
public class AAA{
int i = 10;
class BBB{
int i=20;
public void method(){
int i =30;
System.out.println(i);//30
System.out.println(this.i);//20
System.out.println(AAA.this.i);30
}
}
}
创建内部类对象
外部类.内部类 对象名 = new 外部类().new 内部类
AAA.BBB ab = new AAA().new BBB();
内部类访问外部类成员变量
System.out.println(i);//30
System.out.println(this.i);//20
System.out.println(AAA.this.i);30
2.局部内部类
public class AAA{
public void method(){
class BBB{
int a=10;
}
}
}
用处不大
3.匿名内部类
1.格式
Person p=new Person{
public void method(){
重写父类方法
}
};
2.使用场景
方法的参数是抽象方法或者接口,可以通过匿名内部类的方式创建抽象方法或者接口的子类
3.作用
可以简化代码
4.每一个类都有编译后都会生成一个单独的class文件
内部类文件名 外部类名$内部类名.class
匿名内部类,文件名 外部类$数字.class
第四章 代码块 和常用API
一.权限修饰符
public > protected > 默认 > private
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NOAltEKT-1631766334606)(四种权限修饰符.png)]
二.代码块
1.静态代码块
static{
语句体
}
类被加载的时候自动执行,只执行一次
用于静态变量的初始化
2.构造代码块( 初始化代码块 )
{
语句体
}
每次创建对象的时候被自动调用
作用: 构造方法有相同语句体的时候可以放在构造代码块
3.局部代码块
写在方法中 ,用来约束变量
作用: 方法中用不到的变量通过{ }可以在方法执行完之前释放内存,
三.Object 类
1.equals 方法
默认 object中 this == o( 参数 ) 比较的是地址值
在对象所属类中重写之后比较对象的属性
//学生类
@Override
//逻辑严谨
public boolean equals(Object o) {
if(this==o) return true;
if(o==null||getClass()!=o.getClass()) return false;
Student stu = (Student)o;
if(age!=stu.age) return false;
return name!=null?name.equals(stu.name):stu.name==null;
}
2.toString 方法
默认 object中 输出 类型.类名+@+十六进制地址值
重写后输出自定义内容
3.native 本地的 关键词
native修饰的方法没有方法体,调用了其他语言写的调用系统资源的代码
四.date 类
1.Date 日期类
2.构造方法
new Date(); 获取当前时间
new Date(long time) 设置时间 从基准时间开始
计算机中的基准时间 1970年 1 月1 日
3.常用方法
| 方法名 | 作用 |
|---|---|
| long getTime( ) | 返回基准时间到调用对象的毫秒值 |
| after( ); | 判断是调用对象否在参数 |
| before( ); | 判断 |
五.SmipleDateFormat 类
1.日期格式化类
2.构造方法
new SmipleDateFormat( String pattern );
3.常用方法
| 方法名 | 作用 |
|---|---|
| String format( Date date); | 把日期类转换为String |
| Date parse(String source) | 把String解析为 Date |
六.Calendar 日历类
1.构造方法
Calendar.getInstence();
2.常用方法
| 方法名 | 作用 |
|---|---|
| get( int field ); | 根据字段返回对应的值 |
| set(int field ); | 设置字段的值 |
| add(int field,int values); | 字段加减操作 |
七.Arrays 数组工具类
1.工具类
private修饰构造方法,不能创建对象,
所有的成员都用static修饰,用类名调用
2.常用方法
sort(); 排序
toString(); 把数组输出为字符串
八.System类
常用方法
exit(int status); 退出虚拟机
currentTimeMillis() 获取当前系统时间
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
复制数组 src 源数组 srcPos 源数组复制的起始位置, dest 目标数组 destPos 目标数组的起始位置, length 复制的长度
第五章 集合
1.集合体系
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z7pDzVjx-1631766334610)(D:\java\笔记\se进阶\集合体系.png)]
1.Collection
1.Collection是一个接口;
2.Collection中的抽象方法
| 方法名 | 用法 |
|---|---|
| public boolean add(E e); | 添加元素 |
| public boolean remove(E e); | 删除元素 |
| public boolean contains(E e); | 判断集合是否包含参数 |
| public int size(); | 返回集合的长度 |
2.iterator迭代器
1.概述 : 没有索引的集合,可以使用迭代器进行遍历
2.获取迭代器
Collection系的集合可以使用集合对象调用Iterator方法
3.方法
hasNext(); 判断是否还有下一个元素
Next(); 返回下一个元素;
4.遍历用法
while(iterator.hasNext()){
iterator.Next();
}
5.并发修改异常
原因 : 使用迭代器遍历数组时,如果在遍历中使用中集合删除或增加元素,就会引起并发修改异常
措施 : 使用iterator的remove方法
6.for增强
底层是迭代器
格式
for(数据类型 变量名:集合名){
此时的变量就代表集合中的数据
}
3.泛型
1.概念 泛型指广泛的类型, 当我们不确定使用什么类型的时候就可以使用泛型
2.应用于类,方法,接口
1.作用于类
定义在类名的后边 , 具体确定类型是在创建对象的时候
2.作用于方法
定义在返回值之前, 具体确定类型是在调用方法的时候
3.作用于接口
定义在接口的接口名之后,继承类可以确定具体.类型,或者继承类也定义相同的泛型;继承类的实现类创建对象时确定具体类型
3.泛型的通配符
表示可以接受任意类型 表示可以接受A和A的子类 表示可以接受A和A的父类 用于定义,用于使用具体的类型4.数据结构
1.栈和队列
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T7WcNKZP-1631766334613)(D:\java\黑马java\java基础进阶\day05\笔记\3.栈结构.png)]
栈 只有一个开口,先进后出
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iZg0QnWF-1631766334614)(D:\java\黑马java\java基础进阶\day05\笔记\4.队列结构.png)]
队列 有两个开口,先进先出
2.数组
查找快,增删慢
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DXdI32JN-1631766334616)(D:\java\黑马java\java基础进阶\day05\笔记\5.数组结构.png)]
3.链表
增删快,查找慢
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fQgclnCG-1631766334617)(D:\java\黑马java\java基础进阶\day05\笔记\6.链表结构.png)]
5.List接口
1.list的特点 : 有序, 有索引,可以重复
2.方法
| 方法名 | 用法 |
|---|---|
| boolean add(int index , E e ); | 根据索引添加元素(插队) |
| E get( int index ) | 获取索引位置的元素 |
| E remove(int index) | 根据索引删除元素 |
| E set(int index, E e) | 设置索引位置的元素 |
3.ArrayLIst集合
继承自Collection 和 List 的方法
底层用数组实现,元素增删慢,查找快
4.LinkedList 集合
特有方法,对首尾元素进行添加获取的方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rEBBukfc-1631766334619)(D:\java\笔记\se进阶\Snipaste_2021-09-03_20-45-49.png)]
6.可变参数,参数个数可以改变的参数
1.格式
public void sum (int ... a){
}
2.注意事项
(1)传入实参的时候可以传任意个数的元素,也可以传入数组;
(2)可变参数的底层是数组, 在方法中可以把a当做一个数组来使用
(3) 形参列表中只能定义一个可变参数,多个参数的情况可变参数要定义在参数列表最后一个;
1.Collections工具类
1.Collections类有什么用?
Collections是集合的工具类，所有方法都是静态方法
2.Collections有哪些方法?
| 方法 | 说明 |
|---|---|
| static void shuffle(List list) | 随机打乱集合元素的顺序 |
| static void sort(List list) | 集合的排序(从小到大) |
| static void addAll(Collection<> coll, T… t ) | 给集合一次添加多个元素 |
| static void sort(List list，Comparator ) | 按照指定的方式排序 |
import java.util.ArrayList;
import java.util.Collections;
public class Demo01 {
public static void main(String[] args) {
//Collections的方法
//创建两个集合
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(123);
list1.add(456);
list1.add(789);
list1.add(100);
System.out.println("初始:" + list1);
//static void shuffle(List list)
//随机打乱集合元素的顺序
Collections.shuffle(list1);
System.out.println("打乱" + list1);
//static void sort(List list)
//集合的排序(从小到大)
Collections.sort(list1);
System.out.println("排序" + list1);
//static void addAll(Collection<> coll, T... t )
//给集合一次添加多个元素
Collections.addAll(list1,20,30,40);
System.out.println("添加" + list1);
}
}
2.Comparator比较器
1.比较器有什么作用?怎么用?
参数:
Integer o1 : 代表要比较的元素
Integer o2 : 代表已经比较完的元素
返回值:
int:
如果返回值是正数,代表要把o1放在o2的后面
如果返回值是负数,代表要把o1放在o2的前面
如果返回值是零,代表要把o1和o2位置不变,默认o1在后面
记住结论:
o2-o1就是从大到小 o1-o2就是从小到大
2.整数从大到先排序
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Demo02 {
public static void main(String[] args) {
//创建集合
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(123);
list1.add(456);
list1.add(789);
list1.add(100);
//匿名内部类
Comparator<Integer> c = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
};
//排序
Collections.sort(list1,c);
System.out.println(list1); //[789, 456, 123, 100]
}
}
3.字符串的从大到小
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Demo05 {
public static void main(String[] args) {
//创建集合对象
ArrayList<String> list = new ArrayList<>();
//添加元素
list.add("anc");
list.add("abc");
list.add("cba");
list.add("wcba");
list.add("nba");
list.add("mba");
//创建比较器
Comparator<String> c = new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//int i = o1.compareTo(o2); //从小到大
int i2 = o2.compareTo(o1); //从大到小
return i2;
}
};
//排序
Collections.sort(list,c);
//打印
System.out.println(list);
}
}
3.Set接口及子类
1 HashSet集合有什么特点?
hashSet没有索引,元素存取无序,元素不能重复
2.什么是哈希表结构?
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r2oX3GGT-1631766334620)(D:/java/%E9%BB%91%E9%A9%ACjava/java%E5%9F%BA%E7%A1%80%E8%BF%9B%E9%98%B6/day06%E9%9B%86%E5%90%882/%E7%AC%94%E8%AE%B0/2.%E5%93%88%E5%B8%8C%E8%A1%A8%E7%BB%93%E6%9E%84.png)]
3. 什么是hash值?
每个对象都可以调用hashCode()方法,获取这个对象的哈希值
哈希值是一个整数
如果哈希值不同,说明两个对象一定不同
如果哈希值相同,两个对象不一定相同
public class Demo02 {
public static void main(String[] args) {
String s1 = "ab";
String s2 = "abc";
String s3 = "Aa";
String s4 = "BB";
System.out.println(s1.hashCode()); //3105
System.out.println(s2.hashCode()); //96354
System.out.println(s3.hashCode()); //2112
System.out.println(s4.hashCode()); //2112
//底层计算哈希值的时候,想要给每个不同的对象生成一个不同的整数哈希值,所以搞比较复杂的计算方法
/*
int hash = 0;
循环遍历字符串{
hash = hash * 31 + 获取每个字符;
}
hash的值就是这个字符串的hash结果
*/
}
}
4.HashSet如何保证的元素不重复?
HashSet在添加元素的时候,会调用元素的hashCode()和equals()方法
String s0 = "abc";
String s1 = "abc";
String s2 = "Aa";
String s3 = "BB";
String s4 = new String("BB");
p.hash == this.hash && (p.key == this.key || (key != null && key.equals(k)))
先判断两个元素的哈希值
如果两个元素哈希值不同,就直接知道两个元素不重复!
如果两个元素哈希值相同,就去判断两个元素的地址值
如果两个元素地址值相同,就直接知道两个元素重复!
如果两个元素地址值不同,就判断两个元素的内容
如果两个元素内容相同,就重复!
如果两个元素内容不同,就不重复!
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jC5cI47Z-1631766334621)(D:/java/%E9%BB%91%E9%A9%ACjava/java%E5%9F%BA%E7%A1%80%E8%BF%9B%E9%98%B6/day06%E9%9B%86%E5%90%882/%E7%AC%94%E8%AE%B0/3.HashSet%E7%9A%84%E5%AD%98%E5%82%A8.png)]
5. HashSet存储自定义类型演示
如果要存储自定义类型,需要重写hashCode()和equals()方法
package com.itheima02;
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//重写方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
package com.itheima02;
import java.util.HashSet;
public class Demo04 {
public static void main(String[] args) {
//创建集合
HashSet<Student> set = new HashSet<>();
//创建学生对象
Student s1 = new Student("马冬梅",23);
Student s2 = new Student("马冬梅",23);
Student s3 = new Student("夏洛",28);
//添加到集合
set.add(s1);
set.add(s2);
set.add(s3);
//打印
System.out.println(set);
}
}
6.LinkedHashSet集合有什么特点?
元素没有索引,元素不能重复,元素存取有序
package com.itheima02;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
public class Demo06 {
public static void main(String[] args) {
//创建集合
LinkedHashSet<String> set = new LinkedHashSet<>();
set.add("123");
set.add("abc");
set.add("abc");
set.add("edf");
System.out.println(set); //[123, abc, edf]
}
}
4.单列集合总结
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-30IY4Kk0-1631766334623)(D:/java/%E9%BB%91%E9%A9%ACjava/java%E5%9F%BA%E7%A1%80%E8%BF%9B%E9%98%B6/day06%E9%9B%86%E5%90%882/%E7%AC%94%E8%AE%B0/4.%E5%8D%95%E5%88%97%E9%9B%86%E5%90%88%E6%80%BB%E7%BB%93.png)]
5. 双列集合Map
1. Map集合有什么作用?
Map集合称为双列集合,保存的是一对儿一对儿的数据,一对儿的数据也叫键值对
2. Map集合体系
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ysZrc3aI-1631766334624)(D:/java/%E9%BB%91%E9%A9%ACjava/java%E5%9F%BA%E7%A1%80%E8%BF%9B%E9%98%B6/day06%E9%9B%86%E5%90%882/%E7%AC%94%E8%AE%B0/5.Map%E9%9B%86%E5%90%88%E4%BD%93%E7%B3%BB.png)]
3. Map常用方法
| 方法 | 说明 |
|---|---|
| V put(K key, V value) | 添加键值对 |
| V remove(Object key) | 根据键删除对应的键值对 |
| V get(Object key) | 根据键获取值 |
| boolean containsKey(Object key) | 判断是否包含某个键 |
| boolean containsValue(Object value) | 判断是否包含某个值 |
| int size() | 获取集合长度 |
import java.util.HashMap;
import java.util.Map;
public class Demo01 {
public static void main(String[] args) {
//Map双列集合
//创建Map集合
Map<String,String> map = new HashMap<>();
//V put(K key, V value)
//添加键值对
map.put("夏洛","秋雅");
map.put("贾乃亮","小璐");
map.put("王宝强","马蓉");
System.out.println(map); //{贾乃亮=小璐, 王宝强=马蓉, 夏洛=秋雅}
//V remove(Object key)
//根据键删除对应的键值对
map.remove("夏洛");
System.out.println(map); //{贾乃亮=小璐, 王宝强=马蓉}
//V get(Object key)
//根据键获取值
String s = map.get("贾乃亮");
System.out.println("值是" + s);
//boolean containsKey(Object key)
//判断是否包含某个键
boolean b1 = map.containsKey("王宝强");
System.out.println(b1);
//boolean containsValue(Object value)
//判断是否包含某个值
boolean b2 = map.containsValue("马蓉");
System.out.println(b2);
//int size()
//获取集合长度
int size = map.size();
System.out.println(size);
}
}
4. Map集合如何遍历?
1. keySet()键找值方式
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo02 {
public static void main(String[] args) {
//创建Map集合
Map<String,String> map = new HashMap<>();
//V put(K key, V value)
//添加键值对
map.put("夏洛","秋雅");
map.put("贾乃亮","小璐");
map.put("王宝强","马蓉");
//keySet()
Set<String> set = map.keySet();
//增强for
for (String s : set) {
//map获取值
String v = map.get(s);
//打印
System.out.println(s+"-"+v);
}
}
}
2.entrySet()键值对方式
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo03 {
public static void main(String[] args) {
//创建Map集合
Map<String,String> map = new HashMap<>();
//V put(K key, V value)
//添加键值对
map.put("夏洛","秋雅");
map.put("贾乃亮","小璐");
map.put("王宝强","马蓉");
//entrySet()
Set<Map.Entry<String, String>> set = map.entrySet();
//增强for
for (Map.Entry<String, String> entry : set) {
//获取键
String k = entry.getKey();
//获取值
String v = entry.getValue();
//打印
System.out.println(k + "-" + v);
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V5QZP5cT-1631766334625)(D:/java/%E9%BB%91%E9%A9%ACjava/java%E5%9F%BA%E7%A1%80%E8%BF%9B%E9%98%B6/day06%E9%9B%86%E5%90%882/%E7%AC%94%E8%AE%B0/6.Map%E9%9B%86%E5%90%88%E7%9A%84keySet%E9%81%8D%E5%8E%86.png)]
5. HashMap集合有什么特点?
元素存取无序,元素键不能重复
6. LinkedHashMap集合有什么特点?
元素存取有序,元素键不能重复
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
public class Demo04 {
public static void main(String[] args) {
//创建集合对象
HashMap<String,String> map1 = new HashMap<>();
map1.put("小璐","贾乃亮");
map1.put("秋雅","夏洛");
map1.put("马蓉","王宝强");
//如果键重复了,会用新的值覆盖旧的值
map1.put("马蓉","宋喆");
System.out.println(map1); //存取无序,元素键不能重复
LinkedHashMap<String,String> map2 = new LinkedHashMap<>();
map2.put("小璐","贾乃亮");
map2.put("秋雅","夏洛");
map2.put("马蓉","王宝强");
//如果键重复了,会用新的值覆盖旧的值
map2.put("马蓉","宋喆");
System.out.println(map2); //存取有序,元素键不能重复
}
}
7.练习题
需求
输入一个字符串判断里面每个字符出现次数。
代码实现:
import java.util.LinkedHashMap;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//1.键盘输入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String s = sc.next();
//2.创建一个Map集合
LinkedHashMap<Character,Integer> map = new LinkedHashMap<>();
//3.遍历字符串
for (int i = 0; i < s.length(); i++) {
//4.获取字符串的每个字符
char ch = s.charAt(i);
//5.判断集合的键中是否包含字符
boolean b = map.containsKey(ch);
//6.如果不包含就添加字符次数是1
if(b==false){
map.put(ch,1);
}else {
//7.如果包含就获取原来的值+1再放回去
Integer count = map.get(ch);
map.put(ch,count+1);
}
}
//8.打印
System.out.println(map);
}
}
6.模拟斗地主发牌
图解:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DRLvEfjY-1631766334626)(D:/java/%E9%BB%91%E9%A9%ACjava/java%E5%9F%BA%E7%A1%80%E8%BF%9B%E9%98%B6/day06%E9%9B%86%E5%90%882/%E7%AC%94%E8%AE%B0/7.%E6%96%97%E5%9C%B0%E4%B8%BB%E5%88%86%E6%9E%90.png)]
代码:
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
public class Demo02 {
public static void main(String[] args) {
//创建Map集合
Map<Integer,String> map = new LinkedHashMap<>();
//创建ArrayList集合
ArrayList<Integer> list = new ArrayList<>();
//创建花色数组
String[] color = {"♥","♣","♠","♦"};
//创建数字数组
String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
//定义变量
int i = 1;
//遍历数组
for (String n : num) {
for (String c : color) {
//给集合添加
map.put(i,c+n);
list.add(i);
i++;
}
}
//单独添加王
map.put(53,"");
map.put(54,"");
list.add(53);
list.add(54);
//洗牌
Collections.shuffle(list);
//创建4个集合
ArrayList<Integer> list1 = new ArrayList<>();
ArrayList<Integer> list2 = new ArrayList<>();
ArrayList<Integer> list3 = new ArrayList<>();
ArrayList<Integer> list4 = new ArrayList<>();
//发牌
for (int j = 0; j < list.size(); j++) {
//获取元素
Integer a = list.get(j);
if(j>50){
list4.add(a);
}else if(j%3==0){
list1.add(a);
}else if(j%3==1){
list2.add(a);
}else{
list3.add(a);
}
}
//排序
Collections.sort(list1);
Collections.sort(list2);
Collections.sort(list3);
//看牌,拿数字去map里面找牌
method(list1,map,"旭旭宝宝");
method(list2,map,"车友车行");
method(list3,map,"卢本伟 ");
method(list4,map,"底牌 ");
}
//定义看牌方法
public static void method(ArrayList<Integer> list,Map<Integer,String> map,String name){
//遍历list集合
System.out.print(name + ":");
for (Integer a : list) {
//把每个数字当做键从map里面找值
String s = map.get(a);
//打印值
System.out.print(s+"");
}
System.out.println();
}
}
第六章 异常
1.异常的概念：
1).当我们的程序遇到无法处理的数据，使程序无法继续运行时，这种情况就叫"异常"
2).当JVM执行代码过程中，发生了异常情况，程序会被迫终止——这对于最终用户，非常不友好！！
2.异常的处理：
1).Java中提供了一种"处理异常"的语法、机制，可以让代码产生异常时，可以跳过异常的代码，继续健康的运行下去
3.JVM在遇到异常情况下的处理步骤：
1).JVM执行到有异常的代码
2).JVM会识别出异常情况
3).JVM会到"类库"中查找"描述这种异常的异常类"，并创建一个对象。
Java针对任何异常，都有对应的"异常类"
4).JVM会查看我们的代码是否希望"捕获"这个异常(catch(InputMismatchException e))，
a).如果没有catch(InputMismatchException e)：向控制台打印异常类名 + 异常的位置，然后结束程序
b).如果有catch(InputMismatchException e)：会将之前产生的异常对象传递到catch代码中，并执行catch中的代码，程序就不会死了。
4.异常类结构体系
Java类库中有很多的"异常类"，每种异常类都描述了一种异常情况，这些异常类的体系结构：
Throwable(顶层异常类)
|–Error(严重的错误)：指程序中不需要处理，也是无法处理的一些很严重的异常情况
类名后缀：XxxxxError
示例：
1).定义一个Student类：
public class Student {
int[] arr = new int[1024 * 1024];//4M空间
}
2).定义一个测试类：
public static void main(String[] args) {
//Error：程序不需要处理的非常严重的错误
ArrayList stuList = new ArrayList<>();
while (true){
stuList.add(new Student());
}
}
|–Exception(异常)：
|–RuntimeException(运行时异常)：比较普通的异常，如果程序员比较负责任，完全可以避免的异常情况。
1).NullPointerException：空指针异常
2).IndexOutOfBoundsException：索引越界异常(使用ArrayList索引超出范围时)
3).ArrayIndexOutOfBoundsException：数组索引越界异常(使用数组时，索引超出范围)
4).StringIndexOutOfBoundsException：字符串的索引越界异常(使用String时，例如：charAt(index)),索引超出范围)
5).InputMismatchException：Scanner接收到一个与预期不符的数据时，抛出的异常
…
|–除RuntimeException(及子类)以外的其它异常：非运行时异常，也叫：编译期异常。这种异常通常需要我们使用try…catch进行处理，如果不处理，编译不通过
1).ParseException：使用SimpleDateFormat的parse方法时，抛出的异常
…
5.Java异常处理机制最基本的代码：
try{
//写可能出现异常的代码
}catch(异常类名 变量名){
//如果try中出现了和"异常类名"一样的异常，
//将会执行此catch中的代码
}
注意：
1).如果try中多行代码，只要某一行代码出现异常，try中的后续代码将全部被跳过
2).catch(异常类名)中的"异常类名"必须要和try中产生的异常"一致"，否则无法"捕获"
3).catch中的"异常类型"尽量"精确"，尽量不要使用"父类异常类型"
但是，建议以下这种写法：
try {
Scanner sc = new Scanner(System.in);
System.out.println(“请输入年龄：”);
try {//try：尝试
int age = sc.nextInt();//出现异常，下面代码将不会被执行
System.out.println(“你的年龄是：” + age);//上面的代码出异常，这一行不会被执行
} catch (InputMismatchException e) {//catch：捕获异常对象
System.out.println(“你的输入有误！但是程序没有死，仍然可以继续健康的运行下去”);
}
System.out.println(“后续代码…”);
} catch (Exception e) {
System.out.println(“出现未知异常，请联系系统管理员！”);
6.try中可能产生多种异常的情况
在try中如果可能产生多种异常，可以使用以下语句：
try{
…
}catch(异常类型1 变量名){
…
}catch(异常类型2 变量名){
…
}
注意：
1).多个catch()里面的"异常类型"通常是"平级关系"，都是子类。
2).多个catch()里面的"异常类型"可以是"子父关系"，但"父类的异常类型"必须声明在最后面
3).JDK7开始，又有一种新的写法：【不常见】【当多种异常，都使用一种处理方式，可以使用这个语法】
try{
…
}catch(ArrayIndexOutOfBoundsException | NullPointerException | 其它异常类型… 变量名){
//注意：多个异常类型是"或"的关系，所以这里不能出现"父类"类型
//try中只要出现这几种异常的一种，都会执行此catch，在这里如果需要，可以判断具体是哪种类型，比较麻烦
}
7.第三种语法 finally：
try{
…
}catch(异常类型 变量名){
//如果try中出现"异常类型"的异常，会执行这里
}finally{
//无论try中是否出现异常，都会被执行的代码
//通常做一些"资源释放"的操作，当try和catch中都执行完毕，需要释放资源时，可以将代码写在这里
//这里不要修改try/catch使用的变量，return也不是finally中修改的值。
//可以不return 值[建议]，也可以return 值[不建议]
}
应用场景：通常用在某个"方法"中，而且当try/catch中有return语句时，在return之前，无论是否出现异常，
在return之前都需要被执行的代码，可以写在finally中。
try、catch、finally三个关键字有以下几种组合方式：
1).try…catch
2).try…catch…catch
3).try…catch…finally
4).try…catch…catch…finally
5).try…finally(try中如果出现异常，会执行finally，但由于没有catch，所以程序仍然会终止)
8.throws 处理
throws：声明抛出异常，异常的处理方式之一（另一种是try/catch）
它是一个关键字，在"方法"的声明上处理异常，
表示：告诉JVM，如果此方法中产生了声明的异常，让JVM将异常对象抛给"调用的代码"（谁调用我，我就抛给谁）
注意：
如果throws抛出的是：
a).RuntimeException(或者它的子类对象)：调用的代码不用强制try...catch，可以编译通过，
但是，如果出现异常，程序仍然是死掉
b).编译期异常(除Runtime及其子类以外的异常)：调用的代码必须try...catch或者继续throws抛出这个异常，否则编译错误！
9.throws 和 try{} catch的区别
//throws 处理后异常程序出现异常后中断执行
//try catch 方法处理后可以按照自己的逻辑在catch中对异常进行处理
10.异常的操作：
1.创建异常
2.抛出异常 1+2两个步骤叫做产生了异常
3.处理异常
- 声明throws抛出异常
- try/catch捕获异常
throw关键字：用在方法内部，用于：抛出一个异常对象
注意：
1).如果throw抛出的是"运行时异常"，可以不处理异常，即不声明抛出也不try…catch捕获
2).如果throw抛出的是"非运行时异常"，方法必须处理，声明抛出或者try…catch捕获
11.怎样自定义异常：
1.自定义类，继承自Exception或者是它的某个子类
注意：自定义类 extends Exception ：自定义类就是：编译期异常
自定义类 extends RuntimeException(子类)：自定义类就是：运行时异常
2.在某个类的方法中
throw new 自定义异常对象(“异常信息”)
========================================================================
//异常对象的三个常用方法
//1.获取异常信息
System.out.println(“异常信息：” +
e.getMessage());
//2.toString()
System.out.println(“toString：” +
e.toString());//异常类名 + 异常信息
//3.打印异常的完整信息
e.printStackTrace();//红色的异常类名 + 异常信息 + 异常的位置
多线程
第七章 1.进程和线程
进程是正在执行的程序
线程是程序可以独立执行的单元
进程：是操作系统中的概念，指一个独立运行的程序就是一个"进程"
线程：由"进程"创建的，与主进程(即理解为主线程)“同时执行”，提高程序的效率，同时做多件事情。
java程序中，main方法执行在主线程中。
2.多线程：
指我们的程序可以将一部分代码剥离出去，与主程序"同时执行"——这样可以使我们的程序"同时"做多件事情，提高程序的效率！！
3.注意：
1).之前我们编写的程序都是"单线程"的程序，代码从main()开始，后面的代码都要等待前面的代码执行完毕，然后才能被执行。
2).并发：一颗CPU，两个线程
并行：两颗CPU，两个线程，每个线程占用一颗CPU。
上述是在"硬件"层面上的"并发"与"并行"
4.创建线程的两种方式
第一种方式：继承Thread
1).自定类 extends Thread
2).重写run()方法。线程中要做的事情写在run()方法
即定义这个线程要执行的代码
3).启动线程
创建一个线程类对象:自定义Thread 变量 = new 自定义Thread();
调用线程对象的：start()来启动线程
注意：
1).重写的是run()，但启动线程调用的是start()
2).一个线程对象，只能start()一次，执行完毕，这个线程对象自动销毁，不能再次的start()
3).一个线程类，可以创建多个线程对象，每个线程对象都可以独立start()，以独立的线程的方式运行。
第二种方式 implements Runnable ：
1.自定义Runnable类 implements Runnable接口
2.重写run()方法
3.启动线程：
创建一个自定义类对象
Thread t = new Thread(自定义Runnable类对象);
t.start();
======================================================
5.两种实现线程方式的区别：
1).第一种需要子类 继承 Thread类，由于Java是单继承，所以对子类形成了限制。
2).第二种需要子类 实现 Runnable接口，对于子类就比较灵活，子类仍然可以继承其它类，
并且实现其它接口。
6.Thread中的方法
第一种实现线程的方式：自定义类 extends Thread
我们可以从Thread类中继承的方法：
1).run()：必须重写，我们的线程中需要做的事情写到这里；
2).start()：启动线程。不要重写(可以重写)，重写后就无法启动线程了
3).getName()：获取当前的线程名称。
每个线程都有一个默认的线程名称：Thread-索引
4).setName(String s)：设置线程的名称。
--------------以下是一些静态方法--------------------------
5).public static Thread currentThread()：获取当前的线程对象。
6).public static void sleep(long m)：让当前线程休息m毫秒
第八章 线程安全性
1.多线程在内存中的运行机制：
1).多线程运行时，各自线程进入各自的栈区，如果每个线程做的事情不相关，这样没什么问题，
但，如果多个线程访问同一个资源(变量、文件、数据库的数据…)，就会产生多线程的并发问题，
使数据跟最终预想的不一样。
多线程安全问题前提：
1.多个线程
2.访问同一个数据
3.必须有修改/添加/删除元素的逻辑
2).多线程情况下，可能出现的问题有三种：
1).对同一个变量访问的：可见性
多线程的问题一：变量的可见性
当两个线程共同访问一个变量时，如果一个线程将变量的值更改，
而另一个线程由于访问速度过快，而没有看到这个变量被修改，这就是：
由多线程运行机制导致的：变量的可见性问题。
2).对同一段代码访问的：有序性
程序在编译期间,虚拟机有可能把没有上下逻辑关系的代码进行代码顺序的打乱,叫重排.
一个线程的重排可能对其他线程造成影响,叫有序性问题.
编译器经常在不影响最终结果的前提下，为了提高编 译效率，会对一些代码进行"重排——不按照我们编写的顺序"
例如：
//我们编写的代码
int a = 10;
int b = 20;
int c = a + b;
//编译器为了提高编译效率，很可能在不影响最终结果的前提下，对上述代码进行"重排"
int b = 20;
int a = 10;
int c = a + b;
但是，在多线程情况下，这种"代码重排"可能就会使结果不确定！！！
所以，多线程情况下，我们不希望代码进行重排！！！
3).对同一个变量/一段代码访问的：原子性
2.volatile关键字
1)保证内存的可见性,
2)禁止指令重排序,有序性
可以解决可见性的问题,只要给变量加上volatile,变量就会每次都重新获取
3.多线程原子类
从JDK1.5开始，Java提供了一个新的包：java.util.concurrent(JUC包)，这个包中提供了大量的"多线程"的工具类。
1).java.util.concurrent.atomic.AtomicInteger：可以保证多线程对一个int数值访问的原子性。
它内部定义了一个变量，来存储多线程操作的int值：
private volatile int value;
这样可以首先保证变量的：可见性、有序性；
然后通过getAndIncrement()和incrementAndGet()方法中的一些"机制"保证访问变量的"原子性"
什么机制：CAS机制(比较并交换)
2).java.util.concurrent.atomic.AtomicBoolean：对boolean变量访问的原子类
3).java.util.concurrent.atomic.AtomicLong：对long变量访问的原子类
4).java.util.concurrent.atomic.AtomicReference：对引用类型访问的原子类
4.多线程数组操作原子类
1).java.util.concurrent.atomic.AtomicIntegerArray :可以对一个int[]数组做：原子操作。【主要演示】
2).java.util.concurrent.atomic.AtomicLongArray：对long[]数组操作的原子类
3).java.util.concurrent.atomic.AtomicReferenceArray：对引用类型数组操作的原子类
5.synchornized 关键字
1).之前我们学习了多线程并发的三个问题：
1).可见性
2).有序性
3).原子性
2).volatile可以解决变量的：可见性、有序性；
3).对变量的原子性操作：
1).AtomicInteger：对int变量进行原子操作；
2).AtomicIntegerArray：对int[]数组进行原子操作；
4).synchronized(同步的)
如果需要将一段代码进行"原子操作"——一个线程执行这段代码时，其它线程不允许执行这段代码，要在外面排队
必须保证当前正在执行的线程将这段代码全部执行完毕，其它线程才可以执行这段代码。
Java提供一个重量级的对代码进行原子操作的关键字：synchronized(同步的)
5).synchronized使用的两种方式：
A).同步代码块：
public void show(){
synchronized(锁对象){
…
…
…
}
}
“锁对象”：它是一个"对象"——任何类的对象都可以。
重点：但必须保证"多个线程共同拥有同一个<锁对象>"
B).同步方法：[常用]
public synchronized void show(){
}
同步方法：
public synchronized void show(){//当一个线程访问此方法时，立即加锁，其它线程全部在外部等待。
当执行的线程将此方法全部执行完毕，会自动释放锁，其它线程才可以进入
//方法中所有的代码都是"同步代码"
}
同步方法的锁，是this~！！
因为只new了一个runnable，供三个线程使用。
所以三个线程共享同一个对象，该对象就是锁
静态同步方法的锁对象是类名.class
6.Lock锁
从JDK5开始，Java提供了另一种代替synchronized的锁：Lock锁
1).java.util.concurrent.atomic.locks.Lock(接口)：做"锁"的。
API文档中的示例代码：
Lock l = …;
l.lock();
try {
// access the resource protected by this lock
} finally {
l.unlock();
}
2).Lock锁和synchronized锁的区别：
1).Lock锁中的代码如果出现异常，不会自动释放锁，程序就跟死了一样。
Lock锁的功能要比synchronized更强大，使用更灵活。在JUC包(java工具并发包)中的工具类，使用Lock锁的比较多
2).synchronized中的代码如果出现异常，会自动释放锁！在其它包中使用synchronized的比较多
7.对集合做原子操作
1).对int变量进行原子操作：AtomicInteger
2).对int[]数组进行原子操作：AtomicIntegerArray
3).对集合对象进行原子操作：
1).List集合：java.util.concurrent.CopyOnWriteArrayList
面试题：
1).java.util.Vector:它是一个List集合，内部是用数组实现，从JDK1.0开始的
2).java.util.ArrayList：它也是一个List集合，内部也是用数组实现，从JDK1.2开始
3).java.util.concurrent.CopyOnWriteArrayList：它也是一个List集合，内部也是用数组实现，从JDK1.5开始
这三个类有什么区别：
1).最大的区别：
ArrayList是：线程不安全的；
Vector和CopyOnWriteArrayList：是线程安全的。
2).Vector和CopyOnWriteArrayList的区别：
1).Vector内部是用：synchronized实现的，synchronized被称为是：重量级锁(悲观锁)——效率比较低；无论是否有多线程竞争，都会拿锁，有额外的操作。
2).CopyOnWriteArrayList：内部是使用：CAS机制实现的：轻量级锁(乐观锁)——效率高。如果没有多线程竞争，不需要自旋，一次就可以修改成功。只有当有多线程竞争时，才有自旋的产生。
2).Set集合： java.util.concurrent.CopyOnWriteArraySet：
3).Map集合：java.util.concurrent.ConcurrentHashMap：
ArrayList 线程不安全的
Vector 老的,线程安全的 → 大部分方法均是Synchronized修饰的同步方法
CopyOnWriteArrayList 最新的,大部分方法,提供了线程安全的处理,如lock锁 底层使用CAS机制
C:compare 比较
A:and 和
S:swap 交换
CAS指通过逻辑,完成乐观锁的安全判断
8.CAS机制 compare and swap
悲观锁:无论别的线程有没有修改变量,我都认为修改了,要做安全处理
乐观锁:通过代码逻辑,在要判断同步安全问题的时候判断,不用判断的就不判断
具体的过程:
a线程 和 b线程 同时操作共享数据 (以a线程的视角)
a线程预先记录下共享数据的值
a线程调用方法访问集合元素时,会先获取当前的共享数据的值
情况1
预先值 == 当前值 (比较过程C)
没有其他线程操作过该元素,正常操作元素
情况2
预先值 != 当前值 (比较过程C)
终止当前操作,因为期间有其他线程修改了该共享数据
将预先值交换成当前值(交换过程S)
继续重头开始集合操作
第九章 Callable Timer lambda
1.线程池
1).概念：它是一种"容器"，用于缓存一些"线程对象"的。
2).场景：
一个线程对象不能反复的start()，只能start()一次
如果想再次使用此线程，需要再次创建此线程对象
作用：
1).可以缓存一些线程对象，让我们每次执行一个线程不需要创建新的对象，提高创建线程的效率。
2).可以限制多个线程的"并发数量"
3).API：
Executors是一个"工具类"，静态方法：newFixedThreadPool(int n)：可以获取一个有固定容量的线程池对象n为线程个数
ExecutorService：线程池类
submit(Runnable run) 提交执行目标方法：向线程池提交要执行的内容。线程池分配线程执行。
提问：不传入Runnable，传入Thread可以么？ 可以
shutdown() 关闭线程池
4).实现线程的第三种方式：实现Callable接口的方式
1).从JDK1.5开始的
2).之前我们实现线程的两种方式：继承Thread，实现Runnable接口，然后重写run()方法，这两种方式都有两个重要的缺点：
1).run()方法都不能返回值：
2).run()方法不能抛出"编译期异常"
3).实现Callable接口的好处，需要重写call()，此方法就可以：
1).返回值
Callable的call方法会有返回值Future对象，该对象包括了返回值结果，并且提供了一些有用的方法
Future的isDone方法，判断当前callable是否调用结束
Future的get方法，从对象中获取方法真正的返回值
2).可以抛出任何异常
4).实现方式：
第一步：自定义线程类，实现Callable接口，并重写call()方法
第二步：启动线程——必须使用"线程池"启动
5).线程的状态：
当我们操作线程的某些方法时，会使线程处于某些状态下(见图1)
1).新建
start();
2).可运行：
3).计时等待(sleep)
4).锁阻塞(执行到被锁的方法)
5).无限等待(wait())
6).被终止(run()执行完毕)
6). Object中的wait()和notify()
等待(wait)和唤醒(notify)： 它用于两个线程之间的配合
notify(), 没有线程咋等待的时候可以空唤醒
notifyAll() 唤醒所有线程
假如：
第一个线程先启动
工作...
发现一些问题...
wait()释放锁，进入到(无限等状态，等待被唤醒)
第二个线程拿到锁
工作...
工作完毕notify()唤醒在这个锁上等待的线程(不会释放锁)
释放锁
第一个线程拿到锁
恢复工作...
两个线程相互配合一个前提：必须共享同一把锁
2.timer 定时器
Java类库中有一个线程的应用：定时器，可以让程序启动后，在指定的时间/日期时执行一次某个任务，也可以间隔指定的时间反复的执行某个任务
实现定时器：
1).java.util.TimerTask(抽象类)：用于定义定时任务。我们需要继承此类，并重写它内部的run()方法，编写我们的任务。
2).java.util.Timer(类)：用于启动定时任务的。
1).构造方法：
1).Timer()：无参构造
2).成员方法：
1).void schedule(TimerTask task, long delay) 在指定的延迟之后安排指定的任务执行。【只执行一次】
2).void schedule(TimerTask task, long delay, long period)：在delay延迟时间后执行task任务，每间隔period时间，重复执行此任务【往复执行】
3).void schedule(TimerTask task, Date time) 在指定的日期-时间安排指定的任务执行。【只执行一次】
4).void schedule(TimerTask task, Date firstTime, long period)：在firstTime时间开始执行task任务，每间隔period时间，重复执行此任务【往复执行】
5).cancel,用于取消定时器
3.lambda 表达式
1).概念
Lambda表达式：从JDK1.8开始的，它是一种"代替方案"——代替之前当我们调用一个方法，但方法的形参是一个接口，而且接口中只有一个抽象方法时(函数式接口)，
此时，我们需要传入一个"子类"，Lambda表达式就可以代替这个子类。
2).好处：
1).直接写方法体，编写简单
2).Lambda不是语法糖，编译后不是匿名内部类，整个过程没有定义类，没有创建对象，所以效率比较高。
3).弊端：
1).可读性差。
2).不能重用。
3).破坏了Java面向对象的思想。
4).应用面很窄：必须面向"只有一个抽象方法的接口"，必须是接口，而且必须有、且只有一个必须被子类重写的抽象方法(可以有其它的静态方法、默认方法…)。
不能是抽象类。
4).Lambda的标准格式：
1).一对小括号()：方法的形参部分
2).一个右箭头->：Lambda专属语法
3).一对大括号{}：重写的方法的方法体
Lambda表达式必须要面向"函数式接口"：
对于这种"函数式接口"为了保证它的语法正确，通常会加注解：@FunctionalInterface——告诉编译器，下面的接口是一个函数式接口，如果不符合函数式接口的语法，则会编译错误
例如：类库中的Runnable接口：
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
例如：自定义接口：
@FunctionalInterface
interface IA{
public abstract void eat();//子类必须重写
public abstract String toString();//写上这个抽象方法，就没有异常，仍然是一个合法的函数式接口。因为在Object类中有这个方法，任何类都会继承，所以子类可以不重写这个方法。
public boolean equals(Object o);
}
5).简化lambda语法：
如果参数只有一个，可以同时省略：数据类型，一对小括号。
如果方法体中只有一句话，可以同时省略：语句后的分号、一对大括号、return关键字(如果有)
4.Stream 流
1).概念
java.util.stream.Stream(接口)：Stream流是JDK8新增的，它提供了很多方法结合一些函数式接口，可以对大量的数据进行多次的筛选,过滤、统计…操作。
我们可以将Stream流看做一个高级的迭代器，结合Lambda表达式
对大量数据进行遍历、筛选、过滤、统计等操作非常方便。
2).方法
(1).forEach(…)：用于遍历元素的。
参数接收一个Consumer函数式接口，方法为accept(T t)，代表对参数的处理
forEach内部会做一个循环，将每个元素作为"实参"调用一次accept(T t)方法
Consumer的使用可以简化为lambda方式使用
注意，每个stream只能使用一次，类比迭代器
(2).filter(…)：用于过滤元素。
参数接收一个Predicate函数式接口，方法为boolean test(T t)，代表对参数的处理,返回true则符合条件，false则不符合条件
filter内部会做一个循环，将每个元素作为"实参"调用一次test(T t)方法
Predicate的使用可以简化为lambda方式使用
Lambda的一个特点 ：
惰性求值——只有当我们执行"终结方法"时，之前的"拼接方法"才会被执行。
forEach()方法就是：终结方法，这种方法通常是最后执行。这种方法通常"没有返回值"。
filter()方法就是：拼接方法，这种方法通常在"终结方法"之前被调用。这种方法通常返回Stream流
注意：拼接方法后需要使用过滤后新返回的stream对象，再次使用。同一个stream只能使用一次
链式编程：对象在调用一个方法，返回对象后，再使用返回的对象调用方法，如此反复
(3).终结方法count()：统计流中元素的数量
(4).拼接方法limit(int c)：获取流中前c个元素
(5).拼接方法skip(int c)：跳过前c个元素，返回一个新流
(6).Stream流的map(…)：
用于将一种泛型的流(Stream)转换为另一种泛型(Stream)的流。该方法为拼接方法。 参数接收一个Function函数式接口，方法为R apply(T t)，代表对T型参数的处理,返回R型数据 map(…)内部会做一个循环，将每个元素作为"实参"调用一次R apply(T t)方法
(7).Stream 的静态方法
static concat(Stream s1,Stream s2)：将参数的两个流合并为一个流，返回。
collect(...)：将流中的数据，转换为List集合、Set集合、数组。
参数接收一个Collector的toXXX方法,最终返回XXX容器