【java初学】函数式接口和Stream

最新推荐文章于 2024-03-03 23:00:42 发布
最新推荐文章于 2024-03-03 23:00:42 发布
阅读量228 收藏
点赞数
分类专栏： java初学 文章标签： 后端 java初学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43410878/article/details/123819207
版权

文章目录

函数式接口和Stream

1. 函数式接口
1.1 函数式接口概述
利用接口操作语法格式，对于方法的声明作出二次封装！！！
	方法声明:
		权限修饰符 是否静态 返回值类型 方法名(形式参数列表);
	对于接口而言
		返回值类型 方法名(形式参数列表);
	在使用lambda表达式的过程中
		方法名有个锤子用啊???
		·关注内容就是返回值，一个形式参数列表
1.2 常用函数式接口
1. 消费式接口
	方法是消耗一个参数，但是没有返回值
	interface Consumer<T> {
		void accept(T t);
	}

2. 生产者接口
	方法不需要参数，但是存在返回值数据
	Interface Supplier<T> {
		T get();
	}

3. 转换数据类型接口
	指定参数类型，指定返回值类型，将参数转换成对应指定数据类型
	Interface Function<T,R>  {
		R apply(T t);
	}

4. 判断接口
	判断接口，指定数据类型通过当前test方法判断，满足要求返回true，不满足返回false 类似于filter
	Interface Predicate<T> {
		boolean test(T t);
	}

5. 比较器接口
	比较器接口
	interface Comparator<T> {
		int compare(T o1, T o2);
	}
	
	以上所有接口都有对应的@FuntionalInterface 注解约束，当前接口中有且只允许存在一个未完成方法(abstract方法).
1.3 比较器函数式接口
回顾一个知识点:
	你还记得Arrays? sort方法?
	Arrays.sort(T[] t, Comparator<T> com);

package com.qfedu.a_funtion;

import java.util.Arrays;
import java.util.Comparator;

public class Demo1 {
	public static void main(String[] args) {
		SinglePerson sp1 = new SinglePerson("老王", 66, '男');
		SinglePerson sp2 = new SinglePerson("大哥", 18, '女');
		SinglePerson sp3 = new SinglePerson("鹏鹏", 16, '男');
		SinglePerson sp4 = new SinglePerson("张三", 66, '男');
		SinglePerson sp5 = new SinglePerson("李四", 46, '男');
		SinglePerson sp6 = new SinglePerson("王五", 56, '男');
		SinglePerson sp7 = new SinglePerson("赵四儿", 36, '男');
		
		SinglePerson[] arr = {
			sp1, sp2, sp3, sp4, sp5, sp6, sp7	
		};
		
		Arrays.sort(arr, new Comparator<SinglePerson>() {
			@Override
			public int compare(SinglePerson o1, SinglePerson o2) {
				return o2.getAge() - o1.getAge();
			}
		});
		
		
		Arrays.sort(arr, (p1, p2) -> p2.getAge() - p1.getAge());
		
		for (SinglePerson singlePerson : arr) {
			System.out.println(singlePerson);
		}
	}
}
1.4 消费函数式接口 Consumer
消费式接口
	方法是消耗一个参数，但是没有返回值
	interface Consumer<T> {
		void accept(T t);
	}

package com.qfedu.a_funtion;

import java.util.function.Consumer;

/**
 * 消费函数式接口
 * 		Consumer接口是封装了一个无返回值有一个参数的方法。
 * @author Anonymous
 *
 */
public class Demo2 {
	public static void main(String[] args) {
		
		String str = "消费接口的调用";
		
		test(str, new Consumer<String>() {

			@Override
			public void accept(String t) {
				System.out.println(t);
			}
		});
		
		test(str, (s) -> {
			System.out.println("字符串长度:" + s.length());
		});
	}
	
	/**
	 * 当前方法带有一个消费接口，需要完成一个有参数无返回值方法，当前接口泛型要求String类型
	 * 
	 * @param str String类型
	 * @param c Consumer消费接口
	 */
	public static void test(String str, Consumer<String> c) {
		c.accept(str);
	}
}
1.5 生产者接口 Supplier
生产者接口
	方法不需要参数，但是存在返回值数据
	Interface Supplier<T> {
		T get();
	}

package com.qfedu.a_funtion;

/*
生产者接口
	方法不需要参数，但是存在返回值数据
	Interface Supplier<T> {
		T get();
	}
 */

import java.util.function.Supplier;

