Java自学笔记总结04

一、Lambda表达式

1.1 函数式编程思想概述

Functional Programming

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”

面向对象思想强调“必须通过对象的形式来做事情”

函数式思想则尽量忽略面向对象的复杂语法： “强调做什么，而不是以什么形式去做”

而我们要学习的Lambda表达式就是函数式思想的体现

1.2 体验Lambda表达式

需求 : 启动一个线程，在控制台输出 “多线程程序启动了”
方式1:

• 定义一个类MyRunnable实现Runnable接口，重写run()方法
• 创建MyRunnable类的对象
• 创建Thread类的对象，把MyRunnable的对象作为构造参数传递
• 启动线程

方式2:

• 匿名内部类的方式改进

方式3:

• Lambda表达式的方式改进

实例

MyRunnable类

public class MyRunnable implements Runnable {

	@Override
	public void run() {
		System.out.println("多线程程序启动了");
	}
}

测试类

public static void main(String[] args) {
	// 实现类的方式实现需求
	MyRunnable my = new MyRunnable();
	Thread t = new Thread(my) ;
	t.start();
	
	// 匿名内部类的方式改进
	new Thread ( new Runnable() { 
		@Override
		public void run() {
			System.out.println("多线程程序启动了");
		}
	}).start( );
	// Lambda表达式的方式改进
	new Thread( () -> {
	System.out.println("多线程程序启动了");
	}).start();
}

1.3 Lambda表达式的标准格式

匿名内部类中重写run()方法的代码分析

• 方法形式参数为空，说明调用方法时不需要传递参数

• 方法返回值类型为void，说明方法执行没有结果返回

• 方法体中的内容，是我们具体要做的事情

