Java8新特性枚举&注解&lambda表达式

枚举

1.概述

枚举是指将变量的值一一列出来，而且变量的值只限于列举出来的值的范围内。比如：一周只有7天。

2.枚举的基础代码

package com.darksnow.enums;

public enum Direction {
	FRONT,
	BEHIND,
	LEFT,
	RIGHT;
}


//上述枚举代码大概会翻译成下面这个样子
//public final class Direction extends Enum<Direction>{
//	
//	
//	 public static final Direction FRONT;
//	 public static final Direction BEHIND;
//	 public static final Direction LEFT;
//	 public static final Direction RIGHT;
//	 private static final Direction[] $VALUES;
//	 
//	 public static Direction valueOf(String name) {
//		 return Enum.valueOf(Direction.class,name)
//	 }
//	 
//	 public static Direction[] values() {
//		 return $VALUES.clone();
//	 }
//	 
//	 static {
//		 FRONT = new Direction();
//		 BEHIND = new Direction();
//		 LEFT = new Direction();
//		 RIGHT = new Direction();
//		 $VALUES = new Direction[] {FRONT,BEHIND,LEFT,RIGHT};
//	 }
//}

3.枚举代码演示

package com.darksnow.enums;

public enum Direction {
	FRONT("前") {
		@Override
		public void show() {
			System.out.println("这个是前~");
		}
	},
	BEHIND("后") {
		@Override
		public void show() {
			System.out.println("这个是后~");
		}
	},
	LEFT("左") {
		@Override
		public void show() {
			System.out.println("这个是左~");
		}
	},
	RIGHT("右") {
		@Override
		public void show() {
			System.out.println("这个是右~");
		}
	};
	
	private String name;
	
