10.1、函数式接口

10.1.1、概述

有且仅有一个抽象方法的接口，并且可以通过在类上标注@FunctionalInterface注解进行检测，建议自定义的函数式接口都加上这个注解

10.1.2、函数式接口作为方法的参数

public class Main {

	public static void main(String[] args) {

		// 匿名内部类的方式

		startThread(new Runnable() {

			@Override

			public void run() {

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

			}

		});

		// Lambda表达式方式

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

	}

	private static void startThread(Runnable r) {

		new Thread(r).start();

	}

}

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

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

public class Main {

	public static void main(String[] args) {

		ArrayList<String> array1 = new ArrayList<String>();

		array1.add("cccc");

		array1.add("aaa");

		array1.add("bb");

		array1.add("d");

		System.out.println("排序前：" + array1);

		Collections.sort(array1, getComparator1());

		System.out.println("排序后：" + array1);

		ArrayList<String> array2 = new ArrayList<String>();

		array2.add("cccc");

		array2.add("aaa");

		array2.add("bb");

		array2.add("d");

		System.out.println("排序前：" + array2);

		Collections.sort(array2, getComparator2());

		System.out.println("排序后：" + array2);

	}

	// 匿名内部类的方式实现

	private static Comparator<String> getComparator1() {

		return new Comparator<String>() {

			@Override

			public int compare(String s1, String s2) {

				return s1.length() - s2.length();

			}

		};

	}

	// Lambda表达式方式实现

	private static Comparator<String> getComparator2() {

		return (s1, s2) -> s1.length() - s2.length();

	}

}

10.1.4、四大内置核心函数式接口

10.1.4.1、Supplier接口

import java.util.function.Supplier;

public class Main {

	public static void main(String[] args) {

		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();

	}

}

10.1.4.2、Consumer接口

import java.util.function.Consumer;

public class Main {

	public static void main(String[] args) {

		operatorString("林青霞", s -> System.out.println(s));

		operatorString("林青霞", s -> System.out.println(new StringBuilder(s).reverse().toString()));

		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);

	}

}

10.1.4.3、Predicate接口

import java.util.function.Predicate;

public class Main {

	public static void main(String[] args) {

		boolean b1 = checkString("helloworld", s -> s.length() > 8);

		System.out.println(b1);

		boolean b2 = checkStringNot("helloworld", s -> s.length() > 8);

		System.out.println(b2);

		boolean b3 = checkStringAnd("helloworld", s -> s.length() > 8, s -> s.length() < 10);

		System.out.println(b3);

		boolean b4 = checkStringOr("helloworld", s -> s.length() > 8, s -> s.length() < 10);

		System.out.println(b4);

	}

	// 定义一个方法，对给定的参数进行判断

	private static boolean checkString(String s, Predicate<String> pre) {

		return pre.test(s);

	}

	// 定义一个方法，返回一个逻辑的否定，对应逻辑非

	private static boolean checkStringNot(String s, Predicate<String> pre) {

		return pre.negate().test(s);

	}

	// 定义一个方法，返回一个组合判断，对应短路与

	private static boolean checkStringAnd(String s, Predicate<String> pre1, Predicate<String> pre2) {

		return pre1.and(pre2).test(s);

	}

	// 定义一个方法，返回一个组合判断，对应短路或

	private static boolean checkStringOr(String s, Predicate<String> pre1, Predicate<String> pre2) {

		return pre1.or(pre2).test(s);

	}

}

10.1.4.4、Function接口

import java.util.function.Function;

public class Main {

	public static void main(String[] args) {

		convert("100", s -> Integer.parseInt(s));

		convert(100, i -> String.valueOf(i));

		convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i));

	}

	// 定义一个方法，把一个字符串转换为int类型，在控制台输出

	private static void convert(String s, Function<String, Integer> fun) {

		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) {

		String ss = fun1.andThen(fun2).apply(s);

		System.out.println(ss);

	}

}

10.2、Stream流

10.2.1、概述

流（Stream）是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。集合讲的是数据，流讲的是计算

10.2.2、操作步骤

