JDK1.8新特性了解

浅浅的花香味﹌ 2022-06-06 07:30 221阅读 0赞

Jdk1.8特性之一：

Interface自带默认实现，先看例子

Jdk1.8中java.util.Comparator中184行：

default Comparator<T> reversed() {
            return Collections.reverseOrder(this);
        }

表面上更加混淆了接口和抽象类的界限，但本质上可以获得一个很清晰的信号，抽象类将慢慢成为历史，带默认实现的接口将成为未来的主流。

Jdk1.8特性之二：

Lambda表达式，使语法更简介。

先看下Jdk1.7和jdk1.8中java.util.Comparator声明：

1.7：

public interface Comparator<T>{}

1.8：

@FunctionalInterface
    public interface Comparator<T> {}

多了一个@FunctionalInterface注解，当接口只有一个未实现的方法时，使用该注解，该注解表示此接口是个函数接口。该注解不是必须的，但是一旦定义后编译期会做校验。

好，我们看一个例子，先看前6种写法，展现了Lambda的精简过程。

public class LambdaTest {
    	
    	public static void main(String[] args) {
    		List<String> names = Arrays.asList("A", "B", "C", "D");
    		
    		//Type 1
    		Comparator<String> myComparator = new Comparator<String>() {
    			@Override
    			public int compare(String o1, String o2) {
    				// TODO Auto-generated method stub
    				return 0;
    			}			
    		};
    		Collections.sort(names,myComparator);
    		
    		//Type 2
    		Collections.sort(names, new Comparator<String>() {
    			@Override
    			public int compare(String o1, String o2) {
    				// TODO Auto-generated method stub
    				return 0;
    			}			
    		});
    		
    		//Type 3
    		Collections.sort(names, (String a, String b) -> {return b.compareTo(a);} );
    		
    		//Type 4
    		Collections.sort(names, (String a, String b) -> b.compareTo(a) );
    		
    		//Type 5
    		Collections.sort(names, (a, b) -> b.compareTo(a));
    		
    		//Type 6
    		Collections.sort(names, (a, b) -> myComparator.compare(a, b));
    		
    		//Type7
    		Comparator<String> otherComparator = myComparator::compare;
    		Collections.sort(names,otherComparator);
    		
    		
    		for(int i=0;i<4;i++) {
    			System.out.println(names.get(i));
    		}
    	}
    	
    }

我们在jdk1.8之后尽量使用Lambda格式来写代码，什么场景下可以使用，应该怎么书写？我自己总结了一句话：

“如果某个方法入参中需要一个单一功能的接口，可以将该接口需要实现的方法以入参形式直接指向具体实现。”

单一功能的接口，首先必须是interface，其次这个interface只能有一个必须override的方法。

以入参形式，指的是(a,b)或者(String a,String b)，有没有类型无所谓，JVM自己会帮我们找。

指向，就是\->符号。

具体实现，具体的实现方法分两种，一种是自己实现例如\{return b.compareTo(a);\}或者b.compareTo(2)，一种是已有的实现myComparator.compare(a,b)。

再看Type7，对于FunctionalInterface接口声明时可以按照此语法直接将一个方法赋给它，可以是另一个对象的方法，也可以是另一个类的静态方法，注意右侧的方法没有参数，交给虚拟机去处理。

除开实例代码中的Comparator，原来JDK1.7中的Runnable、Callable等单一功能的函数接口都添加了@FunctionalInterface，在JDK1.8中还新加了一些函数接口：

这些接口都在java.util.fuction包下

Predicate<T>:  boolean test(T t);

做逻辑判断用的函数接口

Predicate<String> predicate = (s)-> s.length() > 0;

predicate.test("test");

predicate.negate().test("test");

Function<T, R>：R apply(Tt);

通过compose方法和andThen方法实现对一个参数进行链型的处理

FunctionTest 代码样例：

public class FunctionTest {
    	
    	public static void main(String[] args) {
    		Function<String,String> mainFunctionTrim = t -> t.trim(); //字符串处理
    		Function<Integer,Integer> mainFunctionAdd = t -> t+100;//数字加100
    		Function<String,Integer> mainFunctionChange = Integer::valueOf;//字符转化成数字
    		
    		int result1 = mainFunctionAdd
    			.compose(mainFunctionChange)
    				.compose(mainFunctionTrim)
    					.apply("  11  ");
    		
    		int result2 = mainFunctionTrim
    			.andThen(mainFunctionChange)
    				.andThen(mainFunctionAdd)
    					.apply("  11  ");
    		
    		System.out.println(result1); //111
    		System.out.println(result2); //111		
    	}
    }

Supplier<T>: T get();

字段名字供应商，是一个获取对象的场景，用于不需要任何入参构造对象的场景。

Supplier<Person>personSupplier = Person::new;

personSupplier.get();

Consumer<T>: void accept(Tt);

与Supplier正好相反，传入一个参数只消费，无返回，可用于无状态的动作，例如打印、记录日志等。

** **

Jdk1.8 特性之三：

List的**Stream处理。**

**Stream是个接口，以流的方式对List进行各种处理。**

**Filter过滤**：

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

Sort**排序：**

myList
        	.stream()
    	.sorted()
        	.filter((s) -> s.startsWith("abc"))
        	.forEach(System.out::println);

Map转化：

myList
        	.stream()
        	.map((s) -> String::toUpperCase
        	.forEach(System.out::println);

Match匹配,return boolean

myList
        		.stream()
        		. anyMatch ((s) -> s.startsWith("abc"))
    	myList
        		.stream()
        		. allMatch ((s) -> s.startsWith("abc"))
    	myList
        		.stream()
        		.noneMatch((s) -> s.startsWith("abc"))

Count计数，return long

myList
        		.stream()
        		.filter((s) -> s.startsWith("abc"))
    		.count();

Stream还可以支持多线程：

myList
        		.parallelStream()
        		.filter((s) -> s.startsWith("abc"))
    		.count();

Jdk1.8特性之四：

Map虽然不支持Stream，不过也扩展了一些实用的方法。

1,不覆盖put

default V putIfAbsent(K key, V value) {
            V v = get(key);
            if (v == null) {
                v = put(key, value);
            }
    
            return v;
    }

2,forEach处理

map.forEach((k, v) ->System.out.println(v));

3,删除一条全匹配key-value数据,

map.remove(k, v);

4,getOrDefault

Map.get(key,”not found”);

最大的变化还是前两个特性：接口默认方法和Lambda语法，还有一些扩展和优化类的需要慢慢看API和源码了。