	private Direction(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public abstract void show();
}

package com.darksnow.enums;

public class EnumTest {
	public static void main(String[] args) {
		System.out.println(Direction.BEHIND); //BEHIND，底层翻译后本质上是一个本类对象，但是走了toString
		System.out.println(Direction.BEHIND.getName()); //后
		Direction.BEHIND.show(); //这个是后~
	}
}

4.枚举注意事项

1.定义枚举类要用关键字enum
2.所有枚举类都是Enum的子类
3.枚举类的第一行上必须是枚举项，最后一个枚举项后面的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不可能省略，建议不要去省略。
4.枚举项的命名全字母大写，因为底层本质上是一个常量。
5.枚举类可以有构造函数，但是必须是被private修饰的，它默认的也是private的
6.枚举类也可以有抽象方法，但是枚举项必须重写该抽象方法
7.枚举可以在switch语句中使用
例子：
public class EnumTest {
	public static void main(String[] args) {
		Direction d = Direction.BEHIND;
		
		switch(d) {
			case FRONT:
				System.out.println("匹配到了前");
				break;
			case BEHIND:
				System.out.println("匹配到了后");
				break;
			case LEFT:
				System.out.println("匹配到了左");
				break;	
		}
	}
}

5.Enum类的方法

package com.darksnow.enums;

public class EnumTest {
	public static void main(String[] args) {
		
		//每个枚举项都有一个默认的编号，从0开始
		Direction direction1 = Direction.FRONT;
		Direction direction2 = Direction.BEHIND;
		Direction direction3 = Direction.LEFT;
		Direction direction4 = Direction.RIGHT;
		
		//public final int compareTo(E o)
		System.out.println(direction1.compareTo(direction1)); //0
		System.out.println(direction1.compareTo(direction4)); //-3
		System.out.println(direction4.compareTo(direction1)); //3
		System.out.println("--------------------------");
		
		//public final String name()  得到的就是枚举项常量名
		System.out.println(direction1.name());
		System.out.println(direction2.name());
		System.out.println(direction3.name());
		System.out.println(direction4.name());
		System.out.println("--------------------------");
		
		//public final int ordinal() 返回此枚举常数的序数（其枚举声明中的位置，其中初始常数的序数为零）。 
		System.out.println(direction1.ordinal());
		System.out.println(direction2.ordinal());
		System.out.println(direction3.ordinal());
		System.out.println(direction4.ordinal());
		System.out.println("--------------------------");
		
		//public String toString()  得到的就是枚举项常量名
		System.out.println(direction1.toString());
		System.out.println(direction2.toString());
		System.out.println(direction3.toString());
		System.out.println(direction4.toString());
		System.out.println("--------------------------");
		
		// public static E[] values() 此方法虽然在JDK文档中招不到，但是每个枚举类都有此方法，它可以用于遍历枚举类的所有枚举值
		Direction[] values = Direction.values();
		for(Direction d : values) {
			System.out.println(d);
			System.out.println(d.getName());
		}
		
		//public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name)
		Direction d = Enum.valueOf(Direction.class, "BEHIND");
	}
}

注解

1.概念

注解(Annotation)，JDK5.0出现的。
作用：
	它是对程序作出结实，可以被其他程序读取。
格式：
	以"@注解名"格式存在的，注解也是可以有参数的
在什么地方使用：
	可以在package，class，method，field上使用

2.内置注解

内置注解就是jdk本身定义好的除元注解以外的注解

@Override，此注解用于修饰方法，表示一个方法将重写父类的另外一个方法
	
@Deprecated，此注解用于修饰方法，属性，类，表示不推荐使用(弃用)

@SuppressWarnings，用于压制黄色警告信息

3.元注解

元注解的作用是负责注解其他注解，Java中定义了4个元注解

@Target：用于表述注解的使用范围，说白了就是描述注解能够用在什么地方。
@Retention：表示需要在什么级别保存该注解信息，就是描述注解的生命周期(存活时长)
				SOURCE(源代码级别) < CLASS(类级别) < RUNTIME(运行级别) 一般用RUNTIME，其他的你不管。
@Documented：表示注解将会被包含在JavaDoc中
@Inherited：表示子类可以继承父类中的该注解

package com.darksnow.enums;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//TYPE（在此代码中表示可以在类上，接口上，枚举上，注解上使用MyAnnotation注解）
//METHOD(表示可以在方法上使用MyAnnotation注解)
//FIELD(表示可以在成员变量上使用MyAnnotation注解)
//CONSTRUCTOR(表示可以在构造函数上使用MyAnnotation注解)
//PACKAGE(表示可以在包上使用MyAnnotation注解)
@Target(value = {ElementType.TYPE,ElementType.METHOD}) //该注解只能用在类上或者方法上
@Retention(RetentionPolicy.RUNTIME) //基本上你可以把它看成固定写法，其他两个属性不需要你关系
@Documented //固定写法
public @interface MyAnnotation {

}

package com.darksnow.enums;

@MyAnnotation
public class UseAnnotation {
	
	@MyAnnotation
	public void test() {
		
	}
}

4.自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口

注意点：
	(1)@interface用来声明一个注解，格式：
		public @interface 注解名{ 
			定义的内容 
		}
	(2)注解中的每一个方法实际上是声明了一个配置参数
    (3)方法的名称就是参数的名称
    (4)方法返回值类型就是参数的类型(返回值类型只能是基本数据类型，Class，String，enum，数组)
    (5)default可以用来表示当前注解参数的默认值，当存在默认的时候，你可以不配置该属性
    (6)如果某个注解只有一个参数，那么参数名一般起名为value
    (7)注解的参数必须要有值(可以用default定义默认值，也可以在使用该注解时指定值)，我们定义注解参数的时候，经常用空字符
       串，0作为默认值
--------------------------------------------------------------------       
package com.darksnow.enums;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD})   
public @interface MyAnnotation {
	
	String value() default "";
	
	//这是注解的参数：参数类型(String) + 参数名(name)
	//default可以用来表示当前注解参数的默认值，当存在默认的时候，你可以不配置该属性
	String name() default "默认值";
	
	int[] numbers();
}

class AnnotationTest{
	//注解可以赋值，如果注解中的参数没有默认值，就必须要赋值，否则会报错！
	@MyAnnotation(numbers = {1,2,3,4,5,6})
	public void test() {
		
	}
}       

5.自定义注解案例

package com.darksnow.enums;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;


//注解一般是结合反射来用的(注解起到标注的作用，反射起到注解功能实现的作用)
//MyAnnotation注解用于给成员变量进行赋值
@Documented
@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = {ElementType.FIELD})   
public @interface MyAnnotation {
	String value();
}

