Java集合部分

原创 已于 2022-01-18 17:26:59 修改 · 432 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java
于 2020-03-31 08:21:53 首次发布
本文详细介绍Java中List集合的分页、合并、去重等实用操作，包括如何找出两个List集合的相同与不同部分，以及利用Stream API高效处理集合数据。

一、list集合分页

/**
     * List集合的分页方法，根据传入总共的List集合数据和页码、数据的条数
     * @param t 需要进行分页的集合
     * @param pageNo 第几页
     * @param pageSize 数据的条数
     * @return 进过分页之后返回的数据
     */
    public static <T> List<T> pageList(List<T> t,int pageNo,int pageSize){
        
        if (CollectionUtils.isEmpty(t)){
            t = new ArrayList<T>();
        }
        if(pageNo <= 0){
            pageNo = 1;
        }
        if (pageSize<=0){
            pageSize = 1;
        }
        //集合总的数据条数
        int total = t.size();
        //返回参数
        List<T> resList = new ArrayList<T>();
        // 从第几页开始
        int begin = (pageNo-1)*pageSize;
        // 结束位置：从开始位置+pageSize,
        // 判定是否大于总条数，如果大于就到总条数结束，如果<= 在开始位置+pageSize结束
        int end = (((pageNo -1)*pageSize) + pageSize > total ? total:((pageNo -1)*pageSize) +pageSize);
        for ( int i = begin; i < end; i++) {
            resList.add(t.get(i));
        }
        return resList;
    }

二、一个单元素的结合

List使用Arrays.asList()和Collections.singletonList()方法创建只有一个元素的实例

三、找出两个list集合的不同部分

@SuppressWarnings({ "rawtypes", "unchecked" })
    public static Collection getDifferent(Collection collmax, Collection collmin) {
        //使用LinkeList防止差异过大时,元素拷贝
        Collection csReturn = new LinkedList();
        Collection max = collmax;
        Collection min = collmin;
        //先比较大小,这样会减少后续map的if判断次数
        if (collmax.size() < collmin.size()) {
            max = collmin;
            min = collmax;
        }
        //直接指定大小,防止再散列
        Map<Object, Integer> map = new HashMap<Object, Integer>(max.size());
        for (Object object : max) {
            map.put(object, 1);
        }
        for (Object object : min) {
            if (map.get(object) == null) {
                csReturn.add(object);
            } else {
                map.put(object, 2);
            }
        }
        for (Map.Entry<Object, Integer> entry : map.entrySet()) {
            if (entry.getValue() == 1) {
                csReturn.add(entry.getKey());
            }
        }
        return csReturn;
    }

四、找出两个list集合的相同部分

方法1:
List<String> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
List<String> list = new ArrayList<>();
if (list1.size()<list2.size()) {
	list = list1.stream().filter(item -> list2.contains(item)).collect(Collectors.toList());
} else {
	list = list2.stream().filter(item -> list1.contains(item)).collect(Collectors.toList());
}

方法3：
public static void main(String[] args) {
// 注意：一定要使用创建对象的格式创建数组
Integer[] a = new Integer[] { 6, 3, 9, 3, 2, 4, 5, 7 };
Integer[] b = new Integer[] { 5, 8, 6, 2, 1, 9 };
List _a = Arrays.asList(a);
List _b = Arrays.asList(b);
// 创建集合
Collection realA = new ArrayList<Integer>(_a);
Collection realB = new ArrayList<Integer>(_b);
// 求交集
realA.retainAll(realB);
System.out.println("交集结果：" + realA);
Set result = new HashSet();
// 求全集
result.addAll(_a);
result.addAll(_b);
System.out.println("全集结果：" + result);
// 求差集：结果
Collection aa = new ArrayList(realA);
Collection bb = new ArrayList(result);
bb.removeAll(aa);
System.out.println("最终结果：" + bb);


/**
* 交集结果：[6, 9, 2, 5] 全集：[1, 2, 3, 4, 5, 6, 7, 8, 9] 最终结果：[1, 3, 4, 7, 8]
*/
}

五、将两个集合合并，去重

List<String> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
将两个List 合并
list1.addAll(list2);
List<String> all = list1.stream()
                    .distinct()
                    .collect(Collectors.toList());