public class Demo3 {
	public static void main(String[] args) {
		Integer[] arr = {1, 3, 5, 17, 9, 2, 4, 6, 8, 10};
		
		Integer max = getMax(arr, new Supplier<Integer>() {

			@Override
			public Integer get() {
				int max = arr[0];
				for (int i = 1; i < arr.length; i++) {
					if (max < arr[i]) {
						max = arr[i];
					}
				}
				
				return max;
			}
		});
		
		Integer max2 = getMax(arr, () -> {
			int max1 = arr[0];
			for (int i = 1; i < arr.length; i++) {
				if (max1 < arr[i]) {
					max1 = arr[i];
				}
			}
			
			return max1;
		});
		
		SinglePerson sp1 = new SinglePerson("老王", 66, '男');
		SinglePerson sp2 = new SinglePerson("大哥", 18, '女');
		SinglePerson sp3 = new SinglePerson("鹏鹏", 16, '男');
		SinglePerson sp4 = new SinglePerson("张三", 66, '男');
		SinglePerson sp5 = new SinglePerson("李四", 46, '男');
		SinglePerson sp6 = new SinglePerson("王五", 56, '男');
		SinglePerson sp7 = new SinglePerson("赵四儿", 36, '男');
		
		SinglePerson[] spArr = {
			sp1, sp2, sp3, sp4, sp5, sp6, sp7	
		};
		
		SinglePerson max3 = getMax(spArr, () -> {
			SinglePerson sp = spArr[0];
			
			for (int i = 1; i < spArr.length; i++) {
				if (sp.getAge() < spArr[i].getAge()) {
					sp = spArr[i];
				}
			}
			
			return sp;
		});
		
		System.out.println(max3);
	}
	
	/**
	 * 找出指定数据类型数组中的最大值
	 * 
	 * @param <T> 反正占位符
	 * @param t 指定数据类型数组
	 * @param s 生产者接口
	 * @return 对应数据类型的最大值
	 */
	public static <T> T getMax(T[] t, Supplier<T> s) {
		return s.get();
	}
}
1.6 转换数据类型接口 Function
转换数据类型接口
	指定参数类型，指定返回值类型，将参数转换成对应指定数据类型
	Interface Function<T,R>  {
		R apply(T t);
	}

package com.qfedu.a_funtion;

import java.util.function.Function;

/**
 * 转换接口
 * @author Anonymous
 *
 */
public class Demo4 {
	public static void main(String[] args) {
		String str = "骚磊,106,男";
		
		SinglePerson person = change(str, new Function<String, SinglePerson>() {

			@Override
			public SinglePerson apply(String t) {
				String[] split = t.split(",");
			
				String name = split[0];
				int age = Integer.parseInt(split[1]);
				char gender = split[2].charAt(0);
				
				return new SinglePerson(name, age, gender);
			}
		});
		
		SinglePerson person2 = change(str, (s) -> {
			String[] split = s.split(",");
			
			String name = split[0];
			int age = Integer.parseInt(split[1]);
			char gender = split[2].charAt(0);
			
			return new SinglePerson(name, age, gender);
		});
		
		System.out.println(person2);
	}
	
	/**
	 * 讲字符串内容转换成SinglePerson类型
	 * 
	 * @param str 数据字符串
	 * @param fun 转换接口
	 * @return SinglePerson类型
	 */
	public static SinglePerson change(String str, Function<String, SinglePerson> fun) {
		return fun.apply(str);
	}
}
1.7 判断接口 Predicate
判断接口，指定数据类型通过当前test方法判断，满足要求返回true，不满足返回false 类似于filter
	Interface Predicate<T> {
		boolean test(T t);
	}

package com.qfedu.a_funtion;

import java.security.Permissions;
import java.util.ArrayList;
import java.util.function.Predicate;

public class Demo5 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("手撕大骨头");
		list.add("小鸡炖蘑菇");
		list.add("铁锅炖大鹅");
		list.add("红烧肉");
		list.add("红烧排骨");
		list.add("糖醋里脊");
		list.add("宫保鸡丁");
		list.add("辣子鸡丁");
		list.add("清蒸哈什蚂");
		list.add("西湖牛肉羹");
		list.add("米酒小圆子");
		
		/*
		list.removeIf(new Predicate<String>() {

			@Override
			public boolean test(String t) {
				return t.contains("哈什蚂");
			}
		});
		
		list.removeIf(s -> s.length() > 4);
		*/
		list.stream().skip(3).forEach(System.out::println);
	}
}
2. Stream流式操作
2.1 先体验后讲解
package com.qfedu.b_stream;

import java.util.ArrayList;

/*
 * 1. 要求获取字符串长度大于3的内容
 * 2. 跳过前5个数据
 * 3. 最后保存数据中带有"鸡丁"
 * 4. 展示
 */