//否是开启MyAnnotation这个注解的功能，true代表开启，false代表不开启
@Documented
@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE})
@interface IsEnableMyAnnotation{
	boolean value() default false;
}

@IsEnableMyAnnotation(value = true)
class Student{
	@MyAnnotation("DarkSnow")
	private String name;
	private String address;
	
	@Override
	public String toString() {
		return "Student [name=" + name + ", address=" + address + "]";
	}
}

class Test{
	public static void main(String[] args) throws Exception {
		Student s = new Student();
		
		//获取字节码文件对象
		Class<? extends Student> c = s.getClass();
		
		//指定获取类上的注解
		IsEnableMyAnnotation annotation = c.getAnnotation(IsEnableMyAnnotation.class);
		//获取指定注解的值
		boolean isEnableMyAnnotationValue = annotation.value();
		
		//获取成员变量的Field对象
		Field name = c.getDeclaredField("name");
		//暴力访问
		name.setAccessible(true);
		//指定获取成员变量上的注解
		MyAnnotation myAnnotation = name.getAnnotation(MyAnnotation.class);
		//获取指定注解的值
		String myAnnotationValue = myAnnotation.value();
		
		if(isEnableMyAnnotationValue) {  //@IsEnableMyAnnotation值为true才能够给成员赋值
			name.set(s, myAnnotationValue); //给成员赋值
		}
		
		System.out.println(s);
	}
}

Lambda表达式

1.案例

package com.darksnow.lambda;

/*
 * Lambda表达式是JDK1.8出现的
 * 
 * ()：代表接口中的方法
 * ->：指向方法的方法体
 * {}：方法体内的内容都包含于此
 * 
 * 对于接口使用Lambda表达式，接口只能有一个抽象方法
 */
public class LambdaDemo {
	
	public interface AddNumber{
		int add(int x,int y);
	}
	
	public static void useAddNumber(AddNumber addNumber) {
		int sum = addNumber.add(6, 8);
		System.out.println(sum);
	}
	
	public interface Test{
		void run(String str);
	}
	
	public static void useTest(Test test) {
		test.run("代码运行了~");
	}
	
	public static void main(String[] args) {
		useAddNumber(new AddNumber() {
			@Override
			public int add(int x, int y) {
				return x + y;
			}
		});
		
		//我们知道useAddNumber需要传入一个AddNumber接口，这是明确的信息，所以可以省略
		//我们知道AddNumber接口中只有一个抽象方法，这又是明确的信息，所以方法名可以省略
		useAddNumber((int x,int y) -> {
			return x + y;
		});
		
		//在接口中唯一的方法add，它的参数列表的数据类型在接口中已经明确，所以数据类型可以省略。
		//但是要注意，数据类型要不都省略，要不都不省略
		useAddNumber((x,y) -> {
			return x + y;
		});
		
		//如果代码块({})中的语句只有一条，那么省略花括号和这一条代码末尾的分号，如果有return，那么也要省略
		useAddNumber((x,y) -> x + y);
		
		System.out.println("-----------");
		
		useTest((String str) -> {
			System.out.println(str);
		});
		
		//如果覆盖的抽象方法的参数只有一个，那么小括号可以省略
		useTest(str -> {
			System.out.println(str);
		});
		
		useTest(str -> System.out.println(str));
	}
}

2.Lambda表达式与匿名内部类的区别

需要的类型不同
	匿名内部类：可以是接口，也可以是抽象类，还可以是具体的类
	Lambda表达式：只能是接口
	
实现的原理不同
	匿名内部类：编译之后，会产生一个字节码文件
	Lambda表达式：编译之后，不会产生字节码文件，对应的字节码文件会在运行时被动态生成
	
使用的限制不同
	接口中只能有一个抽象方法，匿名内部类和Lambda都能使用
	接口中有多个抽象方法，Lambda表达式不能使用，但是可以使用匿名内部类

3.引用符

3.1 引用类方法

package com.darksnow.lambda;

interface Converter{
	int stringConverterInt(String number);
}