根据对象属性去重
//第一种方式 使用TreeSet去重
List<User> users = new ArrayList<>();
        List<User> user1 = users .stream().collect(
                collectingAndThen(toCollection(() -> new TreeSet<>(Comparator.comparing(o ->o.getId()))),ArrayList::new));
 
		//第二种方式 使用map去重
        List<User> user2 = books.stream()
                .filter(distinctByKey(o -> o.getId()))
                .collect(Collectors.toList());

六、获取stream 处理集合

// 将结合中对象的某个属性取出来
List<String> userIds= users.stream().map(User::getUserId).collect(Collectors.toList());
// 通过对象的id对集合进行分组
Map<Long, List<Student>> studentMap = students.stream().collect(Collectors.groupingBy(Student::getStudentId));
// 找到集合中对象的某个属性等于某个值的对象
Student student= students.stream().filter(i -> Objects.equals(i.getStudentId(), 2)).findAny().orElse(null);
// 通过对象的某个属性，进行分组
Map<Long, Student > studentMap = students.stream().collect(Collectors.toMap(Student ::getStudentId, (k) -> k));
Map<Long, String> studentMap = students.stream().collect(Collectors.toMap(Student ::getStudentId,Student ::getStudentName));
 //  获取对象的某个属性，进行排序 
 List<String> strings = students.stream().map(item->(item.getStudengNo())).sorted((a, b) -> a.compareToIgnoreCase(b)).collect(Collectors.toList());
 // 倒序排序
List<Student> reveredStudents = students.stream().sorted(Comparator.comparing(Student ::getStudentId).reversed()).collect(Collectors.toList());
// 找到对象所在集合中的下标
        AtomicInteger index = new AtomicInteger(0);
        strings.stream().filter(item ->
                {
                    index.getAndIncrement();
                    return StrUtil.equals("201417023401", item);
                }
        ).findFirst();
        // i 就是学生编号对应的对象，在集合中的下标了
        int i = index.intValue() - 1;    
        

// 集合中按照对象的多个属性，进行分组,然后根据某个属性求和
     Map<Date, Map<String, Double>> stuCollect = stuData.stream().collect(Collectors.groupingBy(Student::getDate,
    		 Collectors.groupingBy(Student::getStudengNo,
    		                       Collectors.summingDouble(item -> item.getScore().doubleValue()))));

// 获取集合中对象属性的最大值
Student maxAge = stuData.stream().max(Comparator.comparing(Student::getAge)).get();

七、字符集合

# 集合转 ，分割的字符串
List<String> list = new ArrayList<>(list);
String str = String.join(",", list);
# 字符串转集合
String s = "张三,李四,王五";
List<String> newlist = new ArrayList<String>(Arrays.asList(s.split(",")));

八、stream 集合中bigdecimal类型相加

方法中不能调用清除缓存注解的方法，没有效果

BigDecimal totalCount = products.stream().map(product::getCount).reduce(BigDecimal.ZERO,BigDecimal::add);

九、两个不同类型的集合，通过对象的某个属性，找交集