1. 获流对象：一个数据源（如：集合、数组），获取一个流（如：串行流、并行流、无限流）

   import java.util.ArrayList;
   
   import java.util.Arrays;
   
   import java.util.HashMap;
   
   import java.util.HashSet;
   
   import java.util.List;
   
   import java.util.Map;
   
   import java.util.Map.Entry;
   
   import java.util.Set;
   
   import java.util.UUID;
   
   import java.util.stream.DoubleStream;
   
   import java.util.stream.IntStream;
   
   import java.util.stream.LongStream;
   
   import java.util.stream.Stream;
   
   public class Main {
   
   	public static void main(String[] args) {
   
   		// Collection体系的集合直接生成流
   
   		List<String> list = new ArrayList<String>();
   
   		Stream<String> listStream = list.stream();// 顺序流
   
   		Stream<String> parallelListStream = list.parallelStream(); // 并行流
   
   		Set<String> set = new HashSet<String>();
   
   		Stream<String> setStream = set.stream();// 顺序流
   
   		Stream<String> parallelSetStream = set.parallelStream();// 并行流
   
   		// Map体系的集合间接生成流
   
   		Map<String, Integer> map = new HashMap<String, Integer>();
   
   		Stream<String> keyStream = map.keySet().stream();// 顺序流
   
   		Stream<String> parallelKeyStream = map.keySet().parallelStream();// 并行流
   
   		Stream<Integer> valueStream = map.values().stream();// 顺序流
   
   		Stream<Integer> parallelValueStream = map.values().parallelStream();// 并行流
   
   		Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();// 顺序流
   
   		Stream<Entry<String, Integer>> parallelEntryStreamStream = map.entrySet().parallelStream();// 并行流
   
   		// 数组可以通过Arrays类的静态方法Arrays.stream(T[] array)生成流
   
   		int[] intArray = { 10, 20, 30 };
   
   		IntStream intStream = Arrays.stream(intArray);// 顺序流
   
   		IntStream parallelIntStream = intStream.parallel();// 并行流
   
   		long[] longArray = { 10L, 20L, 30L };
   
   		LongStream longStream = Arrays.stream(longArray);// 顺序流
   
   		LongStream parallelLongStream = longStream.parallel();// 并行流
   
   		double[] doubleArray = { 10.1, 20.2, 30.3 };
   
   		DoubleStream doubleStream = Arrays.stream(doubleArray);// 顺序流
   
   		DoubleStream parallelDoubleStream = doubleStream.parallel();// 并行流
   
   		// 数组可以通过Stream接口的静态方法Stream.of(T... values)生成流
   
   		Stream<String> strArrayStream = Stream.of("hello", "world", "java");// 顺序流
   
   		Stream<String> parallelStrArrayStream = strArrayStream.parallel();// 并行流
   
   		Stream<Integer> intArrayStream = Stream.of(10, 20, 30);// 顺序流
   
   		Stream<Integer> parallelIntArrayStream = intArrayStream.parallel();// 并行流
   
   		Stream<Long> longArrayStream = Stream.of(10L, 20L, 30L);// 顺序流
   
   		Stream<Long> parallelLongArrayStream = longArrayStream.parallel();// 并行流
   
   		Stream<Double> doubleArrayStream = Stream.of(10.1, 20.2, 30.3);// 顺序流
   
   		Stream<Double> parallelDoubleArrayStream = doubleArrayStream.parallel();// 并行流
   
   		// 创建无限流
   
   		Stream<Integer> iterateStream = Stream.iterate(0, i -> i + 2);
   
   		iterateStream.limit(10).forEach(System.out::println);
   
   		Stream<UUID> generateStream = Stream.generate(UUID::randomUUID);
   
   		generateStream.limit(10).forEach(System.out::println);
   
   	}
   
   }
   
   

2. 中间操作：一个中间操作链，对数据源的数据进行处理

   • filter()
   • limit()
   • skip()
   • distinct()
   • sorted()
   • map()
   • mapToInt()
   • mapToLong()
   • mapToDouble()
   • flatMap()
   • flatMapToInt()
   • flatMapToLong()
   • flatMapToDouble()
   • peek()

3. 终止操作：一个终止操作，执行中间操作链并产生结果

   • forEach()
   • forEachOrdered()
   • count()
   • min()
   • max()
   • reduce()
   • collect()
   • toArray()
   • findFirst()
   • findAny()
   • anyMatch()
   • allMatch()
   • noneMatch()

10.2.3、代码演示

filter代码演示：

import java.util.ArrayList;

public class Main {

	public static void main(String[] args) {

		// 创建一个集合，存储多个字符串元素

		ArrayList<String> list = new ArrayList<String>();

		list.add("林青霞");

		list.add("张曼玉");

		list.add("王祖贤");

		list.add("柳岩");

		list.add("张敏");

		list.add("张无忌");

		// 需求1：把list集合中以张开头的元素在控制台输出

		list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);

		System.out.println("----------");

		// 需求2：把list集合中长度为3的元素在控制台输出

		list.stream().filter(s -> s.length() == 3).forEach(System.out::println);

		System.out.println("----------");

		// 需求3：把list集合中以张开头的且长度为3的元素在控制台输出

		list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);

	}

}

limit&skip代码演示：

import java.util.ArrayList;

public class Main {

	public static void main(String[] args) {

		// 创建一个集合，存储多个字符串元素

		ArrayList<String> list = new ArrayList<String>();

		list.add("林青霞");

		list.add("张曼玉");

		list.add("王祖贤");

		list.add("柳岩");

		list.add("张敏");

		list.add("张无忌");

		// 需求1：取前3个数据在控制台输出

		list.stream().limit(3).forEach(System.out::println);

		System.out.println("----------");

		// 需求2：跳过3个元素，把剩下的元素在控制台输出

		list.stream().skip(3).forEach(System.out::println);

		System.out.println("----------");

		// 需求3：跳过2个元素，把剩下的元素中前2个在控制台输出

		list.stream().skip(2).limit(2).forEach(System.out::println);

	}

}

distinct代码演示：

import java.util.ArrayList;

public class Main {

	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.add("张无忌");

		// 需求1：把集合元素在控制台输出，要求字符串元素不能重复