new Thread(new Runnable( {Override public void run) {
	System.outprintln("多线程程序启动了"");}
}).start();

Lambda表达式的代码分析

• ()︰里面没有内容，可以看成是方法形式参数为空·
• ->︰用箭头指向后面要做的事情
• {} : 包含一段代码，我们称之为代码块，可以看成是方法体中的方法

new Thread(() -> {
	System.out.println("多线程程序启动了");
}).start();

组成Lambda表达式的三要素: 形式参数，箭头，代码块

Lambda表达式的格式

• 格式: (形式参数)->{代码块}
• 形式参数: 如果有多个参数，参数之间用逗号隔开;如果没有参数，留空即可
• -> : 由英文中画线和大于符号组成，固定写法。代表指向动作
• 代码块: 是我们具体要做的事情，也就是以前我们写的方法体内容

实例

Eatable接口

public interface Eatable {
	void eat();
}

EatavleImpl 类

public class EatableImpl implements Eatable {

	@Override
	public void eat() {
		System.out.println("一天一苹果，医生远离我");
	}

}

测试类

public static void main( String[]args) {
	// 在主方法中调用useEatable方法
	Eatable e = new EatableImpl();
	useEatable(e);
	
	// 匿名内部类
	useEatable( new Eatable() {
		@Override
		public void eat() {
			System.out.println("—天一苹果，医生远离我");
		}
	});
	
	// Lambda表达式
	useEatable(() -> {
		System.out.println("—天一苹果,医生远离我");
	});
}

private static void useEatable(Eatable e) {
	e.eat( );
}

1.4 Lambda表达式的使用

案例

定义一个接口(Flyable)，里面定义一个抽象方法: void fly(String s);

定义一个测试类(FlyableDemo)，在测试类中提供两个方法

​ 一个方法是: useFlyable(Flyablef)

​ 一个方法是主方法，在主方法中调用useFlyable方法

实例

Fly接口

public interface Flyable {
	void fly(String s);
}

测试类

public static void main(String[] args) {
	// 在主方法中调用useFLyable方法
	
	// 匿名内部类
	useFlyable(new Flyable() {
		@Override
		public void fly(String s) {
			System.out.println(s);
			System.out.println("飞机自驾游");
		}
	});
	
	System.out.println("--------");
	
	// Lambda
	useFlyable((String s) -> {
	System.out.println(s);
	System.out.println("飞机自驾游");});
}

private static void useFlyable( Flyable f) {
	f.fly("风和日图,晴空万里");
}

案例

• 定义一个接口(Addable)，里面定义一个抽象方法: intadd(intx,int y);

• 定义一个测试类(AddableDemo)，在测试类中提供两个方法

​ 一个方法是: useAddable(Addable a)
​ 一个方法是主方法，在主方法中调用useAddable方法

实例

Addable接口

public interface Addable {
	void add(int x, int y);
}

测试类

public static void main( String[]args) {
	// 在主方法中调用useAddabLe方法
	useAddable((int x,int y) -> {
		return x + y;
//		return x - y ;
	});
}

private static void useAddable( Addable a) {
	int sum = a.add(10, 20);
	System.out.println(sum);
}

1.5 Lambda表达式的省略模式

省略规则:

• 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
• 如果参数有且仅有一个，那么小括号可以省略
• 如果代码块的语句只有一条，可以省略大括号和分号，甚至是return

实例

public static void main( String[]args) {
	// Lambda表达式
	useAddable( (int x ,int y) ->{ 
	return x + y ;
	});
	
	// 参数的类型可以省略
	useAddable((x,y) -> {
		return x + y;
	});
	
	// 但是有多个参数的情况下，不能只省略一个
//	useAddable( (x ,int y) -> {
//		return x + y ;
//	});
	useFlyable( (String s) -> {
		System.out.println(s);
	});
	
	useFlyable((s) -> {
	System.out.println(s);
    });

	//如果参数有且仅有一个，那么小括号可以省略
	useFlyable(s -> {
		System.out.println(s);
	});
}

private static void useFlyable(Flyable f) {
	f.fly("风和日图,晴空万里");
}
private static void useAddable(Addable a) {
	int sum = a.add(10, 20);
	System.out.println( sum);
}

1.6 Lambda表达式的注意事项

注意事项:

• 使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法

• 必须有上下文环境，才能推导出Lambda对应的接口

​ 根据局部变量的赋值得知Lambda对应的接口 : Runnabler= () -> System.out.printIn("Lambda表达式");

​ 根据调用方法的参数得知Lambda对应的接口 : new Thread(J)-> System.out.printIn("Lambda表达式").start();

实例

接口

public interface Inter {
	void show();
	// 两个抽象方法导致测试类中报错
    //	void method();
}

测试类

public static void main( String[] args ) {
	useInter(() -> {
		System.out.println("好好学习天天向上");
	});
	
	//使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
	useInter(() -> System.out.println("好好学习天天向上"));
	
	//必须有上下文环境，才能推导出Lambda对应的接口
	new Thread (new Runnable() {
		@Override
		public void run( ) {
			System.out.println("匿名内部类");
		}
	}).start();
	
	Runnable r = () -> System.out .println( "Lambda表达式");
	new Thread(r) .start( );
	
	new Thread(() -> System.out.println("Lambda表达式")).start();
}

private static void useInter(Inter i) {
	i.show( );
}

1.7 Lambda表达式和匿名内部类的区别

所需类型不同

• 匿名内部类:可以是接口，也可以是抽象类，还可以是具体类

• Lambda表达式:只能是接口

使用限制不同

• 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类

• 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

实现原理不同

• 匿名内部类:编译之后，产生—个单独的.class字节码文件
• Lambda表达式 : 编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

二、.接口组成更新

2.1 接口组成更新概述

接口的组成

• 常量

​ public static final

• 抽象方法

​ public abstract

• 默认方法(Java 8)

• 静态方法(Java 8)

• 私有方法(Java 9)

2.2 接口中默认方法

想在接口中添加方法，但是又会影响到实现类的使用可用使用默认方法

也可以通过继承创建了抽象方法的接口

接口中默认方法的定义格式:

• 格式

 public default 返回值类型 方法名(参数列表){
 
 }

• 范例

public default void show3() {
    
}

接口中默认方法的注意事项:

• 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字

• public可以省略,default不能省略

实例

接口

public interface MyInterface {
	void show1( );
	void show2( );
//	void show3( );
	
//	public default void show3() {
//		System.out.println("show3");
//	}
	
	default void show3( ) {
		System.out.println( "show3" );
	}
}

接口实现类

public class MyInterfaceOne implements MyInterface {

	@Override
	public void show1() {
		System.out.println("一天一苹果，医生远离我");
	}

	@Override
	public void show2() {
		System.out.println("好好学习，天天向上");
	}
}

测试类

public static void main(String[] args) {
	// 按照多态的方式创建对象并使用
	MyInterface my = new MyInterfaceOne( );
	my.show1();
	my.show2();
	my.show3();
}

通过继承添加抽象方法的接口

public interface MyInterfaceSon extends MyInterface {
	void show3();
}

2.3 接口中静态方法

接口中静态方法的定义格式:

• 格式

public static 返回值 类型方法名(参数列表){

}

• 范例

public static void show(){

}

接口中静态方法的注意事项:

• 静态方法只能通过接口名调用，不能通过实现类名或者对象名

• 调用public可以省略,static不能省略

实例

Flyable接口

public interface Flyable {
	public static void test() {
		System.out. println("F1yable中的静态方法执行了");
		}
}

Inter接口

public interface Inter {
	void show();

	default void method(){
		System.out.println( "Inter中的默认方法执行了");
	}
	
//	public static void test() {
//		System.out.println( "Inter中的静态方法执行了");
//	}
	
	static void test(){
		System.out.println("Inter 中的静态方法执行了");
	}
}

实现类

public class InterImpl implements Inter, Flyable {

	@Override
	public void show() {
		System.out.println("show 方法执行了");
	}
}

测试类

public static void main(String[]args) {
	// 按照多态的方式创建对象并使用
	Inter i = new InterImpl();
	i.show( );
	i.method( ) ;
//	i.test( );
	Inter.test();
//	InterImpl.test( );
	Flyable.test();
}

2.4 接口中私有方法

Java 9中新增了带方法体的私有方法，这其实在Java8中就埋下了伏笔: Java8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题:当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java9增加私有方法的必然性

接口中私有方法的定义格式:

• 格式1

private 返回值 类型 方法名(参数列表){

}

• 范例1

private void show(){
    
}

• 格式2

private static 返回值 类型 方法名(参数列表){}

• 范例2

private static void method(){

}

接口中私有方法的注意事项:

• 默认方法可以调用私有的静态方法和非静态方法

• 静态方法只能调用私有的静态方法

实例

接口

public interface Inter {
	
	default void show1() {
		System.out.println( "show1开始执行");
//		System.out.println("初级工程师");
//		System.out.println("中级工程师");
//		System.out.println("高级工程师");
		show();
//		method();
		System.out.println( "show1结束执行");
	}
	
	default void show2() {
		System.out.println( "show2开始执行");
//		System.out.println("初级工程师");
//		System.out.println("中级工程师");
//		System.out.println("高级工程师");
//		show();
		method();
		System.out.println( "show2结束执行");
	}
	
	
	private void show() {
		System.out.println("初级工程师");
		System.out.println("中级工程师");
		System.out.println("高级工程师");
	}
	
	static void method1() {
		System.out.println( "method1开始执行");
//		System.out.println("初级工程师");
//		System.out.println("中级工程师");
//		System.out.println("高级工程师");
//		show();
		method();
		System.out.println( "method1结束执行");
	}
	
	static void method2() {
		System.out.println( "method2开始执行");
//		System.out.println("初级工程师");
//		System.out.println("中级工程师");
//		System.out.println("高级工程师");
//		show();
		method();
		System.out.println( "method2结束执行");
	}
	
	private static void method() {
		System.out.println("初级工程师");
		System.out.println("中级工程师");
		System.out.println("高级工程师");
	}
}

实现类

public class InterImpl implements Inter {

}

测试类

public static void main(String[]args) {
	//按照多态的方式创建对象并使用
	Inter i = new InterImpl01();
	i.show1();
	System.out. println("--------");
	i.show2( );
	System.out.println( "--------");
	
	Inter.method1();
	System.out.println( "--------" );
	Inter.method2();
}

三、体验方法

3.1 体验方法引用

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案: 拿参数做操作

那么考虑一种情况:如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢?

答案肯定是没有必要

那我们又是如何使用已经存在的方案的呢?

这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案

实例

接口

public interface Printable {
	void printString(String s);
}

测试类

public static void main(String[]args) {
	// 在主方法中调用usePrintable方法
	usePrintable( (String s) -> {
		System.out.println(s);
	});
	
	usePrintable(s -> System.out.println(s));
	
//	System.out.println("爱生活爱Java" ) ;
	
	// 方法引用符 ::
	usePrintable( System.out::println);
	
	//可推导的就是可省略的
	}

private static void usePrintable(Printable p) {
		p.printString("爱生活爱Java");
}

3.2 方法引用符

方法引用符

• ::该符号为引用运算符，而它所在的表达式被称为方法引用

回顾一下我们在体验方法引用中的代码

• Lambda表达式 : usePrintable(s-> System.out.printIn(s));

​ 分析 : 拿到参数s 之后通过Lambda表达式，传递给System.out.println方法去处理

• 方法引用 : usePrintable(System.out:println);

​ 分析 : 直接使用System.out中的println方法来取代Lambda，代码更加的简洁

推导与省略

• 如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导

• 如果使用方法引用，也是同样可以根据上下文进行推导

• 方法引用是Lambda的孪生兄弟

实例

接口

public interface Printable01 {
	void printInt(int i);
}

测试类

public static void main(String[]args) {
	//在主方法中调用usePrintable方法
	usePrintable(i -> System.out.println(i));
	//方法引用
	usePrintable(System.out::println);
}

private static void usePrintable(Printable01 p){
	p.printInt(666);
}

3.3 Lambda表达式支持的方法引用

常见的引用方式:

• 引用类方法

• 引用对象的实例方法·

• 引用类的实例方法

• 引用构造器

3.4 引用类方法

引用类方法，其实就是引用类的静态方法

• 格式 : 类名::静态方法

• 范例 : Integer:parselnt

​ Integer类的方法: public static int parselnt(String s)将此String转换为int类型数据
练习:

定义一个接口(Converter)，里面定义一个抽象方法

​ int convert(String s);

• 定义一个测试类(ConverterDemo)，在测试类中提供两个方法

​ 一个方法是: useConverter(Converter c)

​ 一个方法是主方法，在主方法中调用useConverter方法

实例

Converter接口

public interface Converter {
	int convert(String s);
}

测试类

public static void main(String[]args) {
		// 在主方法中调用useConverter方法
		useConverter( ( String s) -> {
			return Integer.parseInt(s);
		});
	
		useConverter(s -> Integer.parseInt(s));
		// 引用类方法
		useConverter(Integer::parseInt) ;
		// Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
	}
	private static void useConverter(Converter c) {
		int number = c.convert("666");
		System.out.println( number);
	}

3.5 引用对象的实例方法

引用对象的实例方法，其实就引用类中的成员方法

格式 : 对象:成员方法

范例 : "HelloWorld":toUpperCase

​ String类中的方法: public String toUpperCase()将此String所有字符转换为大写
练习

• 定义一个类(PrintString)，里面定义一个方法

​ public void printUpper(String s) : 把字符串参数变成大写的数据，然后在控制台输出

• 定义一个接口(Printer)，里面定义一个抽象方法

​ void printUpperCase(Strings)

• 定义一个测试类(PrinterDemo)，在测试类中提供两个方法

​ 一个方法是 : usePrinter(Printer p)

​ 一个方法是主方法，在主方法中调用usePrinter方法

实例

接口

public interface Printer {
	void printUpperCase(String s);
}

类

public class PrintString {
	//把字符串参数变成大写的数据，然后在控制台输出
	public void printUpper(String s) {
		String result = s.toUpperCase();
		System.out.println(result);
	}

}

测试类

public static void main( String[]args ) {
	// 在主方法中调用usePrinter方法
	usePrinter( ( String s) -> {
		String result = s.toUpperCase();
		System.out.println(result);
		System.out.println(s.toUpperCase());
	});
	
	usePrinter(s -> System.out.println(s.toUpperCase()));
	
	// 引用对象的实例方法
	PrintString ps = new PrintString();
	usePrinter(ps::printUpper);
	
	// Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数
}

private static void usePrinter(Printer p) {
	p.printUpperCase("He1lowor1d");
}

3.6 引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

• 格式 : 类名::成员方法

• 范例 : String::substring

​ String类中的方法: public String substring(int beginIndex,int endIndex)

​ 从beginIndex开始到endIndex结束，截取字符串。返回一个子串，子串的长度为endIndex-beginIndex
练习

• 定义一个接口(MyString)，里面定义一个抽象方法:

​ String mySubString(Strings,int x,int y);

• 定义一个测试类(MyStringDemo)，在测试类中提供两个方法

​ 一个方法是: useMyString(MyString my)

​ 一个方法是主方法，在主方法中调用useMyString方法

实例

接口

public interface MyString {
	String mySubString(String s, int x, int y);
}

测试类

public static void main( String[] args ) {
	//在主方法中调用useMyString方法
	useMyString((String s ,int x,int y) ->{
		return s.substring(x,y);
	});
	useMyString( (s,x,y) -> s.substring(x,y));
	//引用类的实例方法
	useMyString(String::substring);
	// Lambda表达式被类的实例方法替代的时候
	// 第一个参数作为调用者
	// 后面的参数全部传递给该方法作为参数
}

private static void useMyString(MyString my ) {
	String s = my.mySubString("HelloWorld", 1, 3);
	System.out.println(s);
}

3.7 引用构造器

引用构造器，其实就是引用构造方法

格式 : 类名::new

范例 : Student::new

练习

• 定义一个类(Student)，里面有两个成员变量(name,age)

​ 并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法

• 定义一个接口(StudentBuilder)，里面定义一个抽象方法

​ Student build(String name, int age);

• 定义一个测试类(StudentDemo)，在测试类中提供两个方法

​ 一个方法是: useStudentBuilder(StudentBuilder s)

​ 一个方法是主方法，在主方法中调用useStudentBuilder方法

实例

StudentBuilder接口

public interface StudentBuilder {
	Student build(String name, int age);
}

Student类

public class Student {
	private String name;
	private int age;
	
	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;
	}
	
}

测试类

public static void main(String[] args) {
	// 在主方法中调用useStudentBuilder方法
	useStudentBuilder((String name , int age) ->{
//		Student s = new Student(name , age);
//		return s;
		return new Student(name , age);
	});
	
//	useStudentBuilder((name,age) -> new Student(name, age));
	
	// 引用构造器
//	useStudentBuilder(Student::new);
	// Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数
}

private static void useStudentBuilder(StudentBuilder sb){
	Student s = sb.build("林青霞", 30) ;
	System.out.println(s.getName() + "," + s.getAge());
}

四、函数式接口

4.1 函数式接口概述

函数式接口 : 有且仅有一个抽象方法的接口

Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口

只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导

如何检测一个接口是不是函数式接口呢?

• @Functionallnterface

• 放在接口定义的上方:如果接口是函数式接口，编译通过;如果不是，编译失败

注意

• 我们自己定义函数式接口的时候，@Functionallnterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

4.2 函数式接口作为方法的参数

需求

• 定义一个类(RunnableDemo)，在类中提供两个方法

​ 一个方法是: startThread(Runnable r) 方法参数Runnable是一个函数式接口

​ 一个方法是主方法，在主方法中调用startThread方法

如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递

• startThread(()-> System.out.println(Thread.currentThread().getName()+"线程启动了"));

实例

public static void main( String[] args ) {
	// 在主方法中调用startThread方法
	// 匿名内部类的方式
	startThread( new Runnable() {
		@Override
		public void run() {
			System.out.println(Thread.currentThread( ).getName() +"线程启动了");
		}
	});
	
	startThread(() -> System.out .println(Thread.currentThread().getName()+"线程启动了"));
}

private static void startThread(Runnable r) {
//	Thread t = new Thread(r);
//	t.start( );
	new Thread(r).start();
}

4.3 函数式接口作为方法的返回值

需求

• 定义一个类(ComparatorDemo)，在类中提供两个方法

​ 一个方法是: Comparator<String> getComparator() 方法返回值Comparator是一个函数式接口

​ 一个方法是主方法，在主方法中调用getComparator方法

如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回

private static Comparator<String> getComparator() {
	return (s1, s2) -> s1.length() - s2.length();
}

实例

public static void main(String[] args){
	// 构造使用场景
	// 定义集合，存储字符串元素
	ArrayList<String> array = new ArrayList<String>();
	array . add("cccc");
	array .add( "aa" );
	array . add( "b");
	array .add( "ddd" );
	System.out.println("排序前:" + array ) ;
	Collections.sort(array ) ;
	Collections.sort(array, getComparator( ) );
	System.out.println("排序后:" + array);
}

private static Comparator<String> getComparator() {
	// 匿名内部类的方式实现
//	Comparator<String> comp = new Comparator<String>() {
//		@Override
//		public int compare( String s1, String s2){
//			return s1.length() - s2.length( );
//		}
//	};
//		
//	return comp;
	
//	return new Comparator<String>( ) {
//		@Override
//		public int compare( String s1, String s2) {
//			return s1.length() - s2.length();
//		}
//	};
	
//	return (String s1, String s2) -> {
//		return s1.length( )-s2.length();
//	};
	
	return (s1, s2) -> s1.length() - s2.length();
}

4.5 Supplier接口

Supplier<T> : 包含一个无参的方法

• T get() : 获得结果

• 该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据

Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用

实例

public static void main( String[]args) {
//	String s = getString(() -> {
//	return "林青霞";
//	});
	
	String s = getstring(() -> "林青霞");
	System.out.println(s);
	Integer i = getInteger(() ->30);System.out.println(i);
}

//定义一个方法，返回一个整数数据
private static Integer getInteger(Supplier<Integer> sup) {
	return sup.get( );
}
	
	//定义一个方法，返回一个字符串数据
private static String getstring(Supplier<String> sup) {
	return sup.get( );
}

练习

定义一个类(SupplierTest)，在类中提供两个方法

一个方法是: int getMax(Supplier<Integer> sup)用于返回一个int数组中的最大值

一个方法是主方法，在主方法中调用getMax方法

实例

public static void main( String[ ] args) {
	//定义一个int数组
	int[] arr = {19, 50, 28, 37, 46};
	
	int maxValue = getMax(()->{
		int max = arr[0];
		for(int i=1; i<arr.length; i++) {
			if(arr[i] > max) {
				max = arr[i];
			}
		}
	return max;
	});

	System.out.println(maxValue);
}
// 返回一个int数组中的最大值
private static int getMax( Supplier<Integer> sup) {
	return sup.get();
}

4.6 Consumer接口

Consumer<T> : 包含两个方法

• void accept(T t) : 对给定的参数执行此操作

• defaultConsumer<T> andThen(Consumer after) : 返回一个组合的Consumer，依次执行此操作，然后执行after操作

• Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

实例

public static void main(String[] args) {
	operatorString("林青霞", (String s) -> {
	System.out.println(s);
	});
	
	operatorString("林青霞", s -> System.out.println(s));
	
	operatorString("林青霞", System.out::println);
	
//	operatorString("林青霞", s -> {
//	System.out.println(new StringBuilder(s).reverse() .toString());
//	});
	
	operatorString("林青霞", s -> System.out.println(new StringBuilder(s).reverse().toString()));
			System.out.println( "--------");
	operatorString("林青霞", s -> System.out.println(s), s -> System.out.println(new StringBuilder(s).reverse().toString()));
					
}
	
//定义一个方法，用不同的方式消费同一个字符串数据两次
private static void operatorString(String name, Consumer<String> con1,Consumer<String> con2){
//	con1 .accept(name) ;
//	con2.accept(name) ;
	con1.andThen(con2).accept(name);
}
	
//定义一个方法，消费—个字符串数据
private static void operatorString(String name, Consumer<String> con){
	con. accept( name) ;
}

练习

• String[] strArray ={"林青霞,30"，"张曼玉,35","王祖贤,33");

• 字符串数组中有多条信息，请按照格式: 姓名:XX年龄:XX 的格式将信息打印出来

• 要求:

​ 把打印姓名的动作作为第一个Consumer接口的Lambda实例把

​ 打印年龄的动作作为第二个Consumer接口的Lambda实例将两个

​ Consumer接口按照顺序组合到一起使用

实例

public static void main(String[]args) {
	String[] strArray = {"林青霞,30", "张曼玉,35","王祖贤,33"};
	printInfo(strArray, (String str) -> {
		String name = str.split(",")[0];
		System.out.print("姓名:" + name );
	}, (String str) -> {
		int age = Integer.parseInt(str.split(",")[1]);
		System.out.println(",年龄:" + age ) ;
	});
	
	printInfo(strArray, str -> System.out.print("姓名: " + str.split(",")[0]),
			str -> System.out.println(",年龄: " + Integer.parseInt(str.split(",")[1])));
}

private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2){
	for (String str : strArray ) {
		con1.andThen( con2).accept(str);
	}
}

