JDK8新特性

素颜马尾好姑娘i 2023-06-11 04:23 16阅读 0赞

###     **一、default关键字** ###

在java里面，我们通常都是认为接口里面是只能有抽象方法，不能有任何方法的实现的，那么在jdk1.8里面打破了这个规定，引入了新的关键字default，通过使用default修饰方法，可以让我们在接口里面定义具体的方法实现，如下。

/**
     * default关键字
     * @author 游王子
     * 2019年10月29日 上午9:53:22
     */
    public interface NewCharacterTest {
    	
    	public void test1();
    
    	public default void test2() {
    		System.out.println("我是新特性default");
    	}
    }

这么定义一个方法的主要意义是定义一个默认方法，也就是说这个接口的实现类实现了这个接口之后，不用管这个default修饰的方法，也可以直接调用，如下。

public class NewCharacterTestImpl implements NewCharacterTest{
    	@Override
    	public void test1() {
    	}
    }

public static void main(String[] args) {
    		NewCharacterTest newCharacterTest=new NewCharacterTestImpl();
    		newCharacterTest.test2();
    	}

这个default方法是所有的实现类都不需要去实现的就可以直接调用，那么比如说jdk的集合List里面增加了一个sort方法，那么如果定义为一个抽象方法，其所有的实现类如arrayList,LinkedList等都需要对其添加实现，那么现在用default定义一个默认的方法之后，其实现类可以直接使用这个方法了，这样不管是开发还是维护项目，都会大大简化代码量。

### **二、Lambda 表达式** ###

Lambda表达式是jdk1.8里面的一个重要的更新，这意味着java也开始承认了函数式编程，并且尝试引入其中。首先，什么是函数式编程，引用廖雪峰先生的教程里面的解释就是说：函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数。

// 这是常规的Collections的排序的写法，需要对接口方法重写
    	public void test1() {
    		List<Integer> list = Arrays.asList(524, 124, 12, 3);
    		Collections.sort(list, new Comparator<Integer>() {
    			@Override
    			public int compare(Integer o1, Integer o2) {
    				return o2.compareTo(o1);
    			}
    		});
    		for (Integer integer : list) {
    			System.out.println(integer);
    		}
    	}
    
    //这是带参数类型的Lambda的写法
    	public void testLambda1() {
    		List<Integer> list = Arrays.asList(524, 124, 12, 3);
    		Collections.sort(list, (Comparator<? super Integer>) (Integer a, Integer b) -> {
    			return b.compareTo(a);
    		});
    		for (Integer integer : list) {
    			System.out.println(integer);
    		}
    	}
    
    //这是不带参数的lambda的写法
    	public void testLambda2() {
    		List<Integer> list = Arrays.asList(524, 124, 12, 3);
    		Collections.sort(list, (a, b) -> b.compareTo(a));
    		for (Integer integer : list) {
    			System.out.println(integer);
    		}
    
    	}

可以看到不带参数的写法一句话就搞定了排序的问题，所以引入lambda表达式的一个最直观的作用就是大大的简化了代码的开发，像其他一些编程语言Scala，Python等都是支持函数式的写法的。当然，不是所有的接口都可以通过这种方法来调用，只有函数式接口才行，jdk1.8里面定义了好多个函数式接口，我们也可以自己定义一个来调用，下面说一下什么是函数式接口。

### **三、函数式接口** ###

定义：“函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。jdk1.8提供了一个@FunctionalInterface注解来定义函数式接口，如果我们定义的接口不符合函数式的规范便会报错。

@FunctionalInterface
    public interface MyLambda {
    
    	public void test1(String y);
    
    	// 这里如果继续加一个抽象方法便会报错
    //	    public void test2();
    
    	// default方法可以任意定义
    	default String test3() {
    		return "123";
    	}
    	// static方法也可以定义
    	static void test4() {
    		System.out.println("234");
    	}
    }

看一下这个接口的调用，符合lambda表达式的调用方法。

MyLambda m = y -> System.out.println("123"+y);

### ** 四、方法与构造函数引用** ###

jdk1.8提供了另外一种调用方式::，当你需要使用方法引用时 ，目标引用放在分隔符::前 ，方法的名称放在后面，即`ClassName :: methodName`。例如，`Apple::getWeight`就是引用了Apple类中定义的方法getWeight。请记住，不需要括号，因为你没有实际调用这个方法。方法引用就是Lambda表达式`(Apple a) -> a.getWeight()`的快捷写法，如下示例。

/**
     * 转换类型接口
     * @author 游王子
     * 2019年10月29日 上午11:37:44
     * @param <T> 
     * @param <F>
     */
    @FunctionalInterface
    public interface TestConvert<T,F> {
    	 F convert(T t);
    }

