记录:已有对象集合List<Employee> ,需要获取Employee的字段 name出现最多的字段值(即根据name字段分组->排序->取值);

public static void main(String[] args) {
        List<Employee> list = new ArrayList(){{
            add(new Employee(10,"李二"));
            add(new Employee(18,"王五"));
            add(new Employee(11, "赵四"));
            add(new Employee(21,"王五"));
        }};

        String name = list.stream()
                //判定字段非空
                .filter(r -> Objects.nonNull(r.getName()) && !r.getName().isEmpty())
                .collect(Collectors.groupingBy(Employee::getName))
                .values()
                .stream()
                .sorted((a, b) -> b.size() - a.size())
                //实际需要先判定结果集合非空,再获取集合元素
                .collect(Collectors.toList()).get(0).get(0).getName();
    }

注意! 注意!注意!

1.需要对指定指端做非空判定;

2.排序集合收集后需要对集合进行非空判定;

在C#的List集合中有时候需要获取指定索引位置范围的元素对象来组成一个新的List集合，此时就可使用到List集合的扩展方法GetRange方法，GetRange方法专门用于获取List集合指定范围内的所有值，GetRange方法签名为List GetRange(int index, int count)，index为开始索引位置，count为从index开始获取元素的个数。
例如有个List的集合list1,内部存储10个数字，需要获取list1集合从第5个数开始，连续的5个元素组成新的集合，可使用下列语句：
List list1 = new List() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var resultList= list1.GetRange(4, 5);

计算结果为，resultList集合的元素为5,6,7,8,9
备注：原文转载自博主个人技术站IT技术小趣屋，原文链接为C#中List集合使用GetRange方法获取指定索引范围内的所有值_IT技术小趣屋。

功能抄自JDK的Collections类，但源码不支持倒叙查找，做了一点点改动，使其支持。