4.7 Predicate接口

Predicate<T> : 常用的四个方法

• boolean test(T t) : 对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值

• default Predicate<T> negate() : 返回一个逻辑的否定，对应逻辑非

• defaultPredicate<T> and(Predicate other) : 返回一个组合判断，对应短路与

• default Predicate<T> or(Predicate other) : 返回一个组合判断，对应短路或

• Predicate<T>接口通常用于判断参数是否满足指定的条件

实例

public static void main(String[]args) {
	boolean b1 = checkString("he1lo", s -> s.length() > 8);
	System.out.println(b1);
	boolean b2 = checkString("he1lloworld", s -> s.length() > 8);
	System.out.println(b2);
	
	boolean b3 = checkString("he1llo", s -> s.length() > 8, s -> s.length() < 15);
	System.out.println(b3);
	boolean b4 = checkString("he1lloworld", s -> s.length() > 8, s -> s.length() < 15);
	System.out.println(b4);
	
}

//判断给定的字符串是否满足要求
private static boolean checkString(String s, Predicate<String> pre) {
//	return pre.test(s);
	// 取反
//	return !pre.test(s);
	return pre.negate().test(s);
}


private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
//	boolean b1 = pre1.test(s);
//	boolean b2 = pre2.test(s);
	//与
//	boolean b = b1 && b2;
//	return b;
	
	return pre1.and(pre2).test(s);
	
}

