第十章 函数式接口&Stream流

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、四大内置核心函数式接口

第十章 函数式接口&Stream流_第1张图片

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

你可能感兴趣的:(JavaSE)