精华内容
下载资源
问答
  • 对准备集合
    千次阅读
    2019-06-05 14:04:20

    引言:
        本文主要介绍通过JDK提供的原始的去重排序和使用Lambda表达式的形式进行集合中数据的去重和排序

    一.环境准备:

    1.实体类:

    public class User {
        private Long id;
        private String name;
        public Long getId() {
            return id;
        }
        public void setId(Long id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public User() {
        }
        public User(Long id, String name) {
            this.id = id;
            this.name = name;
        }
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    

    2.插入测试数据:

    User u1 = new User(1L, "li");
    User u2 = new User(2L, "哈哈");
    User u3 = new User(1L, "li");
    User u4 = new User(2L, "li");
    List classList = new ArrayList();
    classList.add(u1);
    classList.add(u2);
    classList.add(u3);
    classList.add(u4);
    

    二.根据name属性值的Ascll码进行排序,没有去重:

    /**
     * 按照List中的某个String类型的属性进行排序
     *
     * @param list
     */
    
     Collections.sort(classList, new Comparator() {
         @Override
         public int compare(Object o1, Object o2) {
             User e1 = (User) o1;
             User e2 = (User) o2;
             return e1.getName().compareTo(e2.getName());
         }
     });
     classList.forEach( e -> System.out.println(e));
    

    三.通过name属性进行去重和重排序:

    Set<User> set = new TreeSet<User>(new Comparator<User>() {
           @Override
            public int compare(User o1, User o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        set.addAll(classList);
    List<User> list = new ArrayList<>(set);
    list.forEach( e -> System.out.println(e));
    

    四.采用lambda进行去重和排序:

     List list1 = (List) classList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(()->new TreeSet<>(Comparator.comparing(User::getName))), ArrayList::new));
          list1.forEach( e -> System.out.println(e));
    

    五.总结:
    以上完成了对集合中的对象的属性进行去重和排序操作,使用lambda的方式显的代码少简单,但是不容易懂。

    更多相关内容
  • 政治经济学期末考试试题准备集合.pdf
  • 准备安装NPM的性感React挂钩集合 参考:“ ” useInput useTabs useTitle useClick useHover useConfirm usePreventLeave useBeforeLeave useFadeIn useNetwork useScroll 使用全屏 useNotification ...
  • pyplaybook 我定义的Python函数集合,可加快数据准备和分析的速度2020年5月2日:上传了我的第一个Python脚本,该脚本具有用于pandas数据帧的数据转置功能
  • 使用Set集合对List集合进行去重

    万次阅读 多人点赞 2018-03-22 23:00:21
    使用Set集合对List集合进行去重前段时间正好遇到这样一个需求:我们的支付系统从对方系统得到存储明细对象的List集合,存储的明细对象对象的明细类简化为如下TradeDetail类,需求是这样的,我要对称List集合进行去重...
    使用Set集合对List集合进行去重

    前段时间正好遇到这样一个需求:我们的支付系统从对方系统得到存储明细对象的List集合,存储的明细对象对象的明细类简化为如下TradeDetail类,需求是这样的,我要对称List集合进行去重,这里的去重的意思是只要对象对象中的accountNo账号是相同的,就认为明细对象是相同的,去重之后要求是List集合或者Set集合。

    在进行上面的需求对象去重之前,先来看很简单的List集合去重:
    package com.qdfae.jdk.collections;

    import java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.Comparator;
    import java.util.HashSet;
    import java.util.Set;
    import java.util.TreeSet;

    import org.junit.Test;

    import com.qdfae.jdk.domain.TradeDetail;
    import com.qdfae.jdk.domain.User;

    /**
    * 使用Set集合对List集合进行去重
    *
    * @author hongwei.lian
    * @date 2018年3月9日 下午11:15:52
    */
    public class SetTest {
    /**
    * List集合的泛型为Integer类型
    *
    * @author hongwei.lian
    * @date 2018年3月9日 下午11:32:53
    */
    @Test
    public void testListToSet1() {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(1);
    Set<Integer> set = new HashSet<>(list);
    System.out.println("list的个数为:" + list.size() + "个");
    list.forEach(System.out::println);
    System.out.println("set的个数为:" + set.size() + "个");
    set.forEach(System.out::println);
    }
    /**
    * List集合的泛型为String类型
    *
    * @author hongwei.lian
    * @date 2018年3月9日 下午11:34:15
    */
    @Test
    public void testListToSet2() {
    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("a");
    Set<String> set = new HashSet<>(list);
    System.out.println("list的个数为:" + list.size() + "个");
    list.forEach(System.out::println);
    System.out.println("set的个数为:" + set.size() + "个");
    set.forEach(System.out::println);
    }

    /**
    * List集合的泛型为自定义类型User
    * 需求是userCode一样的便是同一个对象
    *
    * @author hongwei.lian
    * @date 2018年3月10日 上午12:32:12
    */
    @Test
    public void testListToSet3() {
    List<User> list = new ArrayList<>();
    list.add(new User(1,"用户一","600001"));
    list.add(new User(2,"用户二","600002"));
    list.add(new User(3,"用户一","600001"));
    list.add(new User(4,"用户一","600001"));
    Set<User> set = new HashSet<>(list);
    System.out.println("list的个数为:" + list.size() + "个");
    list.forEach(System.out::println);
    System.out.println("set的个数为:" + set.size() + "个");
    set.forEach(System.out::println);
    }
    }
    上面测试使用到的User类源码:
    package com.qdfae.jdk.domain;

    import java.io.Serializable;

    /**
    * User实体类
    *
    * @author hongwei.lian
    * @date 2018年3月10日 上午12:33:22
    */
    public class User implements Serializable {
    private static final long serialVersionUID = -7629758766870065977L;

    /**
    * 用户ID
    */
    private Integer id;
    /**
    * 用户姓名
    */
    private String userName;
    /**
    * 用户代码
    */
    private String userCode;
    public User() {}
    public User(Integer id, String userName, String userCode) {
    this.id = id;
    this.userName = userName;
    this.userCode = userCode;
    }

    public Integer getId() {
    return id;
    }

    public void setId(Integer id) {
    this.id = id;
    }

    public String getUserName() {
    return userName;
    }

    public void setUserName(String userName) {
    this.userName = userName;
    }

    public String getUserCode() {
    return userCode;
    }

    public void setUserCode(String userCode) {
    this.userCode = userCode;
    }

    @Override
    public String toString() {
    return "User [id=" + id + ", userName=" + userName + ", userCode=" + userCode + "]";
    }
    }
    依次运行上面三个方法的结果是:
    testListToSet1()方法结果:

    testListToSet2()方法结果:

    testListToSet3()方法结果:

    上面的testListToSet1()方法和testListToSet2()方法可以去重,那为什么testListToSet3()方法就不能去重呢?仔细想想就会知道,两个对象的地址值不一样,怎么会认为是相同的去重呢,再往深处想,就会想到Object类的hashCode()方法和equals()方法,这两个方法决定了两个对象是否相等。Integer类和String类之所以可以进行去重,是因为这两个类都重写了父类Object类中的hashCode()方法和equals()方法,具体的代码可以去查看JDK源码,这里不再赘述。到这里我们就知道User对象不能去重的原因所在,那么我们根据需求在User类中重写hashCode()方法和equals()方法,重写后的User类源码如下:
    package com.qdfae.jdk.domain;

    import java.io.Serializable;

    /**
    * User实体类
    *
    * @author hongwei.lian
    * @date 2018年3月10日 上午12:33:22
    */
    public class User implements Serializable {
    private static final long serialVersionUID = -7629758766870065977L;

    /**
    * 用户ID
    */
    private Integer id;
    /**
    * 用户姓名
    */
    private String userName;
    /**
    * 用户代码
    */
    private String userCode;
    public User() {}
    public User(Integer id, String userName, String userCode) {
    this.id = id;
    this.userName = userName;
    this.userCode = userCode;
    }

    public Integer getId() {
    return id;
    }

    public void setId(Integer id) {
    this.id = id;
    }

    public String getUserName() {
    return userName;
    }

    public void setUserName(String userName) {
    this.userName = userName;
    }

    public String getUserCode() {
    return userCode;
    }

    public void setUserCode(String userCode) {
    this.userCode = userCode;
    }
    /**
    * 针对userCode重写hashCode()方法
    */
    @Override
    public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((userCode == null) ? 0 : userCode.hashCode());
    return result;
    }

    /**
    * 针对userCode重写equals()方法
    */
    @Override
    public boolean equals(Object obj) {
    if (this == obj)
    return true;
    if (obj == null)
    return false;
    if (getClass() != obj.getClass())
    return false;
    User other = (User) obj;
    if (userCode == null) {
    if (other.userCode != null)
    return false;
    } else if (!userCode.equals(other.userCode))
    return false;
    return true;
    }

    @Override
    public String toString() {
    return "User [id=" + id + ", userName=" + userName + ", userCode=" + userCode + "]";
    }
    }
    我们再次运行testListToSet3()方法结果:

    这一次符合我们的需求,接下里再来看开头提出的需求。
    准备:
    TradeDetail类源码:
    package com.qdfae.jdk.domain;

    import java.io.Serializable;
    import java.math.BigDecimal;

    /**
    * 交易明细
    *
    * @author hongwei.lian
    * @date 2018年3月10日 下午2:44:35
    */
    public class TradeDetail implements Serializable {
    private static final long serialVersionUID = 3386554986241170136L;

    /**
    * 交易明细主键
    */
    private Integer id;
    /**
    * 账号
    */
    private String accountNo ;
    /**
    * 账户名称
    */
    private String accountName;
    /**
    * 交易金额(+表示入金,-表示出金)
    */
    private BigDecimal balance;

    public TradeDetail() {}
    public TradeDetail(Integer id, String accountNo, String accountName, BigDecimal balance) {
    this.id = id;
    this.accountNo = accountNo;
    this.accountName = accountName;
    this.balance = balance;
    }

    public Integer getId() {
    return id;
    }

    public void setId(Integer id) {
    this.id = id;
    }
    public String getAccountNo() {
    return accountNo;
    }

    public void setAccountNo(String accountNo) {
    this.accountNo = accountNo;
    }

    public String getAccountName() {
    return accountName;
    }

    public void setAccountName(String accountName) {
    this.accountName = accountName;
    }

    public BigDecimal getBalance() {
    return balance;
    }

    public void setBalance(BigDecimal balance) {
    this.balance = balance;
    }
    /**
    * 针对accountNo重写hashCode()方法
    */
    @Override
    public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((accountNo == null) ? 0 : accountNo.hashCode());
    return result;
    }

    /**
    * 针对accountNo重写equals()方法
    */
    @Override
    public boolean equals(Object obj) {
    if (this == obj)
    return true;
    if (obj == null)
    return false;
    if (getClass() != obj.getClass())
    return false;
    TradeDetail other = (TradeDetail) obj;
    if (accountNo == null) {
    if (other.accountNo != null)
    return false;
    } else if (!accountNo.equals(other.accountNo))
    return false;
    return true;
    }

    @Override
    public String toString() {
    return "TradeDetail [id=" + id + ", accountNo=" + accountNo + ", accountName=" + accountName + ", balance="
    + balance + "]";
    }

    }
    我们首先来按照上面的想法根据需求重写TradeDetail类的hashCode()方法和equals()方法,上面已经给出重写后的TradeDetail类。
    我有三种实现方案如下:
    package com.qdfae.jdk.collections;

    import java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.TreeSet;
    import java.util.stream.Collectors;

    import org.junit.Before;
    import org.junit.Test;

    import com.qdfae.jdk.domain.TradeDetail;

    /**
    * List集合去重
    *
    * @author hongwei.lian
    * @date 2018年3月11日 下午8:54:57
    */
    public class DuplicateListTest {
    /**
    * 存储没有去重的明细对象的List集合
    */
    private List<TradeDetail> tradeDetailList;
    /**
    * 存储去重后的明细对象的List集合
    */
    private List<TradeDetail> duplicateTradeDetailList;
    /**
    * 存储去重后的明细对象的Set集合
    */
    private Set<TradeDetail> tradeDetailSet;
    /**
    * 初始化tradeDetailList
    *
    * @author hongwei.lian
    * @date 2018年3月11日 下午9:04:45
    */
    @Before
    public void InitTradeDetailList() {
    tradeDetailList = new ArrayList<>();
    tradeDetailList.add(new TradeDetail(1, "600010", "账户一", new BigDecimal(100.00)));
    tradeDetailList.add(new TradeDetail(2, "600011", "账户二", new BigDecimal(100.00)));
    tradeDetailList.add(new TradeDetail(3, "600010", "账户一", new BigDecimal(-100.00)));
    tradeDetailList.add(new TradeDetail(4, "600010", "账户一", new BigDecimal(-100.00)));
    }

    /**
    * 使用Set接口的实现类HashSet进行List集合去重
    *
    * HashSet实现类
    * 构造方法:
    * public TreeSet(Comparator<? super E> comparator)
    *
    * @author hongwei.lian
    * @date 2018年3月11日 下午9:37:51
    */
    @Test
    public void testDuplicateListWithHashSet() {
    //-- 前提是TradeDetail根据规则重写hashCode()方法和equals()方法
    tradeDetailSet = new HashSet<>(tradeDetailList);
    tradeDetailSet.forEach(System.out::println);
    }
    /**
    * 使用Map集合进行List集合去重
    *
    * @author hongwei.lian
    * @date 2018年3月11日 下午9:05:49
    */
    @Test
    public void testDuplicateListWithIterator() {
    duplicateTradeDetailList = new ArrayList<>();
    Map<String, TradeDetail> tradeDetailMap = tradeDetailList.stream()
    .collect(Collectors.toMap(
    tradeDetail -> tradeDetail.getAccountNo(),
    tradeDetail -> tradeDetail,
    (oldValue, newValue) -> newValue));
    tradeDetailMap.forEach(
    (accountNo, tradeDetail) -> duplicateTradeDetailList.add(tradeDetail)
    );
    duplicateTradeDetailList.forEach(System.out::println);
    //-- 参考文章
    //http://blog.jobbole.com/104067/
    //https://www.cnblogs.com/java-zhao/p/5492122.html
    }
    /**
    * 使用Set接口的实现类TreeSet进行List集合去重
    *
    * TreeSet实现类
    * 构造方法:
    * public TreeSet(Comparator<? super E> comparator)
    *
    * @author hongwei.lian
    * @date 2018年3月11日 下午9:37:48
    */
    @Test
    public void testDuplicateListWithTreeSet() {
    tradeDetailSet = new TreeSet<>(
    (tradeDetail1, tradeDetail2)
    ->
    tradeDetail1.getAccountNo().compareTo(tradeDetail2.getAccountNo())
    );
    tradeDetailSet.addAll(tradeDetailList);
    tradeDetailSet.forEach(System.out::println);
    }

    }
    运行上面三个方法的结果都是:

    方案一:根据需求重写自定义类的hashCode()方法和equals()方法
    这种方案的不足之处是根据需求重写后的hashCode()方法和equals()方法不一定满足其他需求,这样这个TradeDetail类的复用性就会相当差。
    方案二:遍历List集合,取出每一个明细对象,将明细对象的accountNo属性字段作为Map集合key,明细对象作为Map集合的value,然后再遍历Map集合,得到一个去重后的List集合或者Set集合。
    这种方案的不足之处是消耗性能,首先是List集合去重转换为Map集合,Map集合再次转换为List集合或者Set集合,遍历也会消耗性能。
    方案三:使用TreeSet集合的独有的构造方法进行去重,如下:
    public TreeSet(Comparator<? super E> comparator) {
    this(new TreeMap<>(comparator));
    }
    这种方案目前为止是我使用的比较多的方案,不足之处暂时没有发现,TreeSet集合实际上是利用TreeMap的带有一个比较器参数的构造方法实现,看JDK源码很清晰,最重要的是这个参数Comparator接口,这个接口的源码:
    Comparator接口部分源码:
    @FunctionalInterface
    public interface Comparator<T> {

    int compare(T o1, T o2);

    }
    这个compare()方法需要自己根据需求去实现,仔细看上面去重的原理实际上还是使用String类的compareTo()方法,String类的compareTo()方法源码:
    public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;

    int k = 0;
    while (k < lim) {
    char c1 = v1[k];
    char c2 = v2[k];
    if (c1 != c2) {
    return c1 - c2;
    }
    k++;
    }
    return len1 - len2;
    }
    基本就想到了这些,如果有好的实现方法,自己还会补充。
    展开全文
  • 与联接操作一样,集合操作也是两个输入进行操作,并生成一个虚拟表。在联接操作中,一般把输入表称为左输入和右输入。集合操作的两个输入必须拥有相同的列数,若数据类型不同,MySQL数据库自动将进行隐式转换。...
  • 我们经常在工作中会碰到这种情况:让我将对象结合中的对象按照对象的某个属性的值进行操作,然后根据值对集合中的对象进行分组。 这种情况听上去不是很难,但是在做起来的时候就会很麻烦。不清楚Java8新特性的朋友...

    我们经常在工作中会碰到这种情况:让我将对象结合中的对象按照对象的某个属性的值进行操作,然后根据值对集合中的对象进行分组。
    这种情况听上去不是很难,但是在做起来的时候就会很麻烦。对不清楚Java8新特性的朋友来说,你可能会遍历数组对对象属性进行操作判断,然后在创建几个List对象去存储分组后的对象,这可能需要十几行代码。
    然而今天,我们来学习一下Java8的其中一个新特性:集合的流式编程,让这种操作只要几行代码搞定。

    一. 准备阶段

    1.准备好一个实体类

    public class Person{
        private Integer age;
        private String name;
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    

    2.准备好一个集合

    ArrayList<Person> people = new ArrayList<>();
            for (int i = 1; i <= 100; i++) {
                Person person = new Person();
                person.setAge(i);
                String l = i % 2 == 0 ? "偶数" : "奇数";
                person.setName(l+"-"+i);
                people.add(person);
            }
    

    这里我循环插入了一百个对象,对象的age直接赋值为每次循环的i值,name值则为当前i是否为偶数再加上“-”和当前i的值。

    二. 实操阶段

    操作一:对person的age属性进行操作,将根据age的奇偶性进行分组

    Map<Boolean, List<Person>> collect = people.stream().collect(Collectors.groupingBy(l -> {
                Integer age = l.getAge();
                return age % 2 == 0;
            }));
    

    好了,分完组后,他会返回一个Map集合,key值是分组的所依据的值,value就是分好组后的集合,接下来让我看看结果

    List<Person> personList1 = collect.get(true);
            List<Person> personList2 = collect.get(false);
            personList1.forEach(System.out::println);
            System.out.println("===============");
            personList2.forEach(System.out::println);
    
    Person{age=2, name='偶数-2'}
    Person{age=4, name='偶数-4'}
    Person{age=6, name='偶数-6'}
    Person{age=8, name='偶数-8'}
    ...
    ===============
    Person{age=1, name='奇数-1'}
    Person{age=3, name='奇数-3'}
    Person{age=5, name='奇数-5'}
    Person{age=7, name='奇数-7'}
    Person{age=9, name='奇数-9'}
    ...
    

    这里由于每个集合中都有50个对象,所以我就挑了前面几条进行展示。

    操作二:在name中获得“-”后的数字,并根据其对5取余的值进行分组

    Map<Integer, List<Person>> collect = people.stream().collect(Collectors.groupingBy(l -> {
                String name = l.getName();
                String[] split = name.split("-");
                int parseInt = Integer.parseInt(split[1]);
                return parseInt % 5;
            }));
    
    Person{age=5, name='奇数-5'}
    Person{age=10, name='偶数-10'}
    Person{age=15, name='奇数-15'}
    Person{age=20, name='偶数-20'}
    ...
    ============
    Person{age=1, name='奇数-1'}
    Person{age=6, name='偶数-6'}
    Person{age=11, name='奇数-11'}
    Person{age=16, name='偶数-16'}
    ============
    Person{age=2, name='偶数-2'}
    Person{age=7, name='奇数-7'}
    Person{age=12, name='偶数-12'}
    Person{age=17, name='奇数-17'}
    ...
    ============
    Person{age=3, name='奇数-3'}
    Person{age=8, name='偶数-8'}
    Person{age=13, name='奇数-13'}
    Person{age=18, name='偶数-18'}
    ...
    ============
    Person{age=4, name='偶数-4'}
    Person{age=9, name='奇数-9'}
    Person{age=14, name='偶数-14'}
    Person{age=19, name='奇数-19'}
    ...
    

    通过这种方法,无论你对需要分组的属性值进行多复杂的计算或操作,只要最后他们返回的结果一致,他们就会分到一个组中,并且组名就是他们的返回值。
    如果对你有用的话麻烦点个赞把。

    展开全文
  • HashMap的应用实例 ...2,当向HashMap中put一对键值时,它会根据key的hashCode值计算出一个位置,该位置就是此对象准备往数组中存放的位置。 HashMap应用举例:控制台输入一句英语,简单统计各个单词出现的次数
  • java8特性快速list集合的筛选过滤和计算一、准备工作1.创建一个Student对象package com.shiro.test.java8特性;import java.io.Serializable;/*** 学生的实体类*/public class Student implements Serializable {...

    java8特性快速对list集合的筛选过滤和计算

    一、准备工作

    1.创建一个Student对象

    package com.shiro.test.java8特性;

    import java.io.Serializable;

    /**

    * 学生的实体类

    */

    public class Student implements Serializable {

    private String id;

    private String username;

    private Integer age;

    private String sex;

    private String status;

    //要加这个构造函数 为了给对象赋值

    public Student(String id, String username, int age, String sex,String status) {

    this.id = id;

    this.username = username;

    this.age = age;

    this.sex = sex;

    this.status = status;

    }

    public String getStatus() {

    return status;

    }

    public void setStatus(String status) {

    this.status = status;

    }

    public String getId() {

    return id;

    }

    public void setId(String id) {

    this.id = id;

    }

    public String getUsername() {

    return username;

    }

    public void setUsername(String username) {

    this.username = username;

    }

    public String getSex() {

    return sex;

    }

    public void setSex(String sex) {

    this.sex = sex;

    }

    public Integer getAge() {

    return age;

    }

    public void setAge(Integer age) {

    this.age = age;

    }

    }

    2.创建一个测试类,创建list集合,向list中添加数据

    @Test

    public void test2(){

    List studentList = new ArrayList<>();

    Student s1 = new Student("1","小张",20,"男","0");

    Student s2 = new Student("2","小李",22,"男","1");

    Student s3 = new Student("3","小花",21,"女","1");

    Student s4 = new Student("4","小华",18,"女","2");

    Student s5 = new Student("5","小流",28,"男","2");

    Student s6 = new Student("6","小吴",25,"男","0");

    Student s7 = new Student("7","小吴",25,"男","0");

    Student s8 = new Student("8","小吴",25,"男","0");

    studentList.add(s1);

    studentList.add(s2);

    studentList.add(s3);

    studentList.add(s4);

    studentList.add(s5);

    studentList.add(s6);

    studentList.add(s7);

    studentList.add(s8);

    二、利用java8特性Stream流对list集合进行操作

    1.利用stream流进行foreach遍历

    studentList.stream.forEach(student ->{

    //处理逻辑 打印出所有学生的名单和年龄

    System.out.println(student.getUsername()+student.getAge());

    });

    42bf92537d20d7b25bb19a5b73f83aca.png

    2.对studentList利用filter函数进行筛选 获取符合条件的

    List list = studentList.stream.filter(student ->Obgects.equals(studengt.getSex(),"女")).collect(Collectors.toList());

    //list中存放的是性别是女的所有学生

    //使用stream流进行foreach遍历

    list.stream().forEach(student ->{

    System.out.println(student.getUsername()+student.getSex());

    });

    3.对List集合进行去重

    //将username相同的 进行去重

    List unique = studentList.stream().collect(Collectors.collectingAndThen(

    Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Student::getUsername))),ArrayList :: new));

    unique.stream().forEach(student -> {

    System.out.println("-------------------"+student.getUsername());

    });

    4.取出list集合对象中的某一个属性(取出list中的每一个对象的名字组成一个新的集合)

    List username=studentList.stream().map(Student::getUsername).collect(Collectors.toList());//不取重的

    List username = studentList.stream(),map(Student::getUsername).distinct().collect(Collectors.toList());//这个是将名字取重之后的

    5.过滤属性为空的字段(添加一条数据 名字为空的数据) //获取名字不为空的

    Student s9 = new Student("9","",25,"男","0");

    studentList.add(s9);

    List IsEmptyUsernameList= studentList.stream().map(s-> s.getUsername()).filter(s-> !s.isEmpty()).collect(Collectors.toList());

    System.out.println(IsEmptyUsernameList);

    6.根据其中的某一属性值进行计算

    //(获取年龄的最大值、最小值、平均值、综合、个数)

    IntSummaryStatistics resultNum = studentList.stream().mapToInt((s) -> s.getAge()).summaryStatistics();

    //个数

    System.out.println(resultNum.getCount());

    //总大小

    System.out.println(resultNum.getSum());

    //最大值

    System.out.println(resultNum.getMax());

    //最小值

    System.out.println(resultNum.getMin());

    //平均值

    System.out.println(resultNum.getAverage());

    本文地址:https://blog.csdn.net/weixin_45170450/article/details/112859227

    如您对本文有疑问或者有任何想说的,请点击进行留言回复,万千网友为您解惑!

    展开全文
  • AWS-SAA认证说明我在准备AWS解决方案架构师联合考试(我通过)时所有笔记的集合
  • java中的集合详解

    千次阅读 多人点赞 2020-07-21 15:02:17
    集合集合是java中提供的一种容器,可以用来存储多个数据。集合和数组既然都是容器,它们有啥区别呢? 数组的长度是固定的。集合的长度是可变的。 数组中存储的是同一类型的元素,可以存储基本数据类型值。...
  • C++实现集合运算

    千次阅读 2021-09-14 16:31:05
    //老师问为啥那么少的人提前交,我做完了但是好多地方没有中文提示,就是纯代码,我就准备先不交再完善下 #include<iostream> #include<stdlib.h> //想用动态内存,但我发现直接定义足够大的静态数组...
  • Java集合体系

    千次阅读 2021-12-11 20:47:50
    任何集合框架都包含三大块内容:对外的接口、接口的实现和对集合运算的算法。 Java的集合体系由最上层的接口、中间的一些抽象类、以及最后各种具体的实现类组成。 Java集合的基本接口是Collection接口和Map接口。 ...
  • 一、概述 Java中集合排序,在Java8之前,可以通过 Collections类的sort方法进行排序;Java8之后,新增 lambda和stream ,都增加了相关的排序方法,本文将整理下常见的三种排序方法。 分别是:二、准备工作 1、创建一...
  • 在使用Drools规则引擎时,有朋友会遇到这样的问题,就是在when部分判断的两个参数都是集合类型,比如两个List,此时要判断一个集合是否包含另外一个集合的内容。 拿一个具体的例子来说明,我的公众号《程序新视界》...
  • 大厂面试突击——集合

    万次阅读 多人点赞 2021-08-26 10:28:08
    上篇
  • JDK1.8优雅的集合排序(集合的排序)

    千次阅读 2020-10-26 12:50:29
    因为数据源来源于多个接口(也就是多个库),所以处理的方式:分别调用这个三个接口,把这三个接口返回的数据转化成同一个对象,然后这些集合对象进行拼接,再按照排序规则进行排序并最终的集合进行截取,获取当前页...
  • 集合

    千次阅读 多人点赞 2019-10-02 07:47:28
    集合集合是java中提供的一种容器,可以用来存储多个数据。集合和数组既然都是容器,它们有啥区别呢? 数组的长度是固定的。集合的长度是可变的。 数组中存储的是同一类型的元素,可以存储基本数据...
  • 1.Set集合 1.1Set集合概述和特点【应用】 不可以存储重复元素 没有索引,不能使用普通for循环遍历 1.2Set集合的使用【应用】 存储字符串并遍历 public class MySet1 { public static void main(String[] args) { ...
  • Postman:集合执行

    千次阅读 2019-10-28 22:01:51
    集合执行 集合是一组请求,运行集合,就会依据所选的环境变量,发送集合中所有的请求,如果配合脚本就可以构建集成测试套件,在接口请求之间传递数据,并构建接口实际工作流的镜像。如果想要自动化测试接口,运行...
  • 这篇博客主要是记录在学习java集合中,使用相关知识点完成宜春(哈哈 貌似暴露了点什么)麻将的准备牌、洗牌、发牌、看牌基本功能。 public class YiChunMaJiang { /** * @Title: main * @Description: *...
  • Set集合(超详解)

    千次阅读 2022-06-27 20:56:34
    set集合,hashset,treeset
  • Java集合的运算之减法A-B

    千次阅读 2021-02-27 15:52:20
    英文自我介绍 一定要事先准备,逻辑要清晰 2.英文项目介绍 使用plist的好处 首先:帮助节省内存.OpenGL ES纹理要求宽和高都是2的n次幂的倍数.我们可以考虑将小的图片拼大图片,然后统一加载. 其次:提高渲染速度.OpenGL...
  • Java8之后很多新特性,接下来主要讲一下, list集合利用stream根据对象得某一属性对集合进行分组! 话不多说,上代码: 首先准备实体类: @Data @AllArgsConstructor @NoArgsConstructor public class Student { ...
  • 这一章节我们来讨论一下查询集合以及投影元素集合。我们下面用一个例子说明上面的这两个部分。1.domain蛋糕类:(不变)package com.raylee.my_new_spring.my_new_spring.ch01.topic_1_21; public class Cake { ...
  • Java中的有序集合

    万次阅读 2019-09-07 19:58:52
    Java中的有序集合 面试的时候经常会被问道这样一个问题:Java集合中哪些是有序的,哪些不是? 我们通常的回答是List、LinkedHashMap、LinkedHashSet、TreeMap、TreeSet是有序的,List、LinkedHashMap、LinkedHashSet...
  • 有时候在List集合操作时并不想新建一个实体类来进行转换。这就涉及到将集合中对象的每个元素投影到新属性,以此来生成一个新的集合。 一、准备工作 定义实体类UserEntity @Data public class UserEntity ...
  • Java8集合过滤操作

    千次阅读 2021-01-17 16:07:00
    首先准备实体类 package entity; public class Person { private Integer age; private String name; public Person(Integer age, String name) { this.age = age; this.name = name; } public Person() ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 340,081
精华内容 136,032
热门标签
关键字:

对准备集合