测试如下，可以以::形式调用

TestConvert<String, Integer> t = Integer::valueOf;
    		//相当于下面这种写法
    TestConvert<String, Integer> t = s -> Integer.valueOf(s);

此外，对于构造方法也可以这么调用

/**
     * 用户实体类
     * @author 游王子
     * 2019年10月29日 上午11:43:25
     */
    public class User {
    	private String name;
    
    	private String sex;
    
    	public User(String name, String sex) {
    		super();
    		this.name = name;
    		this.sex = sex;
    	}
    }

/**
     * 用户工厂
     * @author 游王子
     * 2019年10月29日 上午11:44:44
     */
    public interface UserFactory {
    
    	User get(String name, String sex);
    }

测试：

public static void main(String[] args) {
    		UserFactory uf = User::new;
    	    User u = uf.get("ww", "man");
    	}

这里的User::new就是调用了User的构造方法，Java编译器会自动根据UserFactory.get方法的签名来选择合适的构造函数。

### **五、局部变量限制** ###

Lambda表达式也允许使用自由变量（不是参数，而是在外层作用域中定义的变量），就像匿名类一样。 它们被称作捕获Lambda。 Lambda可以没有限制地捕获（也就是在其主体中引用）实例变量和静态变量。但局部变量必须显式声明为final，或事实上是final。  
　　为什么局部变量有这些限制？

1.      实例变量和局部变量背后的实现有一个关键不同。实例变量都存储在堆中，而局部变量则保存在栈上。如果Lambda可以直接访问局部变量，而且Lambda是在一个线程中使用的，则使用Lambda的线程，可能会在分配该变量的线程将这个变量收回之后，去访问该变量。因此， Java在访问自由局部变量时，实际上是在访问它的副本，而不是访问原始变量。如果局部变量仅仅赋值一次那就没有什么区别了——因此就有了这个限制。
2.  　这一限制不鼓励你使用改变外部变量的典型命令式编程模式。

final int num = 1;
    		Converter<Integer, String> stringConverter =
    		        (from) -> String.valueOf(from + num);
    		String convert = stringConverter.convert(100);
    		System.out.println(convert);

### **六、Date Api更新** ###

1.8之前JDK自带的日期处理类非常不方便，我们处理的时候经常是使用的第三方工具包，比如commons-lang包等。不过1.8出现之后这个改观了很多，比如日期时间的创建、比较、调整、格式化、时间间隔等。这些类都在java.time包下。比原来实用了很多。

1.  *　　*LocalDate/LocalTime/LocalDateTime：LocalDate为日期处理类、LocalTime为时间处理类、LocalDateTime为日期时间处理类，方法都类似，具体可以看API文档或源码，选取几个代表性的方法做下介绍。now相关的方法可以获取当前日期或时间，of方法可以创建对应的日期或时间，parse方法可以解析日期或时间，get方法可以获取日期或时间信息，with方法可以设置日期或时间信息，plus或minus方法可以增减日期或时间信息；
2.  *　　*TemporalAdjusters：这个类在日期调整时非常有用，比如得到当月的第一天、最后一天，当年的第一天、最后一天，下一周或前一周的某天等。
3.   　　DateTimeFormatter：以前日期格式化一般用SimpleDateFormat类，但是不怎么好用，现在1.8引入了DateTimeFormatter类，默认定义了很多常量格式（ISO打头的），在使用的时候一般配合LocalDate/LocalTime/LocalDateTime使用，比如想把当前日期格式化成yyyy-MM-dd hh:mm:ss的形式

public static void main(String[] args) {
    		LocalDateTime dt = LocalDateTime.now();  
    		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");         
    		System.out.println(dtf.format(dt));
    	}

### **七、流（**Stream**）** ###

它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream，也不是 Amazon Kinesis 对大数据实时处理的 Stream。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。通常编写并行代码很难而且容易出错, 但使用 Stream API 无需编写一行多线程的代码，就可以很方便地写出高性能的并发程序。

**（1）流和集合的区别**

1.  流不存储元素。他们可以被存储在隐式的集合中或者按命令生成。
2.  流操作不改变源。
3.  流操作是懒惰型的，他们只有在实际调用到的时候才会执行。

**（2）创建流**

流的创建主要有以下几种：

1、Collection的实现类例如List,Set,Queue等调用stream()方法

Stream<String> stream = new ArrayList<String>().stream();

2、数组类型调用Arrays.stream()方法/可变参数类型调用Stream.of()方法

int[] ints = {1, 2, 3};
    		    Arrays.stream(ints);
    		  //可以指定生成的起始和终点
    		    Arrays.stream(ints, 1, 2);
    		    Stream.of(1, 2, 3);