public class Demo2 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();

		list.add("手撕大骨头");
		list.add("小鸡炖蘑菇");
		list.add("铁锅炖大鹅");
		list.add("红烧肉");
		list.add("红烧排骨");
		list.add("糖醋里脊");
		list.add("宫保鸡丁");
		list.add("辣子鸡丁");
		list.add("清蒸哈什蚂");
		list.add("西湖牛肉羹");
		list.add("米酒小圆子");
		
		// 流水线操作！！！
		list.stream()
			.filter(s -> s.length() > 3)
			.skip(5)
			.filter(s -> s.contains("鸡丁"))
			.forEach(System.out::println);
	}
}
2.2 Stream流式思想
流水线！！！

在这里插入图片描述

2.3 Stream流对象
Stream流对象
	对于集合提供了一套完备的使用方法，并且提供了获取Stream类对象的方法。

Collection接口中的默认方法。
default Stream<E> stream() {
	return StreamSupport.stream(spliterator(), false);
}

常用方法:
	Stream<T> filter(Predicate<? super T> predicate);
		过滤方法，需要的参数是Predicate过滤器接口
			boolean test(T t);
	
	<R> Stream<R> map(Function<? super T, ? extends R> mapper);
		映射方法，将当前Stream流中的T类型数据转换为R类型数据，并且返回的Stream
		类对象对应的是R类型数据
			R apply(T t);
		举例：
			T 土豆
			R 薯片
	
	Stream<T> sorted(Comparator<? super T> comparator);
		排序方法，要求传入的参数是Comparator接口
        	int compare(T o1, T o2);
    
    Stream<T> limit(long maxSize);
    	限制方法 maxSize最大值，演示看效果
    
    Stream<T> skip(long n);
    	跳过方法， n表示跳过的数据个数
    
    void forEach(Consumer<? super T> action);
    	forEach 遍历操作使用 需要的接口是Consumer消费者接口
    	终止方法！！！返回值类型不是Stream流
    	
    long count();
    	返回当前Stream类中还剩余多少数据
    	终止方法！！！返回值类型不是Stream流
2.4 filter 过滤
package com.qfedu.b_stream;

import java.util.ArrayList;
import java.util.stream.Stream;

/*
 * 过滤
 */
public class Demo3 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();

		list.add("冰箱 美的");
		list.add("油烟机 老板");
		list.add("洗衣机 美的");
		list.add("开关面板 西门子");
		list.add("瓷砖 东鹏");
		list.add("卧室门 Tata");
		list.add("锁 德施曼");

		/*
		 * Stream<String> stream = list.stream(); Stream<String> filter =
		 * stream.filter(s -> s.length() > 6); filter.forEach(System.out::println);
		 */
		/*
		 * Stream流处理过程中，对于原始数据是没有任何印象的，是在操作Stream流缓存数据
		 */
		list.stream()
			.filter(s -> s.length() > 6)
			.forEach(System.out::println);

		System.out.println(list);
	}
}
2.5 Map映射
package com.qfedu.b_stream;

import java.util.ArrayList;

public class Demo4 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("1,骚磊,16");
		list.add("2,大哥,18");
		list.add("3,老黑,66");
		list.add("4,帅栋,36");
		list.add("5,杨仔,26");
		list.add("6,博哥,56");
		list.add("7,鹏鹏,6");
		list.add("8,骚杰,106");
		list.add("9,苟磊,16");
		
		list.stream()
			.map(s -> {
				String[] split = s.split(",");
				
				int id = Integer.parseInt(split[0]);
				String name = split[1];
				int age = Integer.parseInt(split[2]);
				
				return new Person(id, name, age);
			})
			.forEach(System.out::println);
	}
}
2.6 sorted排序方法
package com.qfedu.b_stream;

import java.util.ArrayList;

public class Demo5 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("1,骚磊,16");
		list.add("2,大哥,18");
		list.add("3,老黑,66");
		list.add("4,帅栋,36");
		list.add("5,杨仔,26");
		list.add("6,博哥,56");
		list.add("7,鹏鹏,6");
		list.add("8,骚杰,106");
		list.add("9,苟磊,16");
		
		list.stream()
			.map(s -> {
				String[] split = s.split(",");
				
				int id = Integer.parseInt(split[0]);
				String name = split[1];
				int age = Integer.parseInt(split[2]);
				
				return new Person(id, name, age);
			})
			.sorted((p1, p2) -> p2.getAge() - p1.getAge())
			.forEach(System.out::println);;
			
		list.stream()
			.map(s -> {
				String[] split = s.split(",");
				
				int id = Integer.parseInt(split[0]);
				String name = split[1];
				int age = Integer.parseInt(split[2]);
				
				return new Person(id, name, age);
			})
			// sorted() 无参数方法需要借助于当前排序数据的自然顺序，或者Comparable接口
			.sorted() 
			.forEach(System.out::println);;
	}
}
2.7 limit 和 skip
package com.qfedu.b_stream;

