lambda表达式，增强for，collection工具，可变参

1.lambda

1.定义：

lambda表达式就是简单的匿名内部类，实现接口中只能有一个抽象方法，可以有多个其他方法。

2.特点：

Lambda表达式只能为函数式接口创建实例(即只能有一个抽象方法)
Lambda表达式的代码块不允许调用接口中的默认(default)方法

3.基本语法：

(参数)->表达式 或 (参数)->{方法体;}

4.例子

1.基本

interface InterA{
	public void showA();
}
interface InterB{
	public void showB(int a);
}
interface InterC{
	public void showC(int a,int b);
}
interface InterD{
	public int showD(int a,int b);
}
@FunctionalInterface
interface InterE{
	public int showD(int a,int b)
}

在main方法中
          //1.无参的
		InterA aa = ()->System.out.println("没有参数");
		aa.showA();
		//2.一个参数的
		InterB bb = (ib)->System.out.println("一个参数:"+ib);
		bb.showB(5);
		//3.两个参数的
		InterC cc = (ia,ib)->System.out.println("两个参数:"+" ia:"+ia+"   ib:"+ib);
		cc.showC(4, 5);
		//4.返回值
		InterD dd = (i,j)->i+j;
		int value1 = dd.showD(4, 7);
		System.out.println(value1);
		
	//5.lambda表达式作为参数
	fun2(
			new InterC() {public void showC(int a, int b) {}}
		);
	fun2((i,j)->System.out.println("lambda表达式作为参数"+" i:"+i));
	
	//7.lambda表达式中变量的使用（和匿名内部类差不多）
	String value11 = "hello world";
	InterA aaa = ()->{
		System.out.println(value11);
		//value11是final类型的是一个常量,值是不能改变的
		//value11 = "haha";	};
	aaa.showA();

2.引用方法或构造

//* 1.引用类方法
interface Converter{
	//将字符串转换成整数
	Integer convert(String value);
}
class Test1{
	public static void fun1() {
		//原来的方法
		Converter converter = value->Integer.valueOf(value);
		Integer v1 = converter.convert("222");
	//简化
	//引用类方法
	//通过::实现,这里会自动将lambda表达式方法的参数全部传递给当前的方法
	Converter converter2 = Integer::valueOf;
	Integer v2 = converter2.convert("333");
	System.out.println(v2);
}

}
//* 2.引用特定对象的实例方法
interface IA{
	public void show(String message);
}
class A{
	public void play(String i) {
		System.out.println("这里是A的方法play"+"  i:"+i);
	}
}
class Test2{
	public static void fun2() {
		//原来
		IA ia = message->new A().play(message);
		ia.show("hello");
		//简化
		IA ia2 = new A()::play;
		ia2.show("world");
	}
}
//* 3.引用某类对象的实例方法
interface IB{
	String subString(String string,int stat,int end);
}
class Test3{
	public static void fun3() {
		//原来
		IB ib = (string,stat,end)->string.substring(stat, end);
		String sub1 = ib.subString("hello world", 2, 4);
		System.out.println(sub1);
		//简化
		 //函数式接口中被实现方法的第一个参数作为调用者,后面的参数全部传递给该方法
		IB ib2 = String::substring;
		String sub2 = ib2.subString("class is over", 2, 5);
		System.out.println(sub2);
	}
}
//* 4.引用构造方法
interface IC{
	Object show(String name,int age);
}
class Person{
	String name;
	int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

}
class Test4{
	public static void fun4() {
		IC ic = (name,age)->new Person(name, age);
		Object per = ic.show("bing", 19);
		System.out.println(per);
		

	//简化 
	//构造方法引用代替lambda表达式,函数式接口中被实现方法的全部参数传该构造方法作为参数
	IC ic2 = Person::new;
	Object per1 = ic2.show("chen", 10);
	System.out.println(per1);
}

}

3.实际使用

//多线程
		new Thread(new Runnable() {
			public void run() {
				System.out.println("通过匿名内部类创建任务");
			}
		}).start();
		//通过lambda表达式
		new Thread(()->System.out.println("通过lambda表达式创建任务")).start();
		//排序--使用Collections
//		Collections.sort(list, new Comparator<String>() {
//			public int compare(String o1, String o2) {
//				return o1.compareTo(o2);
//			}
//		});
		

```
	//使用lambda表达式
	Collections.sort(list, (o1,o2)->o1.compareTo(o2));
	System.out.println(list);
	
	//动态代理
	Inter inter = new DaHuang();
	Proxy.newProxyInstance(inter.getClass().getClassLoader(), new Class[] {Inter.class}, new InvocationHandler() {
		
		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			System.out.println("洗手");
			Object object = method.invoke(inter, args);
			return object;
		}
	});
	//lambda表达式
	Proxy.newProxyInstance(inter.getClass().getClassLoader(), new Class[] {Inter.class},(proxy,method,arg)->{
		System.out.println("洗手");
		Object object = method.invoke(inter, arg);
		return object;
	});
```

2.增强for

1.例子

List<String>  list;

for (String string : list) {
			System.out.println(string);
		}

3.collection工具类

//使用Collections排序
		//第一种排序:默认按照字典进行排序
		//注意:要想list中的元素可以按照字典排序,元素必须实现Comparable接口
		Collections.sort(list);
		
	//按照从短到长排序
	//使用比较器
	ComStrWithLength1 comStrWithLength = new ComStrWithLength1();
	Collections.sort(list, comStrWithLength);
	
	//倒叙字典排序
	Collections.reverse(list);
	
	//求最大值
	String max = Collections.max(list, comStrWithLength);

4.可变参

//1.构成:数据类型+...    实际上就是数据类型[]  即:int[]
	public static int sum1(int... a) {
		int sum = 0;
		for (int i = 0; i < a.length; i++) {
			sum+=a[i];
		}
		return sum;
	}

//2.当包括可变参数在内有多个参数时,可变参数必须放在最后面,并且一个方法中最多只能有一个可变参数
	public static int sum2(float b,int... a) {
		int sum = 0;
		for (int i = 0; i < a.length; i++) {
			sum+=a[i];
		}
		return sum;
	}
	//3.当可变参数的方法与固定参数的方法是重载关系时,调用的顺序,固定参数的优先于可变参数的.
	public static int sum3(int a, int b) {
		System.out.println("a");
		int sum = 0;
		return sum;
	}
	public static int sum3(int... a) {
		System.out.println("b");
		int sum = 0;
		return sum;
	}