JAVA8新特性--lambda表达式结合泛型的简单应用

JAVA8新特性–lambda表达式结合泛型的简单应用

本篇文章将介绍小编对java8新特性–lambda表达式的理解，以及java5后引入的泛型的理解。随后介绍将lambda表达式结合泛型的实践。

lambda表达式

小编查阅了很多博客，总结一下：
1、lambda表达式最初java并不会支持，其实现形式与C++的指针相似；
2、java8之前的版本采用匿名内部类来代替lambda表达式；

知识延伸：
匿名内部类：java中有些类只用一次，因此java提出了匿名内部类new一次使用完了就不再使用。匿名内部类实现一个接口或继承一个类，可以继承或覆写父类的方法。由于匿名内部类不能直接被外部使用，所以只能继承或覆写父类方法，即使实现其他方法，只能是在继承或覆写父类方法中去调用。

lambda表达式的定义及使用：
lambda表达式语法: 参数 -> 具体的实现
函数式接口的方法叫做函数描述符,lambda表达式的参数和实现必须和函数描述符的参数和返回值一一对应；
lambda表达式的简单应用，小编在此不做过多介绍，此类博客很多。

泛型

泛型的使用非常广泛，小编了解的程度并不深入，基本理解：泛型可以在类、方法、接口中使用，泛型最重要的是定义，我们在创建一个泛型类、泛型接口、泛型方法时，类与接口名后要定义泛型，泛型方法在定义返回类型时要定义泛型。
eg:
泛型类：

public class Generic<T>{ 
	// 1、由于泛型类在声明时已定义了泛型，因此该类中的泛型方法不需要定义泛型
	// 2、泛型类中可以定义非泛型方法
}

泛型接口：

public interface Generic<T> {
	// 泛型接口与泛型类的定义和使用基本相同，同上。
}

泛型方法：

// 泛型方法可以定义在泛型类中，也可以定义在非泛型类中
定义在泛型类：
public class Generic<T>{ 
	public boolean  getMax(T t1, T t2){
		if (t1.compareTo(t2) > 0) {
			return true;
		} else {
			return false;
		}
	}
}

定义在非泛型类：

public class Generic {
	public <T extends Compareble<? super T>> boolean  getMax(T t1, T t2){
		if (t1.compareTo(t2) > 0) {
			return true;
		} else {
			return false;
		}
	}
}

注：泛型使用时需要传入具体的参数类型。

lambda表达式和泛型函数式接口的结合

从小标题中小编特意强调泛型函数式接口，因为如果普通函数式接口中定义了泛型抽象方法，在我们使用lambda表达式时，idea会报错**“target method is generic”**，编译，会报“参数不匹配; 无法推断lambda.SortInterface的函数接口描述符”，原因：函数式接口中定义的泛型方法时，接口必须要定义泛型。网上搜索发现，java中自带支持lambda表达式的函数式接口，方法为泛型其接口一定定义了泛型。不要纠结为什么，这就是新特性的规则，规则这东西适应了就好，毕竟我们不是定规则的人。

public interface SortInterface<T> { // 定义泛型
    List<T> sort(List<T> list);
}

public class SortManage {
    public <T extends Comparable<? super T>> List<T> getSortedList(List<T> list, SortInterface<T> sortInterface) {
        return sortInterface.sort(list);
    }
}

public class ClientDriverTest {
    public static void main(String args[]) {
        List<Integer> list = Stream.of(1, 5, 0, -1, 6, 6).collect(Collectors.toList());
        SortManage sortManage = new SortManage();
        List<Integer> sortedList = sortManage.getSortedList(list, (List<Integer> inilist) -> Sort.xuanzeSort(inilist));

        sortedList = sortManage.getSortedList(list, (List<Integer> inilist) -> Sort.maoPaoSort(inilist));

        sortedList = sortManage.getSortedList(list, (List<Integer> inilist) -> Sort.quickSort(inilist));


        System.out.println(sortedList);
    }
}

public class Sort {
    public static <T extends Comparable<? super T>> List<T> maoPaoSort(List<T> list) {
        List<T> sortedList = list;

        for (int i = sortedList.size() - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (sortedList.get(j).compareTo(sortedList.get(j + 1)) >= 0) {
                    T temp = sortedList.get(j);
                    sortedList.set(j, sortedList.get(j + 1));
                    sortedList.set(j + 1, temp);
                }
            }
        }

        return sortedList;
    }

    public static <T extends Comparable<? super T>> List<T> xuanzeSort(List<T> initlist) {
            for (int i = initlist.size() - 1; i >= 0; i--) {
                int minindex = i;
                for (int j = i; j < initlist.size() - 1; j++) {
                    if (initlist.get(j).compareTo(initlist.get(minindex)) < 0) {
                        minindex = j;
                    }
                }
                if (minindex != i) {
                    T temp = initlist.get(minindex);
                    initlist.set(minindex, initlist.get(i));
                    initlist.set(i, temp);
                }
            }

            return initlist;
    }

    public static <T extends Comparable<? super T>> List<T> quickSort(List<T> list) {
        List<T> sortedList = list;

        if (sortedList.size() <= 1) {
            return sortedList;
        }
        else {
            int l = 0;
            int h = sortedList.size() - 1;
            quickSort(sortedList, l, h);
        }

        return sortedList;
    }

    private static <T extends Comparable<? super T>> void quickSort(List<T> list, int l, int h) {

        if (l <= h) {
            return;
        }
        int m = l;

        while (list.get(l).compareTo(list.get(h)) < 0 && l < h) {
            while (list.get(h).compareTo(list.get(m)) >= 0 && h > l) {
                h--;
            }
            while (list.get(l).compareTo(list.get(m)) <= 0 && l < h) {
                l++;
            }
            swap(list, l, h);
        }
        swap(list, m, l);
        m = l;

        quickSort(list, l, m -1);
        quickSort(list, m + 1, h);
    }

    public static <T extends Comparable<? super T>> void swap(List<T> list, int l1, int l2) {
        T temp = list.get(l1);
        list.set(l1, list.get(l2));
        list.set(l2, temp);
    }

}