见代码，注释很详细，就不啰嗦了。
private static final int BINARYSEARCH_THRESHOLD = 5000;
/**
     *
     * 功能描述：从指定list中，二分查找指定元素指定字段值，如在list<PrintBox> 中，查找字段FModel值为x的对象
     * ，list内的泛型元素须实现了Comparable接口并重写了compareTo方法
     * list须提前排序,正序倒序均可
     * 当list对象未实现RandomAccess接口或list.size()> 5000时，使用基于迭代器的二分法查找，反之，则基于索引的二分法查找。
     * 对于实现了RandomAccess接口的list，索引循环会比迭代器更快，如ArrayList
     * @Author 李
     * @MethodName getBinarySearch
     * @Date 17:47 2021/6/4
     * @param <T> list中的对象的类
     * @param list 被查找的list,建议用ArrayList，比较快
     * @param key 用于查找的对象，该对象中重写比较器时所用的用于比较的字段需有值
     * @return int 返回符合指定元素指定字段值的元素下标
     * @exception
     **/
    public static <T> int getBinarySearch(List<? extends Comparable<? super T>> list, T key) {
        if (list instanceof RandomAccess || list.size() < BINARYSEARCH_THRESHOLD) {
            return indexBinarySearch(list, key);
        } else {
            return iteratorBinarySearch(list, key);
        }
    }
    /**
     * 功能描述：基于迭代器的二分查找,list须提前排序,正序倒序均可
     * @param list
     * @param key  用于查找的对象，该对象中重写比较器时所用的用于比较的字段需有值
     * @return int
     * @throws
     * @Author 李
     * @MethodName getBinarySearch
     * @Date 11:37 2021/6/4
     **/
    private static <T> int iteratorBinarySearch(List<? extends Comparable<? super T>> list, T key) {
        int start = 0;
        int end = list.size() - 1;
        boolean flag = isReverse(list);
        ListIterator<? extends Comparable<? super T>> i = list.listIterator();
        while (start <= end) {
            int middle = (end + start) >>> 1;
            Comparable<? super T> midVal = getIterator(i, middle);
            int cmp = midVal.compareTo(key);
            if (flag){
                cmp *= (-1);
            }
            if (cmp < 0) {
                start = middle + 1;
            } else if (cmp > 0) {
                end = middle - 1;
            } else {
                return middle;
            }
        }
        return -(start + 1);
    }
    /**
     *
     * 功能描述：基于下标索引的二分查找,list须提前排序,正序倒序均可
     * @Author 李
     * @MethodName indexBinarySearch
     * @Date 17:45 2021/6/4
     * @param list
     * @param key 用于查找的对象，该对象中重写比较器时所用的用于比较的字段需有值
     * @return int
     * @exception
     **/
    private static <T> int indexBinarySearch(List<? extends Comparable<? super T>> list, T key) {
        int start = 0;
        int end = list.size() - 1;
        //第一个比最后一个大时，说明是倒序的。
        boolean flag = isReverse(list);
        while (start <= end){
            int middle = (end + start) >>> 1;
            Comparable<? super T> midVal = list.get(middle);
            int cmp = midVal.compareTo(key);
            if (flag){//倒序时，须反转正负
                cmp *= (-1);
            }
            if (cmp < 0) {
                start = middle + 1;
            } else if (cmp > 0) {
                end = middle - 1;
            } else {
                return middle;
            }
        }
        return -(start + 1);
    }
    /**
     *
     * 功能描述：判断一个list是否为倒序,须有序
     * @Author 李
     * @MethodName isReverse
     * @Date 19:06 2021/6/4
     * @param list
     * @return int
     * @exception
     **/
    @SuppressWarnings("unchecked")
    private static <T> Boolean isReverse(List<? extends Comparable<? super T>> list){
        if (CollectionUtils.isEmpty(list)){
            throw new MyException(10000,"列表为空");
        }
        int inter = list.get(0).compareTo((T)list.get(list.size()-1));
        return inter > 0;
    }
    /**
     *
     * 功能描述：从迭代器中获取指定对象
     * @Author 李
     * @MethodName get
     * @Date 10:37 2021/6/5
     * @param i 迭代器对象
     * @param index 索引
     * @return T
     * @exception
     **/
    private static <T> T getIterator(ListIterator<? extends T> i, int index) {
        T obj;
        int pos = i.nextIndex();
        if (pos <= index) {
            do {
                obj = i.next();
            } while (pos++ < index);
        } else {
            do {
                obj = i.previous();
            } while (--pos > index);
        }
        return obj;
    }

public class GetRandomObj {

