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 ((t2) > 0) {
return true;
} else {
return false;
}
}
}
定义在非泛型类：
public class Generic {
public <T extends Compareble<? super T>> boolean getMax(T t1, T t2){
if ((t2) > 0) {
return true;
} else {
return false;
}
}
}
注：泛型使用时需要传入具体的参数类型。
lambda表达式和泛型函数式接口的结合
从小标题中小编特意强调泛型函数式接口，因为如果普通函数式接口中定义了泛型抽象方法，在我们使用lambda表达式时，idea会报错**“target method is generic”**，编译，会报“参数不匹配; 无法推断的函数接口描述符”，原因：函数式接口中定义的泛型方法时，接口必须要定义泛型。网上搜索发现，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 (list);
}
}
public class ClientDriverTest {
public static void main(String args[]) {
List<Integer> list = (1, 5, 0, -1, 6, 6).collect(());
SortManage sortManage = new SortManage();
List<Integer> sortedList = (list, (List<Integer> inilist) -> (inilist));
sortedList = (list, (List<Integer> inilist) -> (inilist));
sortedList = (list, (List<Integer> inilist) -> (inilist));
(sortedList);
}
}
public class Sort {
public static <T extends Comparable<? super T>> List<T> maoPaoSort(List<T> list) {
List<T> sortedList = list;
for (int i = () - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if ((j).compareTo((j + 1)) >= 0) {
T temp = (j);
(j, (j + 1));
(j + 1, temp);
}
}
}
return sortedList;
}
public static <T extends Comparable<? super T>> List<T> xuanzeSort(List<T> initlist) {
for (int i = () - 1; i >= 0; i--) {
int minindex = i;
for (int j = i; j < () - 1; j++) {
if ((j).compareTo((minindex)) < 0) {
minindex = j;
}
}
if (minindex != i) {
T temp = (minindex);
(minindex, (i));
(i, temp);
}
}
return initlist;
}
public static <T extends Comparable<? super T>> List<T> quickSort(List<T> list) {
List<T> sortedList = list;
if (() <= 1) {
return sortedList;
}
else {
int l = 0;
int h = () - 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 ((l).compareTo((h)) < 0 && l < h) {
while ((h).compareTo((m)) >= 0 && h > l) {
h--;
}
while ((l).compareTo((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 = (l1);
(l1, (l2));
(l2, temp);
}
}