		list.stream().distinct().forEach(System.out::println);

	}

}

sorted代码演示：

import java.util.ArrayList;

public class Main {

	public static void main(String[] args) {

		// 创建一个集合，存储多个字符串元素

		ArrayList<String> list = new ArrayList<String>();

		list.add("linqingxia");

		list.add("zhangmanyu");

		list.add("wangzuxian");

		list.add("liuyan");

		list.add("zhangmin");

		list.add("zhangwuji");

		// 需求1：按照字母顺序把数据在控制台输出

		list.stream().sorted().forEach(System.out::println);

		System.out.println("----------");

		// 需求2：按照字符串长度把数据在控制台输出

		list.stream().sorted((s1, s2) -> {

			int num1 = s1.length() - s2.length();

			int num2 = num1 == 0 ? s1.compareTo(s2) : num1;

			return num2;

		}).forEach(System.out::println);

	}

}

map&mapToInt&mapToLong&mapToDouble代码演示:

import java.util.ArrayList;

public class Main {

	public static void main(String[] args) {

		// 创建一个集合，存储多个字符串元素

		ArrayList<String> list = new ArrayList<String>();

		list.add("10");

		list.add("20");

		list.add("30");

		list.add("40");

		list.add("50");

		// 需求1：将集合中的字符串数据转换为整数之后在控制台输出

		list.stream().map(Integer::parseInt).forEach(System.out::println);

		System.out.println("----------");

		// 需求2：将集合中的字符串数据转换为Integer之后在控制台输出

		list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);

		System.out.println("----------");

		// 需求3：将集合中的字符串数据转换为Long之后在控制台输出

		list.stream().mapToLong(Long::parseLong).forEach(System.out::println);

		System.out.println("----------");

		// 需求4：将集合中的字符串数据转换为Double之后在控制台输出

		list.stream().mapToDouble(Double::parseDouble).forEach(System.out::println);

	}

}

forEach&forEachOrdered&count代码演示：

import java.util.ArrayList;

public class Main {

	public static void main(String[] args) {

		// 创建一个集合，存储多个字符串元素

		ArrayList<String> list = new ArrayList<String>();

		list.add("林青霞");

		list.add("张曼玉");

		list.add("王祖贤");

		list.add("柳岩");

		list.add("张敏");

		list.add("张无忌");

		// 需求1：把集合中的元素在控制台输出

		list.stream().forEach(System.out::println);

		System.out.println("----------");

		// 需求2：把集合中的元素在控制台输出

		list.stream().forEachOrdered(System.out::println);

		System.out.println("----------");

		// 需求3：统计集合中有几个以张开头的元素，并把统计结果在控制台输出

		long count = list.stream().filter(s -> s.startsWith("张")).count();

		System.out.println(count);

	}

}

max&min代码演示：

import java.util.ArrayList;

public class Main {

	public static void main(String[] args) {

		// 创建一个集合，存储多个整数元素

		ArrayList<Integer> list = new ArrayList<Integer>();

		list.add(10);

		list.add(20);

		list.add(30);

		list.add(40);

		list.add(50);

		// 需求1：获取集合中的最大值在控制台输出

		Integer max = list.stream().max(Integer::compareTo).get();

		System.out.println(max);

		// 需求2：获取集合中的最小值在控制台输出

		Integer min = list.stream().min(Integer::compareTo).get();

		System.out.println(min);

	}

}

最新文章

1. gulp使用引导
2. Flex 监听浏览器关闭
3. Ixia测试仪的自动化
4. ie6兼容性
5. 2016年最受欢迎中国开源软件TOP 20
6. rpm安装软件(需管理员权限)
7. g++编译cpp文件
8. [LeetCode]题解（python）：017-Letter Combinations of a Phone Number
9. mwValidate.js验证插件
10. 《Thinking in Java》学习笔记(三)
11. Java Jar包压缩、解压使用指南
12. BZOJ2567 : 篱笆
13. scala读取解析json文件
14. [Educational Round 3][Codeforces 609E. Minimum spanning tree for each edge]
15. 使用 Ansible 统计服务器资源利用率
16. Pycharm4.5注册码 激活
17. python的反射函数（hasattr()、getattr()、setattr()与delattr()）和类的内置属性attr（__getattr()__、__setattr()__与__delattr()__）
18. 芯灵思SInA33开发板怎样烧写镜像文件
19. 利用blob对象实现粘贴图片
20. Jaccard similarity(杰卡德相似度)和Abundance correlation（丰度相关性）

热门文章

1. django admin 添加用户出现外键约束错误
2. 洛谷 P4822 [BJWC2012]冻结
3. SpringBoot-多数据源配置-Mysql-SqlServer-Oracle
4. Java实现 第十一届蓝桥杯——走方格（渴望有题目的大佬能给小编提供一下题目，讨论群：99979568）
5. mysql 常见使用场景
6. git clone 别人的项目的步骤
7. Zip破解工具Fcrackzip使用简介
8. 央行数字货币(CBDCs)的互操作性至关重要
9. VS2019阅读源码 翻译注释插件
10. day22 作业