Java基础30（Java 8 特性 Java8中Interface接口 Lambda 表达式 Stream流）

冯诺依曼转世

已于 2024-06-07 09:31:31 修改

阅读量979

点赞数 23

CC 4.0 BY-SA版权

分类专栏： javase 文章标签： java 开发语言数据结构 eclipse 算法

于 2024-06-07 01:26:48 首次发布

本文链接：https://blog.csdn.net/qq_52897007/article/details/139498928

一、 Java8中Interface接口

二、Lambda 表达式

1. lambda的精简写法

2. 函数式接口 Functional Interface

3. 内置函数式接口(Built-in Functional Interfaces)

3.1 Supplier 供给型接口

3.2 Consumer 消费型接口

3.3 Function 函数型接口,r>

3.4 Predicate 断言型接口 ,r>

3. limit(long )--获取流中的前n个元素

Collectors.mapping()将Stream中的元素，映射后，收集至新集合

Collectors.groupingBy() 分组

10. Parallel Streams 并行流

函数式接口总结

一、Java8中Interface接口

interface接口的设计目的是面向接口编程，提高扩展性。
●Java8中，接口中除了抽象方法外，还可以定义default默认方法和static静态方法。
○default修饰的默认方法，属于实例方法，可以被实现类调用或重写。

调用：实现类必须implements接口，才能调用该接口的default默认方法。

重写：实现类implements不同接口时，接口中存在相同签名的方法（名称、参数、类型完全一致），则实现类必须重写该方法，明确方法定义；

○static修饰的静态方法，属于类的静态方法。但它不能被子类继承，只能用interface接口名称调用。

二、Lambda 表达式

Lambda 表达式本质是一个匿名函数，用于把函数作为参数，传入方法中，实现函数式编程风格。
使用Lambda 表达式可以使代码变的更加简洁紧凑。

语法格式

(parameters)-> expression 或 (parameters)->{ statements;}

接口名 对象名=(参数类型 参数名称)->{方法体}
(参数类型，参数名称): 抽象方法的参数，形参
->固定写法
{}存放方法的内容

public static void main(String[] args) {
		new Thread(new Runnable() {
			// 1.定义了一个没有名字的内部类
			// 2.实现了Runnable接口
			// 3.创建Runnable实现类对象
			@Override
			public void run() {
				System.out.println("子线程1执行任务");
			}
		}).start();

		new Thread(() -> System.out.println("子线程2执行任务")).start();

		System.out.println("主线程执行任务");
	}

运行结果：
子线程1执行任务
主线程执行任务
子线程2执行任务

创建函数式接口类型的对象
函数式接口:接口中只有一个抽象方法(static default,抽象方法只能有1个)

//创建函数式接口类型的对象
//函数式接口:接口中只有一个抽象方法(static default,抽象方法只能有1个)

//接口名 对象名=(参数类型 参数名称)->{方法体}
//(参数类型，参数名称): 抽象方法的参数，形参
//->固定写法
//{}存放方法的内容

//lambda的精简写法
//a.参数的类型省略
//b.()可以省略,参数个数只有1个的时候可以省略
//c.{ return ;}可以省略,只有一条语句的时候才能省略
public class Demo02 {
	public static void main(String[] args) {
		goSWimining(new Swimable() {

			@Override
			public void swimming() {
				System.out.println("zkt在游泳");
			}
		});

		//接口名对象名=(参数类型参数名称)->{方法体}
		goSWimining(() -> {
			System.out.println("zkt1在游泳");
		});
		goSWimining(() -> System.out.println("zkt2在游泳"));
	}

	public static void goSWimining(Swimable s) {
		s.swimming();
	}
}

interface Swimable {
	void swimming();
}

1. lambda的精简写法

参数的类型省略
()可以省略,参数个数只有1个的时候可以省略
{ return ;}可以省略,只有一条语句的时候才能省略

public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>(Arrays.asList(3,2,1,5,6,7));
		
		//写法1：匿名内部类写Compartor实现类对象
//		Collections.sort(list,new Comparator<Integer>() {
//
//			@Override
//			public int compare(Integer o1, Integer o2) {
//				// TODO Auto-generated method stub
//				return o2-o1;
//			}
//		});
		//写法2:1ambda表达式写法
		Collections.sort(list,(Integer o1,Integer o2)->{return o2-o1;});
		
		//写法3:省略参数类型
		Collections.sort(list,( o1, o2)->{return o2-o1;});
		
		//写法4:省略{return ;}
		Collections.sort(list,( o1, o2)->o2-o1);
		
		System.out.println(list);
	}

public class Demo04 {
	public static void main(String[] args) {
		List<Person> persons = new ArrayList<Person>();
		persons.add(new Person("zkt1", 21,177));
		persons.add(new Person("zkt2", 17,180));
		persons.add(new Person("zkt3", 24,187));
		
		Collections.sort(persons,(p1,p2)->{return p1.getAge()-p2.getAge();});
		
		persons.forEach((t)->{System.out.println(t);});
	}
}

class Person {
	private String name;
	private int age;
	private int height;

	public Person(String name, int age, int height) {
		super();
		this.name = name;
		this.age = age;
		this.height = height;
	}

	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", 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;
	}

}

2. 函数式接口 Functional Interface

只有一个抽象方法的接口（可以定义多个非抽象方法）。可以使用@FunctionalInterface接口定义，强化语义规范。
函数式接口，也被称为SAM 接口（Single Abstract Method Interfaces）

作用
基于函数式接口，可以使用Lambda表达式进行实现，实现函数式编程。

//lambda表达式使用的前提:
//1.方法的参数或者变量的类型是接口
//2.这个接口中只能有一个抽象方法
public class Demo05 {
	public static void main(String[] args) {
		test(new Flyable() {

			@Override
			public void fly() {
				System.out.println("我能飞");
			}
		});

		test(() -> {
			System.out.println("我能飞");
		});
	}

	public static void test(Flyable fly) {
		fly.fly();
	}
}
@FunctionalInterface //函数式接口注解，表示此接口只有一个
interface Flyable {
	public abstract void fly();

}

public class Demo01 {
	public static void main(String[] args) {
		//调用函数式接口中的方法
		method((arr) -> {
			int sum = 0;
			for (int i : arr) {
				sum = sum + i;
			}
			return sum;
		});
	}
    //使用自定义的函数