练习

• String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};

• 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合Arraylist中，并遍历ArrayList集合

• 同时满足如下要求:姓名长度大于2;年龄大于33

• 分析

​ 有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断

​ 必须同时满足两个条件,所以可以使用and方法连接两个判断条件

实例

public static void main(String[] args) {
	String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
	
	ArrayList<String> result = myFilter(strArray, s -> s.split(",")[0].length() > 2,
			s -> Integer.parseInt(s.split(",")[1]) > 33);
	
	for(String str : result) {
		System.out.println(str);
	}
}

private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String>pre2){
	ArrayList<String> result = new ArrayList<String>();
	for(String str : strArray) {
		if(pre1.and(pre2).test(str)) {
			result.add(str);
		}
	}
	
	return result;
}

4.8 Function接口

Function<T,R>︰ 常用的两个方法

• R apply(T t) : 将此函数应用于给定的参数

• default <V> Function andThen(Function after) : 返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

• Function<T,R> 接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值

实例

public static void main(String[] args) {
//	convert("100" , ( String s)->{
//		return Integer.parseInt(s );
//	});
	
//	convert("100", s -> Integer.parseInt(s));
	convert( "100" , Integer::parseInt);
	
	convert(100, i -> String.valueOf(i + 566));
	convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
}

// 定义一个方法，把一个字符串转换int类型，在控制台输出
private static void convert(String s, Function<String,Integer> fun) {
//	Integer i = fun. apply(s);
	int i = fun.apply(s);
	System.out.println(i);
}