/*
 * ::  引用运算符
 * 当Lambda表达式被类方法(静态方法)替代的时候，它的形式参数全部传递给静态方法作为参数，那么可以省略为“类名::静态方法”
 * 
 * 格式：
 * 		类名::静态方法
 */
public class LambdaDemo {
	
	public static void useStringConverterInt(Converter converter) {
		int number = converter.stringConverterInt("8");
		System.out.println(number);
	}
	
	public static void main(String[] args) {
		//匿名内部类写法，调用useStringConverterInt方法
		useStringConverterInt(new Converter() {
			@Override
			public int stringConverterInt(String number) {
				return Integer.parseInt(number);
			}
		});
		
		//Lambda表达式写法
		useStringConverterInt(number -> Integer.parseInt(number));
		
		//化简
		useStringConverterInt(Integer::parseInt);
	}
}

3.2 引用对象的实例方法

package com.darksnow.lambda;


/*
 * 当Lambda表达式被实例方法(对象方法，非静态)替代的时候，它的形式参数全部传递给实例方法作为参数，那么可以省略为“对象::成员方法”
 * 
 * 格式：
 * 		对象::成员方法
 */
class PrintString{
	//传入一个字符串，将其都变为大写，并打印
	public void printUpper(String str) {
		String result = str.toUpperCase();
		System.out.println(result);
	}
}

interface Printer{
	void printUpperCase(String str);
}

public class LambdaDemo {
	
	public static void usePrinter(Printer p) {
		p.printUpperCase("darksnow");
	}
	
	public static void main(String[] args) {
		
		PrintString printString = new PrintString();
		
		//匿名内部类写法
		usePrinter(new Printer() {
			@Override
			public void printUpperCase(String str) {
				printString.printUpper(str);
			}
		});
		
		//Lambda表达式写法
		usePrinter(str -> printString.printUpper(str));
		
		//化简
		usePrinter(printString::printUpper);
	}
}

3.3 引用类的实例方法

package com.darksnow.lambda;


interface MyString{
	String mySubString(String str, int start, int end);
}

/*
 * 当Lambda表达式被类的实例方法(对象方法，非静态)替代的时候，第一个参数作为调用者，后面的形式参数全部传递给实例方法作为参数，那么可以省略为“类名::实例方法”
 * 格式：
 * 		类名::实例方法
 */
public class LambdaDemo {
	
	public static void useMySubString(MyString myString) {
		String result = myString.mySubString("darksnow", 0, 4);
		System.out.println(result);
	}
	
	public static void main(String[] args) {
		//用匿名内部类的方式
		useMySubString(new MyString() {
			@Override
			public String mySubString(String str, int start, int end) {
				return str.substring(start,end);
			}
		});
		
		//Lambda表达式的方法
		useMySubString( (str, start, end) -> str.substring(start,end));
		
		//化简
		useMySubString(String :: substring);
	}
}

4.函数式接口

函数式接口是为了Lambda表达式服务的

是接口，且内部只有一个抽象方法，那么这个接口就为函数式接口(接口上有一个注解：@FunctionalInterface)
往深层次说，实现接口需要覆盖抽象方法，而且接口中有多个抽象方法，但只有一个抽象方法需要被覆盖

JDK1.8起，提供了一些函数式接口：Supplier接口，Consumer接口，Predicate接口，Function接口

Stream流

它跟I/O流没有半毛线关系，不具备I/O流的性质，Stream是于集合的。

1.Stream流常见的生成方式

package com.darksnow.stream;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.stream.Stream;

public class StreamDemo {
	public static void main(String[] args) {
		Stream<String> stream1 = new ArrayList<String>().stream();
		
		Stream<String> stream2 = new HashSet<String>().stream();
		
		Stream<String> stream3 = new HashMap<String,String>().keySet().stream();
		
		Stream<String> stream4 = new HashMap<String,String>().values().stream();
		
		Stream<Entry<String, String>> stream5 = new HashMap<String,String>().entrySet().stream();
		
		int[] arr = {1,3,5,7,9};
		Stream<int[]> stream6 = Stream.of(arr);
		Stream<Integer> stream7 = Stream.of(2,4,6,8,10);
	}
}

2.filter方法

package com.darksnow.stream;

import java.util.ArrayList;

