Java8新特性(二)(持续更新中)

让我们接着上一篇的Lambda表达式继续

2.7 java.util.function.Supplier接口

Supplier接口返回一个任意范型的值,和Function接口不同的是该接口没有任何参数
public interface Supplier {
T get();
}
例如:

public class SupplierTest {
		public static void main(String[] args) {
			//生成一个八位的随机字符串
			Supplier<String> f = ()->{
				String base = "abcdefghijklmnopqrstuvwxyz0123456789";     
				Random random = new Random();     
				StringBuffer sb = new StringBuffer();     
				for (int i = 0; i < 8; i++) {  
					//生成[0,base.length)之间的随机数
					int number = random.nextInt(base.length());     
					sb.append(base.charAt(number));     
				}     
				return sb.toString();   
			};
			System.out.println(f.get());
		}
}

2.8 java.util.function.Consumer接口

Consumer接口接收一个任意范型的值,和Function接口不同的是该接口没有任何值

public interface Consumer<T> {

		void accept(T t);

		default Consumer<T> andThen(Consumer<? super T> after) {
			Objects.requireNonNull(after);
			return (T t) -> { accept(t); after.accept(t); };
		}
	}
	

例如:

	public class ConsumerTest {
		//静态内部类
		private static class Student{
			private String name;
			public String getName() {
				return name;
			}
			public void setName(String name) {
				this.name = name;
			}
		}
		
		public static void main(String[] args) {
			Student s = new Student();
			s.setName("tom");
			
			Consumer<Student> first = stu->{
				System.out.println("我要第一个执行,把name值给改了");
				stu.setName("zhangsan");
			};
			Consumer<Student> then = stu->{
				System.out.println("我紧跟着执行,输出的name值为:"+stu.getName());
			};
			first.andThen(then).accept(s);
			
		}
		
	}

总结:

	Function<T, R>  接口   R apply(T t);       有参数有返回值
	Supplier<T>     接口   T get();		       没参数有返回值
	Consumer<T>     接口   void accept(T t);   有参数没返回值

另外需要注意的接口: 其用法和上面介绍的接口使用方式类同

BinaryOperator<T>接口    T apply(T t, T t)  将两个T作为输入,返回一个T作为输出

注:一般用于同一类型的数据的合并

BiFunction<T, U, R>接口  R apply(T t, U u)  将一个T和一个U输入,返回一个R作为输出

注:俩种不同类型的数据,操作后得到第三种类型的数据
注:BinaryOperator接口继承了BiFunction接口

public interface BinaryOperator<T> extends BiFunction<T,T,T>

BiConsumer<T, U>接口  void accept(T t, U u) 将俩个参数传入,没有返回值

注:可以根据具体的功能需求,来自定义出自己的函数式接口

2.9 java.util.Optional类

Optional 不是接口而是一个类,这是个用来防止NullPointerException异常的辅助类型
Optional 被定义为一个简单的容器,其值可能是null或者不是null。在Java8之前一般某个函数应该返回非空对象但是偶尔却可能返回了null,而在Java8中,不推荐你返回null而是返回Optional。
这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。

public class OptionalTest {
	
	public static void main(String[] args) {
		
		/*of方法 为非null的值创建一个Optional对象*/
		//需要注意的是,创建对象时传入的参数不能为null。
		//如果传入参数为null,则抛出NullPointerException 。
		Optional<String> op1 = Optional.of("hello");
		
		/*ofNullable方法 为指定的值创建一个Optional,如果指定的值为null,则返回一个空的Optional。*/
		//ofNullable与of方法相似,唯一的区别是可以接受参数为null的情况
		Optional<String> op2 = Optional.ofNullable(null);
		
		/*isPresent方法 如果值存在返回true,否则返回false。*/
		/*get方法 如果Optional有值则将其返回,否则抛出NoSuchElementException。*/
		if(op1.isPresent()){
			System.out.println(op1.get());
		}
		if(op2.isPresent()){
			System.out.println(op2.get());
		}
		
		/*ifPresent方法 如果Optional实例有值则为其调用consumer接口中的方法,否则不做处理*/
		//consumer接口中的方法只有参数没有返回值
		//public void accept(T t);

		op1.ifPresent(str->System.out.println(str));
		op2.ifPresent(str->System.out.println(str));//这个不执行 因为op2里面的值是null
		
		
		/*orElse方法 如果有值则将其返回,否则返回指定的其它值。*/
		System.out.println(op1.orElse("如果op1中的值为null则返回这句话"));
		System.out.println(op2.orElse("如果op2中的值为null则返回这句话"));
		
		
		/*orElseGet方法 orElseGet与orElse方法类似,区别在于得到的默认值的方式不同。orElse方法将传入的字符串作为默认值,orElseGet方法可以接受Supplier接口的实现用来生成默认值。*/
		//Supplier接口中的方法没有参数但是有返回值
		//public T get();
		System.out.println(op1.orElseGet(()->"自己定义的返回值"));
		System.out.println(op2.orElseGet(()->"自己定义的返回值"));
		
		
		/*orElseThrow方法 如果有值则将其返回,否则抛出supplier接口创建的异常。*/
		//在orElseThrow中我们可以传入一个lambda表达式或方法,如果值不存在来抛出异常。
		//orElseThrow方法的声明如下 所有只能返回一个Throwable类型对象
		//public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X

		try {
			System.out.println(op1.orElseThrow(Exception::new));
			//System.out.println(op2.orElseThrow(NullPointerException::new));这个会抛出异常
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		
		/*map方法 如果有值,则调用mapper的函数处理并得到返回值*/
		//返回值并且依然Optional包裹起来,其泛型和你返回值的类型一致
		//public<U> Optional<U> map(Function<? super T, ? extends U> mapper)

		Optional<Integer> map1 = op1.map(str->1);
		System.out.println(map1.orElse(0));
		Optional<Double> map2 = op2.map(str->1.2);
		System.out.println(map2.orElse(0D));
		
		
		/*flatMap方法 如果有值,则调用mapper的函数返回Optional类型返回值,否则返回空Optional。*/
		//flatMap与map方法类似,区别在于flatMap中的mapper返回值必须是Optional。
		//调用结束时,flatMap不会对结果用Optional封装
		//需要我们自己把返回值封装为Optional
		//public<U> Optional<U> flatMap(Function<? super T, 
		Optional<U>> mapper);

		Optional<String> flatMap = op1.flatMap(str->Optional.of(str+"_briup"));
		System.out.println(flatMap.get());
		//编译出错,因为lambda表示的函数的返回类型不对
		//op1.flatMap(str->"");
		
		

		/*filter方法 如果有值并且满足断言条件返回包含该值的Optional,否则返回空Optional。*/
		//public Optional<T> filter(Predicate<? super T> predicate);
		
		op1 = op1.filter(str->str.length()<10);
		System.out.println(op1.orElse("值为null"));
		op1 = op1.filter(str->str.length()>10);
		System.out.println(op1.orElse("值为null"));
	}