//定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
private static void convert(int i, Function<Integer ,String> fun){
	String s = fun.apply(i);
	System.out.println(s );
}

//定义一个方法，把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
private static void convert(String s, Function<String,Integer>fun1, Function<Integer ,String> fun2)	{
//	Integer i = fun1.apply(s );
//	String ss = fun2 .apply(i);
//	System.out.println( ss);
	String ss = fun1.andThen(fun2).apply(s);
	System.out.println(ss);
}

练习

Strings = "林青霞,30";

请按照我指定的要求进行操作:

• 将字符串截取得到数字年龄部分
• 将上一步的年龄字符串转换成为int类型的数据
• 将上一步的int数据加70，得到一个int结果，在控制台输出
• 请通过Function接口来实现函数拼接

实例

public static void main(String[] args) {
	String s = "林青霞,30";
	convert(s, (String ss) -> {
		return s.split(",")[1];
	}, (String ss) ->{
		return Integer.parseInt(ss);
	}, (Integer i) -> {
		return i + 70;
	});
	
	convert(s, ss -> ss.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 70);
	convert(s, ss -> ss.split(",")[1], Integer::parseInt, i -> i + 70);
}

private static void convert(String s, Function<String, String>fun1, Function<String,Integer>fun2, Function<Integer, Integer>fun3) {
//	Integer i = fun1.andThen(fun2).andThen(fun3).apply(s);
	int i = fun1.andThen(fun2).andThen(fun3).apply(s);
	System.out.println(i);
}