/*
 * Stream<T> filter(Predicate<? super T> predicate)：根据条件进行集合数据的过滤
 * void forEach(Consumer<? super T> action)：用于遍历集合元素
 */
public class StreamDemo {
	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("明月");

		//需求1：打印集合中以小字开头的元素
		list.stream().filter(element -> element.startsWith("小")).forEach(System.out::println);
		System.out.println("-----------------------");
		
		//需求2：打印集合中长度为3的元素
		list.stream().filter(element -> element.length() == 3).forEach(System.out::println);
		System.out.println("-----------------------");
		
		//需求3：打印集合以小字开头并且长度为2的元素
		list.stream().filter(element -> element.startsWith("小"))
		.filter(element -> element.length() == 2)
		.forEach(System.out::println);
	}
}

3.limit&skip方法

package com.darksnow.stream;

import java.util.ArrayList;

/*
 * Stream<T> limit(long maxSize)：取集合数据中的前N项
 * Stream<T> skip(long n)：跳过前N项取集合中的数据
 */
public class StreamDemo {
	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("明月");

		//需求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);
	}
}

4.concat&distinct方法

package com.darksnow.stream;

import java.util.ArrayList;
import java.util.stream.Stream;

/*
 * static <T> Stream<T> concat(Stream<? extends T> a,Stream<? extends T> b):用于合并两个Stream流
 * Stream<T> distinct():用于去除集合中重复的元素
 */
public class StreamDemo {
	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("明月");

		//需求1：取前4个元素组成一个Stream流
		Stream<String> s1 = list.stream().limit(4);
		
		//需求2：跳过2个元素组成一个Stream流
		Stream<String> s2 = list.stream().skip(2);
		
		//需求3：合并需求1和需求2得到的Stream流，并把结果打印在控制台
//		Stream.concat(s1, s2).forEach(System.out::println);
//		System.out.println("-----------------------");
		
		//需求4：合并需求1和需求2得到的Stream流，并把结果打印在控制台上，但是要求打印出来的结果不能重复
		Stream.concat(s1, s2).distinct().forEach(System.out::println);
	}
}

5.map&mapToInt方法

package com.darksnow.stream;

import java.util.ArrayList;

/*
 * <R> Stream<R> map(Function<? super T,? extends R> mapper)
 * IntStream mapToInt(ToIntFunction<? super T> mapper)
 */
public class StreamDemo {
	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");
		
		//需求：将集合中的字符串数据转化为整数，并且打印在控制台
		//filter是先遍历出每个元素，再拿每个元素做条件判断，以此来达到过滤数据效果，主要功能是过滤
		//map是先遍历出每个元素，再对每个元素进行操作(做一些转换，拼接等等的一些操作)，主要功能是将原来的元素进行了改变
		//list.stream().map(str -> Integer.parseInt(str)).forEach(System.out::println);
		list.stream().map(Integer::parseInt).forEach(System.out::println);
		
		System.out.println("------------------------");
		
		//需求：获取集合中所有元素之和，并且打印在控制台
		//mapToInt能够得到一个IntStream，在这个IntStram中可以通过sum方法对元素求和
		int result = list.stream().mapToInt(Integer::parseInt).sum();
		System.out.println(result);
	}
}

6.Stream流终结操作方法(count&forEach)

package com.darksnow.stream;

import java.util.ArrayList;
import java.util.LinkedList;

/*
 * Stream流终结操作方法
 * 		执行完这些方法后，Stream流就不能再执行其他操作了
 * 
 * 常见的：
 * 		void forEach(Consumer<? super T> action)
 * 		long count() 返回流中元素的个数
 */
public class StreamDemo {
	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.stream().forEach(System.out::println);
		System.out.println("--------------------------");
		list.forEach(System.out::println);
		System.out.println("--------------------------");
		
		//统计集合中以小字开头的元素的个数
		long count = list.stream().filter(str -> str.startsWith("小")).count();
		System.out.println(count);
	}
}

7.sorted方法

package com.darksnow.stream;

import java.util.TreeSet;

/*
 * Stream<T> sorted()：根据自然顺序排序，将元素进行排序
 * Stream<T> sorted(Comparator<? super T> comparator)：根据条件进行排序
 */
