java lamdba表达式

lamdba支持将代码块作为方法的参数，为只有一个抽象方法的接口创建实例，这种接口被称为函数式接口(functional interface)

命令模式的演化

package com.zrun;

import org.junit.Test;

public class TestCommand {
	/**
	 * 命令模式的演化
	 */
	@Test
	public void test() {
		System.out.println("一.以下是自己写Command实现类");
		ProcessArray pa = new ProcessArray();
		int[] intArr = { 1, 8 };
		pa.process(intArr, new PrintCommand());
		pa.process(intArr, new AddCommand());

		System.out.println("二.以下是匿名内部类实现方式");
		pa.process(intArr, new Command() {

			@Override
			public void process(int[] target) {
				for (int item : target)
					System.out.println(item);
			}
		});
		pa.process(intArr, new Command() {

			@Override
			public void process(int[] target) {
				int cou = 0;
				for (int item : target) {
					cou += item;
				}
				System.out.println(cou);
			}

		});

		System.out.println("三.以下是lamdba表达式实现方式");
		pa.process(intArr, target -> {
			for (int item : target)
				System.out.println(item);
		});
		pa.process(intArr, target -> {
			int cou = 0;
			for (int item : target) {
				cou += item;
			}
			System.out.println(cou);
		});
	}
}

interface Command {
	void process(int[] target);
}

class ProcessArray {
	public void process(int[] target, Command cmd) {
		cmd.process(target);
	}
}

class PrintCommand implements Command {

	@Override
	public void process(int[] target) {
		for (int item : target)
			System.out.println(item);
	}
}

class AddCommand implements Command {

	@Override
	public void process(int[] target) {
		int cou = 0;
		for (int item : target) {
			cou += item;
		}
		System.out.println(cou);
	}

}

多线程简化实现

Runnable接口就是函数式接口

package com.zrun;

import org.junit.Test;

public class TestThread {
	@Test
	public void test() {
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("我是匿名内部类实现的多线程");
			}
		}).start();

		new Thread(() -> {
			System.out.println("我是lamdba表达式实现的多线程");
		}).start();
	}
}

数组排序

package com.zrun;

import java.util.Arrays;
import java.util.Comparator;

import org.junit.Test;

public class TestComparator {
	@Test
	public void test() {
		String[] arr = { "ych", "hll", "wh" };
		// 使用匿名内部类实现数组排序
		Arrays.sort(arr, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}
		});
		for (String s : arr)
			System.out.println(s);

		// 使用lamdba实现数组排序
		Arrays.sort(arr, (s1, s2) -> s2.compareTo(s1));
		for (String s : arr)
			System.out.println(s);
	}
}