精华内容
下载资源
问答
  • 记录:已有对象集合List<Employee> ,需要获取Employee的字段 name出现最多的对象(即根据name字段分组->排序->取第一个对象); public static void main(String[] args) { List<Employee> list = ...

    记录:已有对象集合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...

    在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类... * 功能描述:从指定list中,二分查找指定元素指定字段值,如在list<PrintBox> ,查找字段FModel值为x的对象 * ,list内的泛型元素须实现了Comparable接口并重写了compareTo方法

    功能抄自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盘下,命名为Source... List<String> strings = new ArrayList<String>(); List<String> select.
    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;
                    }
                }
            }
        }
    }
    展开全文
  • 使用lambda筛选集合中指定的数据

    千次阅读 2019-05-23 00:05:07
    最近使用lambda表达式,获取集合中指定的一个对象,分享一波~ // 从学生集合studentList获取第一个名字为tom的学生 Student stu = studentList.stream() .filter(s -> "tom".equals(s.getName)) .find...
  • jquery获取除某指定对象外的其他对象 .not() 遍历方法 从匹配元素集合中移除元素 :not() 选择器 选取除了指定元素以外的所有元素。 <li>list item 1 <li>list item 2 <li id=unwanted>list item 3 <li>...
  • import java.io.File; import java.io.FileFilter; import java.io.ObjectInputStream.GetField; import java.util.ArrayList; import java.util.List;... /*获取一个想要的指定文件的集合获取文件夹下
  • 获取集合中指定字段集合 List<String> names= list.stream().map(Book -> Book.getName()).collect(Collectors.toList()); 查询集合中匹配的多个对象 List<Student> students= list.stream()....
  • 创建list集合对象3.获取指定下标对应的元素4.获取List集合)迭代器5.元素取代(add)和添加(set)6.移出指定下标和指定集合5.set集合1.导包2.案例分析 1. 集合的由来 容器(数组和StringBuffer),数组的
  • List集合和set集合

    2017-10-16 17:03:00
    List集合中的元素允许重复,各元素的顺序就是对象插入的顺序,类似于java数组,用户可通过使用索引(元素在集合中的位置)来访问集合中的元素。 List接口继承了Collection借口,因此包含了Collection的所有方法,...
  • 集合类1-list

    2017-04-05 16:49:15
    List集合中的元素允许重复,各元素的顺序就是对象插入的顺序。用户可以通过索引访问集合中的元素。 List接口的两个重要方法: get(int index): 获取指定索引位置的元素 set(int index, Object ob): 将集合中指定...
  • List集合中可以包含重复的对象,若要获取重复对象第一次出现的索引位置可以使用indexOf()方法,想要获取重复对象最后一次出现的索引位置,可以使用lastIndexOf()方法。使用indexOf()与lastIndexOf()方法时,如果指定...
  • 在工作会遇到下面一个场景:从数据库根据某些条件查询会返回很多条数据,这些数据返回到后台我们用List集合接收,由于List的泛型是我们后台自定义实体类,我们只想要获取这些数据实体类的某一个字段的值并将其...
  • 还继承了ICollection和IEnumerable接口,除实现了接口原有的方法成员外,其本身也定义多个专门的方法成员,例如新增、移除、在指定位置插入元素或是返回特定元素在集合中所在的位置索引,这些方法主要为集合对象提供...
  • 1.List集合 List集合除了继承Collection接口,还定义了...//将集合中index位置的对象改成指定对象 List接口实现类有:ArrayList、LinkedList ArrayList: 实现可变长度的数组,方便对特定索引位置的数据快速访问...
  • 集合

    2021-01-11 09:39:20
    注意:如果集合对象创建时不指定泛型,则在当前集合中可以存放任意类型的对象。 包括:Collection List Set Map List:接口的实现类有ArrayList、LInkedList、Vector 特点:有序,可重复 ArrayList:数组结构(底层使用...
  • java集合框架

    2020-07-27 12:19:04
    指定对象添加到集合中 remove(Object e) 将指定对象集合中删除 isEmpty() 返回boolean值,判断集合是否为空 iterator() 返回一个迭代器,用于遍历集合中的对象 size() 返回int型值,获取集合中元素的个数 List和...
  • 12.集合

    2020-07-25 23:43:16
    集合类又称为容器 集合的长度是可变的,数组的长度是不可变的 常用的集合有List、Set、...将指定对象添加到集合中 Remove() void 从集合中移除对象 Size() int 获取集合大小 isEmpty() boolean 判断集合是...
  • -------android培训、java培训、期待与您交流! ---------- ArrayList 首先我们熟悉下ArrayList类中常用方法的使用。...2)获取:public Object get(int index):返回此列表中指定位置(索引)上的元素。 3
  • List接口是继承Collection接口,所以Collection集合中有的方法,List集合也继承过来。 Java的Collection集合的常用方法 方法名 说明 boolean add(E e) 向集合添加元素e,若指定集合元素改变了则返回true ...
  • EL 表达式获取

    2020-03-25 22:59:07
    键名}`二、`${键名}`三、获取对象四、获取 List 集合五、获取 Map 集合的值 一、${域名称.键名} ${域名称.键名}:从指定中获取指定键的值 * 域名称: * pageScope --> pageContext * requestScope --&...
  • 第十四章 集合

    2021-03-11 20:46:09
    注意:如果集合对象创建时不指定泛型,则在当前集合中可以存放任意类型的对象 包括:Collection List Set Map List: 接口的实现类有ArrayList、LinkedList、Vector 特点:有序,可重复 ArrayList:数组结构(底层...
  • hibernate提供了映射各种类型集合的方法,通过映射不同类型的集合,... LIst集合的特点是将其中的对象按照索引进行排序,并且可以通过索引获取指定对象List集合可以存放重复对象。 三、映射Map  Map集合中的每
  • Java每日笔记013 集合

    2021-01-12 21:08:43
    注意:如果集合对象创建时不指定泛型,则在当前集合中可以存放任意类型的对象。 包括:Collection List Set Map List:接口的实现类有ArrayList ArrayList:数组结构(底层利用数组实现),以下标形式获取...
  • 第十二章 集合

    2021-01-11 09:39:41
    注意:如果集合对象创建时不指定泛型,则在当前集合中可以存放任意类型的对象。 包括:Collection List Set Map List:接口的实现类有:ArrayList、LinkedList、Vector 特点:有序、可重复 ArrayList:数组结构(底层...
  •  /// 根据指定类型,从数据库中获取数据,存放到List集合中  ///  /// 泛型对象  /// 类类型,即数据库中的表名  /// 查询表的SQL  /// SQL参数  ///  public List MakeTablePackage(stri

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 288
精华内容 115
关键字:

获取list集合中指定对象