public class StreamDemo {
	public static void main(String[] args) {
		TreeSet<String> list = new TreeSet<String>();
		list.add("mingyue");
		list.add("xiaoyu");
		list.add("kunkun");
		list.add("dahua");
		list.add("mingyue");
		list.add("liwei");
		
		//需求：按照字母顺序把元素打印在控制台
		list.stream().sorted().forEach(System.out::println);
		System.out.println("--------------------------------------");
		
		//需求：按照字符串长度顺序把元素打印在控制台
		list.stream().sorted((o1,o2) -> o1.length()-o2.length()).forEach(System.out::println);
	}
}

8.Stream流的收集操作

package com.darksnow.stream;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/*
 * <R, A> R collect(Collector<? super T, A, R> collector);  
 * 先通过集合或者数组，变为一个Stream流(可以在Stream中对数据进行一系列的操作，比如过滤等)，collect可以将操作完之后的Stream流转成一个List，Set或者Map
 */
public class StreamDemo {
	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.获得名字为三个字的流
		Stream<String> listStream = list.stream().filter(str -> str.length() == 3);
		
		//2.将listStream流操作完成之后得到的数据收集到一个List集合中
		//List<String> names = listStream.collect(Collectors.toList());
		//System.out.println(names);
		
		Set<String> set = listStream.collect(Collectors.toSet());
		System.out.println(set);
		
		//将下面的String数组变成一个Map
		String[] strArr = {"阿伟,60","坂田,70","坤坤,80"};
		//将String数组变成一个Stream流
		Stream<String> strStream = Stream.of(strArr);
		//再将Stream流中的数据通过collect收集到Map集合中
		Map<String, String> map = strStream.collect(Collectors.toMap(str -> str.split(",")[0], str -> str.split(",")[1]));
		System.out.println(map);
	}
}

Lambda表达式案例

package com.darksnow.lambda;

/*
 * 根据下面的注释补全代码
 */
interface Inter{
	void test(String str);
}
public class LambdaDemo01 {
	
	public static void useTest(Inter inter) {
		inter.test("testing...");
	}
	
	public static void main(String[] args) {
		
		//下面Lambda表达式改为匿名内部类的写法为
		useTest(new Inter() {
			@Override
			public void test(String str) {
				System.out.println(str);
			}
		});
		
		//Lambda表达式调用方式
		useTest(str -> System.out.println(str));
		
		//上述Lambda表达式化简为
		useTest(System.out::println);
	}
}

package com.darksnow.lambda;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/*
 * 根据下面的注释补全代码
 */
public class LambdaDemo02 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("ddddd");
		list.add("aa");
		list.add("ccc");
		list.add("bbbb");
		
		System.out.println(list);
		
		Collections.sort(list,mySort());
		
		System.out.println(list);
	}
	
	public static Comparator<String> mySort(){
//		return new Comparator<String>() {
//			@Override
//			public int compare(String o1, String o2) {
//				return o1.length() - o2.length();
//			}
//		};
		
		
		//上面注释部分的代码改写成Lambda表达式写法
		return (o1,o2) -> o1.length() - o2.length();
	}
}

package com.darksnow.lambda;

/*
 * 根据下面的注释补全代码
 */
interface Calculator{
	int calculate(int a,int b);
}

class Compute{
	public int binaryOperate(int a, int b, Calculator calculator) {
		return calculator.calculate(a, b);
	}
}

public class LambdaDemo03 {
	public static void main(String[] args) {
		
		//以匿名内部类的方式 调用Compute类中的binaryOperate方法，可以使该方法计算“a的二次方” + “b的二次方”
		int result = new Compute().binaryOperate(2,2,new Calculator() {
			@Override
			public int calculate(int a, int b) {
				return a*a + b*b;
			}
		});
		System.out.println(result);
		
		//以Lambda表达式的方式 调用Compute类中的binaryOperate方法，可以使该方法计算“a的二次方” + “b的二次方”
		int rs = new Compute().binaryOperate(2,2,(a,b) -> a*a + b*b);
		System.out.println(rs);
		
	}
}

package com.darksnow.lambda;

public class Test {
	public static void main(String[] args) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName());
			}
		}).start();
		
		new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
	}
}