1. 先将两个集合的属性分别取出来
2. 然后取交集，将集合取出来
 public static void main(String[] args) {
 		// 测试数据
        List<Order> orders = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            Order order = new Order();
            order.setOrderId(Long.valueOf(i));
            order.setProdName("测试" + Long.valueOf(i));
            order.setOrderNumber("000"+String.valueOf(i));
            orders.add(order);
        }
        for (int i = 11; i <= 13; i++) {
            Order order = new Order();
            order.setProdName("测试" + Long.valueOf(i));
            order.setOrderId(Long.valueOf(i));
            order.setOrderNumber("000"+String.valueOf(i));
            orders.add(order);
        }
        List<Order> orders2 = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            Order order = new Order();
            order.setOrderNumber("000"+String.valueOf(i));
            order.setOrderId(Long.valueOf(i));
            order.setProdName("测试" + Long.valueOf(i));
            orders2.add(order);
        }
		
		// 方法一：遍历，取相同的数据
        long startTime = System.currentTimeMillis();
        List<Order> sames = new ArrayList<>();
        for (Order order : orders2) {
            Order order1 = orders.stream().filter(item -> Objects.equals(item.getOrderNumber(), order.getOrderNumber())).findAny().orElse(null);
            sames.add(order1);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("sames 所需时间：" + new BigDecimal(endTime).subtract(new BigDecimal(startTime)).longValue());
        for (Order item : sames) {
            if (Objects.isNull(item)){
                continue;
            }
            System.out.println("sames: " + item.getOrderId() +"  "+item.getOrderNumber() + "  " + item.getProdName());
        }

		// 方法二：先将相同的属性找出来，再取相同的集合
        long startTime2 = System.currentTimeMillis();
        List<String> orderNums1 = orders.stream().map(Order::getOrderNumber).collect(Collectors.toList());
        List<String> orderNums2 = orders2.stream().map(Order::getOrderNumber).collect(Collectors.toList());
        // 取交集，集合为空情况请自行处理
        orderNums2.retainAll(orderNums1);
        List<Order> sames2 = new ArrayList<>();
        for (String s : orderNums2) {
            if (orderNums1.size()>=orderNums2.size()){
                Order order = orders2.stream().filter(item -> Objects.equals(s, item.getOrderNumber())).findAny().orElse(null);
                sames2.add(order);
            } else {
                Order order = orders.stream().filter(item -> Objects.equals(s, item.getOrderNumber())).findAny().orElse(null);
                sames2.add(order);
            }
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("sames2 所需时间：" + new BigDecimal(endTime2).subtract(new BigDecimal(startTime2)).longValue());
        for (Order item : sames2) {
            if (Objects.isNull(item)){
                continue;
            }
            System.out.println("sames2: " + item.getOrderId() +"  "+item.getOrderNumber() + "  " + item.getProdName());
        }
    }
// 结果：
sames 所需时间：86
sames: 1  0001  测试1
sames: 2  0002  测试2
sames: 3  0003  测试3
sames: 4  0004  测试4
sames: 5  0005  测试5
sames2 所需时间：8
sames2: 1  0001  测试1
sames2: 2  0002  测试2
sames2: 3  0003  测试3
sames2: 4  0004  测试4
sames2: 5  0005  测试5
JAVA计算集合、数组中每个元素的个数
qq_40750086的博客
10-18 3509
【代码】JAVA计算集合、数组中每个元素的个数。
Java中集合的基础知识与代码（超详细）
Jiang5106的博客
07-21 672
随风散->拉萨 java.util.Collection接口，所有的集合都实现自该接口，这个接口中定义了所有集合都必须。数组的工具类Arrays提供了一个静态方法asList，可以将一个数组转换为List集合。java.util.List线性表，是一个可以存放重复元素且有序的集合。集合与数组一样，可以保存一组元素，但是操作元素都封装成了方法。集合有多种不同的数据结构，可根据实际应用场景选择最优的结构。集合只能存放引用类型元素，并且存放的是元素的引用(地址)元素是否重复取决于集合自身的equals...
java集合（超详细）
热门推荐
zdl66的博客
08-12 6万+
所有的集合类和集合接口都在java.util包下。 在内存中申请一块空间用来存储数据，在Java中集合就是替换掉定长的数组的一种引用数据类型。
java 一个list<T>集合自己比较自己得出所有相同的数据
季末
09-30 1104
List<OdsStatsData> odsStatsData = igniteService.statisticOd(min, addMin); List<FlowOdStats> flowOdStats = new ArrayList<>(odsStatsData.size()); List<OdsStatsData...
java中list集合对象按照某一个属性分组
feinifi的博客
02-01 5619
java语言中list集合按照对象某一属性分组。如果list中是map对象，我们需要在分组的地方传入一个lambda表达式函数，将需要分组的属性通过map.get("xx")传入。
【Java集合的使用以及部分底层实现】
最新发布
weixin_63309304的博客
01-15 1083
无论前方等待我们的是什么，让我们保持勇气和决心，一路向前！
Java中的集合框架有哪些部分组成？它们各自的特点是什么？
11-15 4万+
Queue：Queue 是一个特殊的集合，用于通过特定的插入和删除操作来处理元素。Set 接口提供了一种对元素进行唯一性验证的方式，因此，它也是处理一组唯一元素的有效方式。实现类：这些类是接口的具体实现，Java集合框架提供了一系列的常用实现类，如 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等。接口：这些是集合框架的顶层抽象，代表了不同类型的集合，包括 Set、List、Queue、Deque 和 Map。
Java集合需要记忆的部分
Adam York
08-09 698
//仅记录需要记忆的部分 0、总体框架 1、Collection Collection是一个接口，是高度抽象的集合，包含集合的基本操作：添加、删除、清空、遍历（读取）、是否为空、获取大小等。 1.1、List是有序的队列，每一个元素都一个索引，第一个元素的索引值是0，与set不同，List允许重复的元素。注意indexof和lastindexof的不同。 1.2、set不允许重复 ...
Java学习之集合框架（部分）
weixin_45073487的博客
08-01 172
list中重复值合并
Loicco的博客
10-19 2410
1.重写equals方法，name相同即为相等 2.新建一个List，用来放结果。 3.遍历旧的List，如果新的list中存在名字相同的，则新的List中该元素的count+1. 如果不存在，则放入新的List 示例代码： //测试类 public class ListTest { public static void main(String[] args) { List<ListTestObject> oldList = new ArrayList<>(); /
《Java 8 in Action》【06】----用流收集数据（一）
梦悠哉的博客
04-06 493
文章目录1. 1.
JAVA后台常用方法_一蓑烟雨任平生
Jaeger_Java的博客
05-21 496
Springboot 时间转换类,越用越爽 package com.hnyfkj.productmarket.web.config; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.core.JsonPr
java集合详解完整版（超详细）
weixin_42533238的博客
06-09 2万+
联合整理 https://blog.csdn.net/feiyanaffection/article/details/81394745 https://www.cnblogs.com/linliquan/p/11323172.html 一、集合大纲 1、集合与数组的区别 2、集合常用方法 3、常用集合分类 Collection 接口的接口 对象的集合（单列集合） ├——-List 接口：元素按进入先后有序保存，可重复 │—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有
java中list方法addall怎么写_使用List的addAll()方法请判空指针
weixin_33503998的博客
01-27 2102
标签：在写代码的时候经常会用到List,Set的addAll()方法，但是要注意addAll()方法不能传入空指针。1 packagelink.mengya.utils;23 importlink.mengya.User;45 import java.util.*;67 /**8 * Created by chang on 16/2/20.9 */10 public classListTest ...
Java开发避坑指南——空指针、异常
qq_35599414的博客
11-08 2278
一、空指针 1）、没初始化的对象（万物皆对象，java实体类、数组、异常对象、空内容等都可以看出对象，一个对象如果没初始化，使用其内容时就会报空指针异常） public class UserDemo { private String username; private String[] arrys; public void pri(){ System.out.println("这是UserDemo的方法"); } public Strin
java 抽出集合中指定的值进行变化操作_BAT面试题——22个集合框架（完）
weixin_39924779的博客
11-28 285
1.Set 里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用 == 还是equals()? 它们有何区别?Set 里的元素是不能重复的，元素重复与否是使用 equals() 方法进行判断的。equals() 和 == 方法决定引用值是否指向同一对象 equals() 在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。2.两个对象值相同 (x.equals(y) == ...
Java集合框架及接口浅谈
相鱼南故
11-04 334
Java集合框架及接口浅谈 近期开始接触Java框架的相关知识，特此根据现有知识对Java集合框架做以小结，以下博客仅作为个人学习过程的小结，如能对各位博友有所帮助不胜荣幸。 本篇博客将简单介绍Java集合框架及接口的相关知识，以及其注意事项有哪些，只做本人小结，后期随学习深入再做补充修改。 一、集合与Java集合框架的简介 所谓集合可以看做储存对象信息的一种容器 而集合框架即为了表示和操作集合而规定的 一种统一的标准的体系结构 Java集合框架（Java Collections Framework），此处
JAVA列表排序方法sort和reversed介绍, 以及排序时避免空指针异常
林临的博客
06-16 1万+
排序方法sort List和Stream中都有sort方法, 可以借助Comparator比较器快速实现列表排序 1.按年龄正序排(从小到大) public class Test { String name; Integer age; Doubleheight; public static void main(String[] args) { List<Test> l = new ArrayList<>(); //直接对列表排序 l.sort(Comparator
Java集合部分总结
jerryzaki的博客
07-11 252
/* * 集合框架 演示java集合的用法 * ArrayList * */ package jerryzaki1; import java.util.*;import javax.xml.crypto.dsig.spec.C14NMethodParameterSpec; public class Test2_5 { public static void main(String[] a
Java集合部分知识
在下的博客
07-23 326
集合中的接口与类之间的关系如下图所示： 其中蓝色标注的为接口，红色标注的为类。 具体如下： 1.Set接口表示的集合不能包含重复的元素； 2.HashSet：元素存放在Hash表中，元素数量较大时，访问效率比线性列表快； 3.TreeSet：采用有序树存储集合中的元素，元素按照升序排序； 4.LinkedHashSet：采用Hash表和链表结合的结构存储元素，既能保证元素的顺序，存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值