JAVA泛型模拟scala实现自定义ArrayList

泛型就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），
然后在使用/调用时传入具体的类型
操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

 

以下实例通过泛型，灵活的实现了类似scala中集合的map，reduce方法，并可以链式编程

Function1：一个入参的泛型接口，例如map()，filter()

//泛型接口
public interface Function1<T, R> {

    R call(T t);

}

Function2：两个入参的泛型接口，例如reduce()

//泛型接口
public interface Function2<E> {

    E call(E elem,E sum);

}

MyList：自定义List

import java.util.ArrayList;

//泛型类
public class MyList<E> extends ArrayList<E> {

    //泛型方法  （只有在public修饰符和返回值之间用了泛型的才是泛型方法，指定后，该方法内可以使用该泛型）
    public <R> MyList<R> map(Function1<E, R> fun){
        MyList<R> myList = new MyList<>();
        for (E e : this) {
            R res = fun.call(e);
            myList.add(res);
        }
        return myList;
    }

    //这个不是泛型方法，泛型在引用时指定，可以是泛型类中已经定义的，也可以是具体的类
    public MyList<E> filter(Function1<E,Boolean> fun){
        MyList<E> myList = new MyList<>();
        for(E elem : this){
            Boolean flag = fun.call(elem);
            if(flag){
                myList.add(elem);
            }
        }
        return myList;
    }

    //这个也不是泛型方法
    public E reduce(Function2<E> fun){
        E sum = null;
        boolean isFirst = true;
        for (E elem : this) {
            if(isFirst){
               sum =  elem;
               isFirst = false;
            }else {
                sum = fun.call(elem,sum);
            }
        }
        return sum;
    }

}

测试：

public class MyTest {

    public static void main(String[] args) {

        MyList<String> myList = new MyList<>();
        myList.add("aaaa");
        myList.add("bbbb");
        myList.add("cccc");
        myList.add("accc");

        String res = myList.filter(x -> x.contains("a")).map(x -> x.toUpperCase()).reduce((x, y) -> x + y);
        System.out.println(res);
    }
}

输出：