1. 回顾
1. java实现线程的方式:
[1]继承Thread类。
[2]实现Runnable接口。
[3]实现Callable接口。
2. 线程中常见方法:
sleep();
Thread.currentThread().getName();
yield():
join():
setDaemon():
3. 线程安全问题: ---效率底层
[1]为线程枷锁。synchronized和Lock锁
[2]使用线程安全类。StringBuffer,Hashtable,ConcurrentHashMap
4. 什么是死锁和如何避免死锁:
5. 线程通信: wait和notify
6. 线程的状态:
New(新建状态)---调用start方法---就绪状态--->获取cpu--->执行状态--->调用sleep|join进入等待状态--->终止状态。
堵塞状态---->没有获取到锁
6. 线程池。
线程池的主要作用: 管理线程的创建和销毁，以及限制线程个数。
线程池的创建方式5种:
1.单一线程池.newSingleThreadPool()
2.固定线程池:newFixedThreadPool(n);
3.创建可变线程池:newCachedThreadPool();
4.创建延迟线程池:newScheduledThreadPool();
5.原生创建线程: ThreadPoolExecutor
7. 提交任务: submit(Runnable|Callable) execute(Runnable)
2. 正文-JDK8的新特性
1. lambda表达式
2. 函数式接口。
3. 方法引用。
4. Stream流
5. 日期时间类
3.lambda表达式
概念:
语法:
函数式的优点：
函数式接口不同于以往的普通接口，它最大的作用其实是为了支持行为参数传递，比如传递Lambda、方法引用、函数式接口对应的实例对象等。
注意: 函数式接口:接口中只有一个抽象方法。
(参数1，参数2): 抽象方法的参数
->: 分隔符
{}：表示抽象方法的实现
例子:
package demo01;
public class Test01 {
public static void main(String[] args) {
//该构造方法需要传递一个线程任务对象。Runnable类型
My task=new My();
Thread t1=new Thread(task);
t1.start();
//匿名内部类
Runnable task02=new Runnable() {
@Override
public void run() {
System.out.println("这时匿名内部类方式的任务对象");
}
};
Thread t2=new Thread(task02);
t2.start();
}
}
class My implements Runnable{
@Override
public void run() {
System.out.println("自定义任务接口类");
}
}
分析代码:
- Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心
- 为了指定 run 的方法体，不得不需要 Runnable 接口的实现类
- 为了省去定义一个 Runnable 实现类的麻烦，不得不使用匿名内部类
- 必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错
- 而实际上，似乎只有方法体才是关键所在。
这时可以使用lambda表示完成上面的要求。
//lambda表达式
Runnable task03 = ()-> {
System.out.println("这是使用Lambda表达式完成的");
};
Thread t3=new Thread(task03);
t3.start();
前提:必须是函数式接口。
简化匿名内部类的使用，语法更加简单。
3.1 无参无返回值
package demo02;
public class Test02 {
public static void main(String[] args) {
//匿名内部类
Swimmable swimmable=new Swimmable() {
@Override
public void swimming() {
System.out.println("这时使用匿名内部类的方式");
}
};
fun(swimmable);
//lambda表达式
// Swimmable swimmable1=()->{
// System.out.println("使用lambda表达式");
// };
fun(()->{System.out.println("使用lambda表达式");});
}
public static void fun(Swimmable w){
w.swimming();
}
}
//函数式接口
interface Swimmable{
public void swimming();
}
3.2 练习有参数有返回值的Lambda
下面举例演示 java.util.Comparator 接口的使用场景代码，其中的抽象方法定义为：
- public abstract int compare(T o1, T o2);
当需要对一个对象集合进行排序时， Collections.sort 方法需要一个 Comparator 接口实例来指定排序的规则。
package demo02;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Test03 {
public static void main(String[] args) {
List<Person> personList=new ArrayList<>();
personList.add(new Person("刘德华",50,175));
personList.add(new Person("张学友",55,178));
personList.add(new Person("杨紫琼",45,170));
personList.add(new Person("闫克起",18,185));
//对集合中的元素进行排序 按照年龄从大到小。
//传统做法:Comparator: 排序规则接口
// Comparator<Person> comparator = new Comparator<Person>() {
// //int: 0表示新加的元素和集合中原来的比对的相同
// //1: o2比o1小
// //-1: o2比o1大
// @Override
// public int compare(Person o1, Person o2) {
// return o2.getAge()-o1.getAge();
// }
// };
// Collections.sort(personList,comparator);
//
// for (Person p:personList){
// System.out.println(p);
// }
System.out.println("===============================lambda===========================");
Comparator<Person> comparator1 = (Person o1, Person o2)->{
return o1.getAge()-o2.getAge();
};
Collections.sort(personList,comparator1);
for (Person p : personList) {
System.out.println(p);
}
}
}
class Person {
private String name;
private int age;
private int height;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
public Person(String name, int age, int height) {
this.name = name;
this.age = age;
this.height = height;
}
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;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
}
3.3 详细介绍lambda表达式
![> [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DhDVFNGL-1658228203780)(assets/1658215300900.png)]](https://img-blog.csdnimg.cn/cdf8a1728c864220983c2075092eceee.png)
4. 函数式接口
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q6jOYy9P-1658228203780)(assets/1658217150413.png)]](https://img-blog.csdnimg.cn/f91aafd9ee904a77af1f8582639cc76b.png)
内置函数式接口的由来
public class Test03 {
public static void main(String[] args) {
Operater o=arr -> {
int sum=0;
for(int n:arr){
sum+=n;
}
System.out.println("数组的和为:"+sum);
};
fun(o);
}
public static void fun(Operater operater){
int[] arr={2,3,4,5,6,7,11};
operater.getSum(arr);
}
}
@FunctionalInterface
interface Operater{
//求数组的和
public abstract void getSum(int[] arr);
}
分析
我们知道使用Lambda表达式的前提是需要有函数式接口。而Lambda使用时不关心接口名，抽象方法名，只关心抽 象方法的参数列表和返回值类型。因此为了让我们使用Lambda方便，JDK提供了大量常用的函数式接口。
常见得函数式接口
java.util.function保存
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-suTBB9Tq-1658228203780)(assets/1658217745961.png)]](https://img-blog.csdnimg.cn/ce15300a955a4b42a0130d08ba85a18a.png)
4.1 Consumer
有参数，无返回值。
public class Test { public static void main(String[] args) { Consumer<Double> c= t->{ System.out.println("洗脚花费了:"+t); }; fun01(c,200); } //调用某个方法时，该方法需要的参数为接口类型，这时就应该能想到使用lambda public static void fun01(Consumer<Double> consumer,double money){ consumer.accept(money); } }
4.2 Supplier供给型函数式接口
T:表示返回结果的泛型
无参，想有返回结果的函数式接口时
T get();
public class Test02 {
public static void main(String[] args) {
//Supplier<Integer> supplier=()->new Random().nextInt(10);
fun(()->new Random().nextInt(10));
}
public static void fun(Supplier<Integer> supplier){
Integer result = supplier.get();
System.out.println("内容为："+result);
}
}
4.3 Function<T,R> 函数型函数式接口
T: 参数类型的泛型
R: 函数返回结果的泛型
有参，有返回 值时。
例子: 传入一个字符串把小写转换为大写。
public class Test03 {
public static void main(String[] args) {
fun((t)->{
return t.toUpperCase();
},"hello world");
}
//传入一个字符串，返回字符串的长度。
public static void fun(Function<String,String> function,String msg){
String s = function.apply(msg);
System.out.println("结果为:"+s);
}
}
4.4 Predicated
T: 参数的泛型
boolean test(T t);
当传入一个参数时，需要对该参数进行判断时，则需要这种函数。
public class Test04 {
public static void main(String[] args) {
fun(n->{
return n.length()>3?true:false;
},"栗毅");
}
public static void fun(Predicate<String> predicate,String name ){
boolean b = predicate.test(name);
System.out.println("该名称的长度是否长啊:"+b);
}
}
5. 方法引用。
5.1 lambda表达式的冗余
package demo05;
import java.util.function.Consumer;
public class Test01 {
public static void main(String[] args) {
Consumer<Integer[]> c=arr->{
int sum=0;
for(int b:arr){
sum+=b;
}
System.out.println("数组的和为:"+sum);
};
fun(c);
}
public static void fun(Consumer<Integer[]> consumer){
Integer[] arr={1,2,3,4,5};
consumer.accept(arr);
}
public static void sum(Integer[] arr){
int sum=0;
for (int a:arr){
sum+=a;
}
System.out.println("数组的和为:"+sum);
}
}
分析:
如果我们在Lambda中所指定的功能，已经有其他方法存在相同方案，那是否还有必要再写重复逻辑？可以直接“引 用”过去就好了：—方法引用。
package demo05;
import java.util.function.Consumer;
public class Test01 {
public static void main(String[] args) {
Consumer<Integer[]> c=Test01::sum;
fun(c);
}
public static void fun(Consumer<Integer[]> consumer){
Integer[] arr={1,2,3,4,5};
consumer.accept(arr);
}
public static void sum(Integer[] arr){
int sum=0;
for (int a:arr){
sum+=a;
}
System.out.println("数组的和为:"+sum);
}
}
请注意其中的双冒号 :: 写法，这被称为“方法引用”，是一种新的语法。
5.2 什么是方法引用
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fj1pTcS2-1658228203781)(assets/1658221726516.png)]](https://img-blog.csdnimg.cn/b0be452a6067414a9e46b364d8b2903a.png)
方法引用的分类
[1]：静态方法引用: 类名::静态方法 (参数)->类名.静态方法(参数)
[2]：实例方法引用: 对象::实例方法 (参数)->对象.实例方法(参数)
[3]：对象方法引用: 类名::实例方法. (参数1,参数2)->参数1.实例方法(参数2)
[4]：构造方法引用: 类名::new (参数)->new 类名(参数)
5.3 静态方法引用
静态方法引用，顾名思义就是调用已经存在的静态的方法，，静态方法引用类无需实例化，直接用类名去调用。
package com.lwh.demo03;
import java.util.function.Consumer;
public class StaticMethods {
public static void main(String[] args) {
show(StaticMethods::sum,10);
}
public static void show(Consumer<Integer> consumer,Integer i){
consumer.accept(i);
}
public static void sum(Integer integer){
System.out.println(integer + 20);
}
}
请注意其中的双冒号 :: 写法，这被称为“方法引用”，是一种新的语法。
5.4 实例方法引用
实例方法引用，顾名思义就是调用已经存在的实例的方法，与静态方法引用不同的是类要先实例化，静态方法引用类无需实例化，直接用类名去调用。
package com.lwh.demo03;
import java.util.Random;
import java.util.function.Supplier;
public class InstMethds {
public static void main(String[] args) {
InstMethds instMethds = new InstMethds();
show(instMethds::demo);
}
public static void show(Supplier<Integer> supplier){
System.out.println(supplier.get());
}
public Integer demo(){
System.out.println(new Random().nextInt(20));
return new Random().nextInt(10);
}
}
5.5 对象方法引用
简单来说就是可以通过类去调用实例方法
package com.lwh.demo03;
import java.util.function.Function;
public class ClassMethods {
public static void main(String[] args) {
show(People::getName);
}
public static void show(Function<People,String> function){
People lwh = new People("lwh");
System.out.println(function.apply(lwh));
}
}
class People{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public People(String name) {
this.name = name;
}
}
// **两个参数时**，比较两个字符串的内容是否一致.T, U, R
// R apply(T t, U u);
// BiFunction<String,String,Boolean> bi=(t,u)->{
// return t.equals(u);
// };
// BiFunction<String,String,Boolean> bi=String::equals;
// Boolean aBoolean = bi.apply("hello", "world");
// System.out.println(aBoolean);
结果：
5.6 构造方法引用
通过类调用对应的构造方法，来创建对象
package com.lwh.demo03;
import java.util.function.Function;
import java.util.function.Supplier;
public class ConstuctorMethods {
public static void main(String[] args) {
//有参构造，使用函数型函数式接口
Function<String,People1> function=People1::new;
People1 lwh = function.apply("lwh");
// 无参构造，使用供给型函数式接口
Supplier function2= People1::new;
System.out.println(function2.get());
System.out.println(lwh);
}
}
class People1{
private String name;
public People1(String name) {
this.name = name;
}
public People1() {
System.out.println("我被调用了");
}
@Override
public String toString() {
return "People1{" +
"name='" + name + '\'' +
'}';
}
}
399
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