    public static  void main(String[] args){

        //默认把资源文件创建在C盘下,命名为SourceFile.txt
        //一行填一个数据 比如:12,33两个数据,就填2行
        List<String> strings = new ArrayList<String>();
        List<String>  selected = new ArrayList<String>();
        List<Integer> ints = new ArrayList<Integer>();
        List<String> getStrs = new ArrayList<String>();
        Boolean isFisrtStart = true;
        Boolean isGo = true;
        BufferedReader br  = null;
        String err_msg = "";
        //输入和输出文件
        String path ="C:\\SourceFile.txt";
        String resultPath = "C:\\ResultFile.txt";
        GetRandomObj getRandomObj = new GetRandomObj();
        //接收输入值
        br = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        //-----------------测试 测试---------------//
        /*System.out.println("是否初始化源文件? Y ：是 ; 其他随意键 : 退出 ");
        try{
            str = br.readLine();
        }catch (Exception ex){
            isGo = false;
            err_msg = ex.getMessage();
        }
        if("Y".equals(str)){
            getRandomObj.initSourceFile(path,100);
        }*/
        //-----------------测试 测试---------------//
        System.out.println("-----------------------------");
        System.out.println("开始读取归档文件!!!!!!");
        //读抽取文件
        strings = getRandomObj.redaFile(path);
        //加载上次抽取结果
        selected = getRandomObj.redaFile(resultPath);
        System.out.println("读取归档成功!!!!!!");
        System.out.println("-----------------------------");
        while(isGo){
            System.out.println("----------待抽数据集"+strings.size()+"个---------");
            if(strings.size() == 0){
                isGo = false;
                err_msg = "当前待抽数据集是空的，请重新启动程序，初始化数据!!!!!!!! ";
                break;
            }else {
                for (String str1 : strings) {
                    System.out.println(str1);
                }
            }
            System.out.println("---------------------------");
            if(selected.size() > 0){
                System.out.println("----------已抽数据集"+selected.size()+"个---------");
                //for(String str1 : strings){
                System.out.println(selected.toString());
                //}
                System.out.println("---------------------------");
            }
            if(!isFisrtStart){
                System.out.println("是否继续? Y ：是 ; 其他随意键 : 退出 ");
                try{
                    str = br.readLine();
                }catch (Exception ex){
                    isGo = false;
                    err_msg = ex.getMessage();
                    break;
                }
                if(!"Y".equals(str)){
                    isGo = false;
                    err_msg = "退出";
                    break;
                }
            }else {
                File file = new File(resultPath);
                if(file.exists()){
                    System.out.println("是否初始化（把已抽记录还原到待抽列表）? Y ：是 ; 其他随意键 : 否 ");
                    try{
                        str = br.readLine();
                    }catch (Exception ex){
                        isGo = false;
                        err_msg = ex.getMessage();
                        break;
                    }
                    if("Y".equals(str)){
                        int count = 0;
                        for(String selectStr : selected){
                            count ++;
                            if(count == 1){
                                if(strings.size() > 0) {
                                    getRandomObj.writeFile(path, "", true, true);
                                }
                                if(count == selected.size()){
                                    getRandomObj.writeFile(path,selectStr,true,false);
                                }else{
                                    getRandomObj.writeFile(path,selectStr,true,true);
                                }
                            }else if(count == selected.size()){
                                getRandomObj.writeFile(path,selectStr,true,false);
                            }else{
                                getRandomObj.writeFile(path,selectStr,true,true);
                            }
                            strings.add(selectStr);
                        }
                        selected = new ArrayList<String>();
                        file.delete();
                        System.out.println("初始化成功!!!!!!!! ");
                        System.out.println("---------------------------");
                        System.out.println("----------待抽数据集"+strings.size()+"个---------");
                        for(String str1 : strings){
                            System.out.println(str1);
                        }
                        System.out.println("---------------------------");
                    }else{
                        System.out.println("---------------------------");
                        System.out.println("跳过初始化!!!!!!!! ");
                        System.out.println("---------------------------");
                    }
                }
            }
            if(strings.size() == 0){
                isGo = false;
                err_msg = "当前待抽数据集是空的，请重新启动程序，初始化数据!!!!!!!! ";
                break;
            }
            System.out.println("输入你要检出的个数:");
            try{
                str = br.readLine();
            }catch (Exception ex){
                isGo = false;
                err_msg = ex.getMessage();
                break;
            }
            int number = 0;
            try{
                number = Integer.valueOf(str);
            }catch (Exception ex){
                isGo = false;
                err_msg = ex.getMessage() +",结束！";
                break;
            }
            if(number > strings.size()){
                isGo = false;
                err_msg = "检出的个数大于当前数据集,结束！";
                break;
            }
            isFisrtStart = false;
            Random r = new Random();
            for(int i=0 ; i<number ;  i++)
            {
                boolean flag = true;
                int ran1 = r.nextInt(strings.size());
                for(int k : ints){
                    if(k == ran1){
                        flag = false;
                        break;
                    }
                }
                if(flag){
                    ints.add(ran1);
                }else{
                    i--;
                }
            }
            System.out.println("-------随机抽出"+number+"个----------");
            for(int j : ints){
                System.out.println(strings.get(j));
                getStrs.add(strings.get(j));
                selected.add(strings.get(j));
            }
            for(String str2 : getStrs){
                strings.remove(str2);
            }
            //把上一轮挑选的结果初始化
            getStrs = new ArrayList<String>();
            ints = new ArrayList<Integer>();
            System.out.println("---------------------------");
            System.out.println("***********************************************");
            if(strings.size() == 0){
                try{
                    //把待选文件清空
                    File file = new File(path);
                    file.delete();
                    file.createNewFile();
                }catch (Exception ex){
                    //ex;
                }
                isGo = false;
                System.out.println("----------已选数据集---------");
                System.out.println(selected.toString());
                System.out.println("---------------------------");
                err_msg = "数据全部抽取完毕,结束！";
            }
        }
        //关闭窗口输入流
        if(null != br){
            try{
                br.close();
            }catch (Exception ee){
                //ee;
            }
        }
        System.out.println("---------------------------");
        System.out.println(err_msg);
        System.out.println("---------------------------");
        //增加记忆功能
        try{
            int count = 0;
            //把本次执行后的待选数据归档
            for(String str3 : strings){
                count ++;
                if(count == 1) {
                    getRandomObj.writeFile(path,str3,false,true);
                }else if(count == strings.size()){
                    getRandomObj.writeFile(path,str3,true,false);
                } else{
                    getRandomObj.writeFile(path,str3,true,true);
                }
            }
            // 已选数据更新到文件里面
            File file = new File(resultPath);
            if(!file.exists()){
                file.createNewFile();
            }
            count = 0;
            for(String str4 : selected){
                count ++;
                if(count == 1) {
                    getRandomObj.writeFile(resultPath,str4,false,true);
                }else if(count == selected.size()){
                    getRandomObj.writeFile(resultPath,str4,true,false);
                }else{
                    getRandomObj.writeFile(resultPath,str4,true,true);
                }
            }
            System.out.println("///");
            System.out.println("记忆模式开启，已存档，下次启用会自动读取这次抽取结果!!!");
            System.out.println("");
        }catch (Exception ex){
            err_msg = err_msg +"归档异常!!" + ex.getMessage();
            System.out.println("---------------------------");
            System.out.println(err_msg);
            System.out.println("---------------------------");
        }
    }