3、创建一个空的流

Stream<Object> empty = Stream.empty();

4、从文件读取一个流

Path path = Paths.get("D:\\test.txt");
    Stream<String> lines = Files.lines(path);

5、无限流,用Stream.generate方法和Stream.iterate方法：

//常量Stream
    	    Stream<String> echos = Stream.generate(() -> "Echo");
    	    //随机数Stream
    	    Stream<Double> randoms = Stream.generate(Math::random);
    	    Stream.iterate(new Integer(1), (x)-> x+1).forEach(System.out::println);

**（3）转换**

1、filter()过滤

例如筛选字符串长度，通常流中的元素个数会减少。

List<String> list = Arrays.asList("a", "abc", "qWE", "c");
    		    list.stream()
    		        .filter((x)-> x.length() > 1)
    		        .forEach(System.out::println);

2、map()映射

例如大小写转换。流中元素个数不变。

List<String> list = Arrays.asList("a", "abc", "qWE", "c");
    	    list.stream()
    	        .map(w -> w.toUpperCase())
    	        .forEach(System.out::println);

3、flatMap()平铺映射。流中元素个数可能会增加。

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "abc", "qWE", "c");
    		list.stream().flatMap(w -> letters(w)).forEach(System.out::println);
    	}
    
    	/**
    	 * 将字符串s分割成由单个字符组成的List，再通过stream方法转成流。
    	 * @param s
    	 * @return
    	 */
    	public static Stream<String> letters(String s) {
    		List<String> result = new ArrayList<>();
    		for (int i = 0; i < s.length(); i++) {
    			result.add(s.substring(i, i + 1));
    		}
    		return result.stream();
    	}

**（4）扩展和拼接streams**

1、limit()限制返回的个数

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "abc", "qWE", "c");
    		list.stream().limit(2L).forEach(System.out::println);
    	}

2、skip()跳过开始的个数

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "abc", "qWE", "c");
    		list.stream().skip(2L).forEach(System.out::println);
    	}

3、concat()拼接两个stream

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "abc", "qWE", "c");
    		List<String> list2 = Arrays.asList("12", "423", "1", "4");
    		Stream.concat(list.stream(), list2.stream()).forEach(System.out::println);
    	}

**（5）其他转换方式**

1、distinct()去重

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "a", "abc", "abc", "qWE", "c");
    		list.stream().distinct().forEach(System.out::println);
    	}

2、sorted()排序

sorted有两个实现方法，一个是无参的 一个是有参的。

*  Stream sorted()。
 *  Stream sorted(Comparator<? super T> comparator)

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "a", "abc", "abc", "qWE", "c");
    		list.stream().forEach(w -> System.out.print(w + " "));
    		System.out.println();
    		list.stream().sorted(Comparator.comparing(w -> w.length())).forEach(w -> System.out.print(w + " "));
    	}

（6）收集结果

1、forEach()遍历流、peek() 对每个元素执行操作并返回一个新的 Stream

通常收集结果会消费掉流，但是使用peek不会消费掉流，而被视为一个中间操作。

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "a", "abc", "abc", "qWE", "c");
    		list.stream().peek(x -> System.out.println("peek:" + x)).filter(x -> x.length() > 1)
    				.forEach(System.out::println);
    	}

2、toArray()将stream存储为array

无参的toArray方法直接返回Object\[\]对象。如果传入类生成器，则返回对应的类对象。如：toArray(String \[\]::new)返回String \[\]

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "a", "abc", "abc", "qWE", "c");
    		String[] strings = list.stream().filter(x -> x.length() > 1).toArray(String[]::new);
    		System.out.println(Arrays.toString(strings));
    	}

3、collect

*  collect(Collectors.toList()):list类型
 *  collect(Collectors.toSet()):set类型
 *  collect(Collectors.toCollection(TreeSet::new));TreeSet类型
 *  collect(Collectors.joining())将stream中所有的string拼接成一条
 *  collect(Collectors.joining(","))以,为分隔符拼接

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "a", "abc", "abc", "qWE", "c");
    		List<String> strings = list.stream().filter(x -> x.length() > 1).collect(Collectors.toList());
    		System.out.println(strings);
    
    		Set<String> set = list.stream().filter(x -> x.length() > 0).collect(Collectors.toSet());
    		System.out.println(set);
    
    		String s = list.stream().filter(x -> x.length() > 0).collect(Collectors.joining("+"));
    		System.out.println(s);
    	}

4、IntSummaryStatistics collect(Collectors.summarizingInt(String::length)):将stream转为可计算的数字类型