import java.util.ArrayList;

public class Demo6 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("刘亦菲");
		list.add("高圆圆");
		list.add("佟丽娅");
		list.add("王祖贤");
		list.add("玛丽莲梦露");
		list.add("贾玲");
		list.add("拼多多小岳岳");
		
		list.stream()
			/*
			 * limit是限制最大个数，从0开始到maxSize
			 * limit(int maxSize)
			 */
			.limit(5)
			.forEach(System.out::println);
		
		System.out.println();
		
		list.stream()
			/*
			 * skip是跳过指定数据
			 * skip(3) 是跳过前三个
			 */
			.skip(3)
			.forEach(System.out::println);
	}	
}
2.8 foreach 和 count
终止方法！！！
	stream流运行到foreach和count终止Stream流

forEach(System.out::println);
	System.out::println 方法引用
	这里需要【引入，使用】这个方法

package com.qfedu.b_stream;

import java.util.ArrayList;

public class Demo7 {
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("胡歌");
		list.add("古巨基");
		list.add("彭于晏");
		list.add("金城武");
		list.add("成龙");
		list.add("张译");
		list.add("张涵予");
		list.add("吴京");
		list.add("陈道明");
		
		long count = list.stream().count();
		System.out.println(count);
		
		// Lambda表达式
		list.stream().forEach(s -> System.out.println(s));
		
		// 方法引用
		/*
		 * System.out::println 
		 * System.out 的 println方法
		 */
		list.stream().forEach(System.out::println);
		