    /**
     * 初始化源文件
     * @param path
     * @param max
     */
    public void initSourceFile(String path,int max){
        GetRandomObj obj = new GetRandomObj();
        for(int j =1 ;j <= max ; j++){
            if(j == 1) {
                obj.writeFile(path,j+"",false,true);
            }else if(j == max){
                obj.writeFile(path,j+"",true,false);
            }else{
                obj.writeFile(path,j+"",true,true);
            }
        }
    }

    /**
     * 根据路径读取文件
     * @param path
     * @return
     */
    public List<String> redaFile(String path){
        List<String> result = new ArrayList<String>();
        FileReader fileReader = null;
        BufferedReader br  = null;
        File file = new File(path);
        if(file.exists()){
            try{
                fileReader = new FileReader(file);
                br = new BufferedReader(fileReader);//构造一个BufferedReader类来读取文件
                String s = null;
                while((s = br.readLine())!=null){//使用readLine方法，一次读一行
                    result.add(s);
                }
            }catch (Exception ex){

            }finally {
                if(null != br){
                    try{
                        br.close();
                    }catch (Exception ee){
                        //ee;
                    }
                }
                if(null != fileReader){
                    try{
                        fileReader.close();
                    }catch (Exception ee){
                        //ee;
                    }
                }
            }
        }
        return result;
    }

    /**
     * 写文件
     * @param path
     * @param str
     * @param isAppend
     * @param isAddChangeLine
     */
    public void writeFile(String path, String str, Boolean isAppend, Boolean isAddChangeLine){
        FileWriter fileWriter = null;
        BufferedWriter bw = null;
        File file = new File(path);
        try {
            fileWriter = new FileWriter(file,isAppend);
            bw = new BufferedWriter(fileWriter);
            bw.write(str);
            if(isAddChangeLine){
                bw.write("\n");
            }
            bw.flush();
        }catch (Exception ex){

        }finally {
            if(null != fileWriter){
                try{
                    fileWriter.close();
                }catch (Exception ee){
                    //ee;
                }
            }
            if(null != bw){
                try{
                    bw.close();
                }catch (Exception ee){
                    //ee;
                }
            }
        }
    }
}