*  getMax()
 *  getAverage()
 *  getCount()
 *  getMin()
 *  getSum()

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "a", "abqwerc", "abc", "qWE", "c");
    		IntSummaryStatistics collect = list.stream().filter(x -> x.length() > 0)
    				.collect(Collectors.summarizingInt(String::length));
    		System.out.println(collect.getMax());
    	}

5、Match

Stream 有三个 match 方法，从语义上说：

*  allMatch：Stream 中全部元素符合传入的 predicate，返回 true
 *  anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
 *  noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "a", "abqwerc", "abc", "qWE", "c");
    		boolean noneMatch = list.stream().noneMatch("c"::equals);
    		boolean allMatch = list.stream().allMatch("c"::equals);
    		boolean anyMatch = list.stream().anyMatch("c"::equals);
    		System.out.println(
    				"noneMatch(没有任何一个匹配):" + noneMatch + "\nallMatch(所有都匹配):" + allMatch + "\nanyMatch(有一个匹配):" + anyMatch);
    	}

6、Reductions

reduce方法需要先了解java8中新增的Optional类型和lambda中的函数式接口BinaryOperator，理解了这两个之后才能比较好的去使用。

BinaryOperator代表接受两个T类型的参数，然后返回一个T类型的值

public static void main(String[] args) {
    		List<String> list = Arrays.asList("a", "a", "abc", "abc", "qWE", "c");
    		System.out.println(list.stream().reduce((x, y) -> x + y).orElse("aa"));
    	}

相当于一直迭代： “a”+“a” = “aa”, “aa”+“abc” =“aaabc” ……

7、grouping,partitioning

封装People 对象

public class People {
    	private String name;
    	private Integer id;
    	private Integer classId;
    
    	public People(String name, Integer id, Integer classId) {
    		this.name = name;
    		this.id = id;
    		this.classId = classId;
    	}
    // 省略get set
    }

groupingBy其实类似于SQL里的group by语句，不过groupingBy将返回的结果封装到 Collector<T, ?, Map<K, List>>，其中T是传入的参数类型，K是groupingBy的键。

public static void main(String[] args) {
    		Integer id = 0;
    		List<People> list = Arrays.asList(new People("a", ++id, 1), new People("b", ++id, 2), new People("c", ++id, 2),
    				new People("d", ++id, 3), new People("e", ++id, 3), new People("f", ++id, 3));
    
    		// select SUM(id) from People group by classId;
    		Map<Integer, List<People>> collect = list.stream().collect(Collectors.groupingBy(People::getClassId));
    		collect.forEach((K, V) -> {
    			System.out.println(K + " : " + V);
    			System.out.println(K + " : " + V.stream().collect(Collectors.summarizingInt(People::getId)).getSum());
    		});
    	}

输出结果：

1 : [People [name=a, id=1, classId=1]]
    1 : 1
    2 : [People [name=b, id=2, classId=2], People [name=c, id=3, classId=2]]
    2 : 5
    3 : [People [name=d, id=4, classId=3], People [name=e, id=5, classId=3], People [name=f, id=6, classId=3]]
    3 : 15

partitioningBy

partitioningBy根据判断条件是否满足将原本的流分为TRUE和FALSE映射的两个集合，返回的是Collector<T, ?, Map<Boolean, List>>，其中T是传入的参数类型。

public static void main(String[] args) {
    		Integer id = 0;
    		List<People> list = Arrays.asList(new People("a", ++id, 1), new People("b", ++id, 2), new People("c", ++id, 2),
    				new People("d", ++id, 3), new People("e", ++id, 3), new People("f", ++id, 3));
    
    		Map<Boolean, List<People>> collect = list.stream().collect(Collectors.partitioningBy(x -> x.getClassId() == 3));
    		System.out.println("TRUE: ");
    		collect.get(Boolean.TRUE).forEach(System.out::println);
    		System.out.println("FALSE: ");
    		collect.get(Boolean.FALSE).forEach(System.out::println);
    	}

输出结果：

TRUE: 
    People [name=d, id=4, classId=3]
    People [name=e, id=5, classId=3]
    People [name=f, id=6, classId=3]
    FALSE: 
    People [name=a, id=1, classId=1]
    People [name=b, id=2, classId=2]
    People [name=c, id=3, classId=2]

**（7）原始类型stream**

IntStream,LongStream,DoubleStream和对象stream的差异:

1.  toArray返回原始类型数组
2.  返回的是OptionalInt,OptionalLong,OptionalDouble而不是Option,相应的get变为getAsInt,getAsLong,getAsDouble
3.  定义了sum,average,max,min方法
4.  summaryStatistics调用返回的对应为IntSummaryStatistics,LongSummaryStatistics,DoubleSummaryStatistics

**如果本文对您有很大的帮助，还请点赞关注一下。**