		/*
		 * Demo7::printElement 
		 * Demo7的 printElement方法
		 */
		list.stream().forEach(Demo7::printElement);
	}
	
	/**
	 * 有参数无返回值的方法，需要的参数类型是String类型
	 * 
	 * @param s String类型
	 */
	public static void printElement(String s) {
		System.out.println(s);
	}
}
九离⠂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java初学者
09-13
学习过程中总结,积累出来的东西,包括,java的基本数据类型,基本语句,运算符,基本sql 语句,servlet3.0,线程,网络编程.
Java源代码：抽象类和接口
03-16
内容索引:Java源码,初学实例,抽象　抽象类和接口的Java相关源代码，包括大家喜欢的日历类Calendar和公历类GregorianCalendar，通过这些源代码可学习接口、声明类以实现Comparable接口、创建自定义接口、将基本数据...
JAVA进阶知识点总结 7-线程池、Lambda、函数式接口(生产者接口,消费者接口,函数接口,判断接口)
AdamCafe的博客
03-30 639
01.第一章：线程池_概念及作用： 1).什么是“线程池”：指封装了很多的“线程对象”的一个容器。 2).作用：内部的这些线程对象可以被“重复使用”； 线程对象每次使用完成后，会自动成为垃圾，不能再次的start。如果想要再次使用就需要再创建一个线程对象，但创建一个线程对象需要很大的系统开销，所以如果需要大量的、反复的执行同一线程会降低程序的效率。所以提出了“线程池”的概念。 02.第一章：线程池...
Java Stream类常见用法
sc179的博客
08-31 2891
Java Stream类常见用法
19.Java基础&函数式接口、Stream流
最新发布
weixin_42378614的博客
03-03 1034
函数式接口是Java 8引入的一个特性，它定义了一个抽象方法，并且可以被实现了该接口的lambda表达式或实现类实例化。@FunctionalInterface注解可以用来声明一个接口是函数式接口。欢迎关注我的公众号，获取更多Java编程的技巧和知识。编程之路，与你同行！
Java：Stream三部曲（一）：函数式接口的理解与常用示例（Runnable、Comparator、Callable、Consumer、Predicate、Supplier、Function）
whx6666666的博客
11-24 2222
Stream流处理器入门第一步——函数式接口。本文主要包含关于函数式接口的简略基础概念、个人学习过程中的一些理解以及对当前JDK中内置的主要函数式接口的用法解析（包括Runnable、Comparator、Callable、Consumer、Predicate、Supplier、Function）。
Java基础16（函数式接口，Stream流）
qq_43671768的博客
08-07 138
函数式接口 函数式接口：指有且仅有一个抽象方法的接口。 Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口，只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。 函数式接口注解： @FunctionalInterface 放在函数式接口的上方，如果接口是函数式接口则编译通过，反之编译失败。 函数式接口作为方法的参数 如果方法的参数是一个函数表达式，可以使用Lambda表达式作为该方法的参数传递 函数式接口作为方法的返回值 如果
java常用函数.doc
09-02
该资源适合初学者，内容详细，简单易懂，相信会祝你一臂之力！！！
Java接口和抽象类的区别深入剖析
09-04
主要介绍了Java接口和抽象类的区别,对于Java的初学者来说是需要准确掌握的概念！
java的API接口文档模板
01-12
java初学者
Java-Stream详解
yueerba126的博客
06-30 5168
Stream是Java 8新增的接口，Stream可以认为是一个高级版本的 Iterator。
Stream 和函数式接口的基础讲解
庄周de蝴蝶的博客
02-19 777
前言 关于 Stream 和函数式接口的基础概念的文章已经有很多，相信很多小伙伴也在实际工作中进行使用体验了。但是关于函数式接口的使用，部分小伙伴可能接触的比较少，其实我们经常使用的 map、filter 等方法内部就使用了函数式接口的知识： // 以下两个接口截取自 Java8 源码中的定义, 这里的 Function<? super T, ? extends R> // 和 Predicate<? super T> 就属于函数式接口方面的知识 <R> Stream&
函数式接口Stream类
听闻
12-29 398
一、Stream概述 1.1 关于流的简介 Java8是一个非常成功的版本，新增的Stream，配合同版本出现的Lambda，为我们操作集合提供了极大的便利。 ​ Stream 是 Java8 中处理集合的关键抽象概念，它可以指定我们希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来执行并行操作。 ​ Stream将要处理的元素集合看做一种流，在流的过程中，借助
JavaSE——Java8之函数式接口、函数式编程、Lambda表达式
zhupup
12-11 200
一、函数式接口 1、概念   函数式接口的几点特征：    函数式接口只有一个抽象方法；    default方法某默认实现，不属于抽象方法；    接口重写了Object的公共方法也不算入内。   函数式接口的应用场景：函数式编程，而在Java中的函数式编程就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中只有一个抽象方法，Lambda表达式才能顺利的进行...
玩转Java8的 Stream 之函数式接口
Java知音
05-24 662
作者：liteskywww.jianshu.com/p/2338cabc59e1函数式接口是伴随着Stream的诞生而出现的，Java8Stream 作为函数式编程的一种具体实现，开发者...
Stream流的使用函数式接口
weixin_47120348的博客
01-20 415
认识函数式接口 @FunctionalInterface public interface Lamdbatest { Integer getdouble(Integer s); } Lamdba表达式 lamdba可以实现函数式接口创建出一个对象， lamdba允许把一个函数作为一个方法的参数，或是将一个方法赋值给一个属性 -实现类实现接口 public class impllamdba implements Lamdbatest { @Override public I.
JAVA-接口中定义抽象方法及使用{笔记}
QL_DIANDIAN的博客
09-27 7511
接口的定义 在接口中定义抽象方法的时候 （抽象方法的一般格式;public abstract 返回值类型 方法名（）；） (1)但是在接口中抽象方法，修饰符必须是两个固定的关键字 public abstract (2)其中public abstract 可以省略 (3)方法的三要素可以随意更改 public interface Myinterface { //以下都可以 public abstract void method(); public void method1(); abstract
函数式接口与Stream流的用法
zouyouxiu的博客
12-29 726
文章目录函数式接口与Stream流的用法1.函数式接口1.1 常用函数式接口2.Stream流1.1 获取流1.2 常用方法 函数式接口与Stream流的用法 1.函数式接口 函数接口在java中是指：有且仅有一个抽象方法的接口。函数式接口，即适用于函数式编程场景使用。而java中的函数式编程体现的就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象...
java初学者推荐书籍
11-03
以下是几本适合Java初学者的书籍： 1.《Java编程入门经典》：这本书是一本非常适合Java初学者的入门书籍，它详细介绍了Java的基础知识和编程技巧，同时还提供了大量的实例和练习，帮助读者快速掌握Java编程的基本技能。 2.《Java核心技术》：这本书是一本比较全面的Java技术参考书，它详细介绍了Java的核心技术和应用，包括Java语言基础、面向对象编程、Java集合框架、多线程编程、网络编程等方面的内容，是Java初学者和进阶者都值得一读的好书。 3.《Head First Java》：这本书是一本非常有趣的Java入门书籍，它采用了大量的图表和幽默的语言，帮助读者轻松理解Java编程的基本概念和技巧，同时还提供了大量的实例和练习，帮助读者快速掌握Java编程的基本技能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值