java对数据操作的一些技巧

1、从一个集合里面选择需要的数据返回出来

        从order.getOrderItems()集合里面选出OrderItemVo 类里的skuId,count,Title返回出一个新集合

 List<OrderItemVo> locks = order.getOrderItems().stream().map(item -> {
                    OrderItemVo itemVo = new OrderItemVo();
                    itemVo.setSkuId(item.getSkuId());
                    itemVo.setCount(item.getSkuQuantity());
                    itemVo.setTitle(item.getSkuName());
                    return itemVo;
                }).collect(Collectors.toList());

2、一个类里面有一个集合属性。填充集合属性值(此处不建议循环查询数据，数据越多，创建数据库的连接就越多，消耗越高。时间会越长。改成in查询出来后再stream处理)

从page里传入order （order=page）参数，通过order里的订单号，查询出所有的订单项。然后再把page里的几集合属性填充。返回。再收集成一个list.

        

IPage<OrderEntity> page = this.page(
                new Query<OrderEntity>().getPage(params),
                new QueryWrapper<OrderEntity>().eq("member_id",memberRespVo.getId()).orderByDesc("id")
        );

        List<OrderEntity> order_sn = page.getRecords().stream().map(order -> {
            List<OrderItemEntity> itemEntities = orderItemService.list(new QueryWrapper<OrderItemEntity>().eq("order_sn", order.getOrderSn()));
            order.setItemEntities(itemEntities);
            return order;
        }).collect(Collectors.toList());

3、补全一个数据。(此处不建议循环查询数据，数据越多，创建数据库的连接就越多，消耗越高。时间会越长。改成in查询出来后再stream处理)

        通过list集合里的已知数据。通过方法查询到数据。再放入补全的数据。最后返回完整数据

List<SeckillSessionEntity> list = this.list(new QueryWrapper<SeckillSessionEntity>().between("start_time", startTime(), endTime()));
        if(list!=null&&list.size()>0){
            List<SeckillSessionEntity> collect = list.stream().map(session -> {
                Long id = session.getId();
                List<SeckillSkuRelationEntity> relationEntities = seckillSkuRelationService.list(new QueryWrapper<SeckillSkuRelationEntity>().eq("promotion_session_id", id));
                session.setRelationSkus(relationEntities);
                return session;
            }).collect(Collectors.toList());
        }

4、远程调用返回的数据实体类根据远程服务的实体类一致。 

5、一个集合遍历通过forEach。以及单个实体类里的某个集合属性返回集合通过map(此处不建议循环查询数据，数据越多，创建数据库的连接就越多，消耗越高。时间会越长。改成in查询出来后再stream处理)

 sessions.stream().forEach(session -> {
                long startTime = session.getStartTime().getTime();
                long endTime = session.getEndTime().getTime();
              String key=SESSIONS_CACHE_PREFIX+startTime+"_"+endTime;
                List<String> collect = session.getRelationSkus().stream().map(item -> item.getId().toString()).collect(Collectors.toList());
                redisTemplate.opsForList().leftPushAll(key,collect);
            });

 6、分布式锁的基本使用

  @Autowired
    RedissonClient redissonClient;

  private final String upload_lock="seckill:upload:lock";

RLock lock = redissonClient.getLock(upload_lock);
        lock.lock(10, TimeUnit.SECONDS);
        try{
            seckillService.uploadSeckillSkuLatest3Days();
        }finally {
            lock.unlock();
        }

7、对String的某个数据替换

        XX.replace();

String replace = key.replace(SESSIONS_CACHE_PREFIX, "");

8、对某个String的切割成数组

        XX.split();

 String[] s = replace.split("_");

9、对一个集合的操作。把一个redis取出来的数据集合转换为实体类的集合

List<Object> list = hashOps.multiGet(Collections.singleton(range));

                if(list!=null){
                    List<SeckillSkuRedisTo> collect = list.stream().map(item -> {
                        SeckillSkuRedisTo redis = JSON.parseObject((String) item, SeckillSkuRedisTo.class);
                        //  redis.setRandomCode(null);当前秒杀开始就需要随机码
                        return redis;
                    }).collect(Collectors.toList());

                    return collect;
                }

10、把一些数据转换成List集合

Arrays.asList（）

 User u1=new User(11,"a",23);
       User u2=new User(12,"a",24);
       User u3=new User(13,"a",25);
       User u4=new User(14,"a",26);
       User u5=new User(15,"a",27);

       List<User> list= Arrays.asList(u1,u2,u3,u4,u5);

11、把某个字符串转换为大写

toUpperCase();

t.getUserName().toUpperCase();

12、把一个实体类复制到另一个

 BeanUtils.copyProperties(engineer, workOrderDto);