java lambda表达式用法

已于 2024-06-07 14:33:27 修改
阅读量564 收藏
点赞数
分类专栏： JAVA 文章标签： lambda stream
于 2020-04-20 10:56:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014373554/article/details/105628543
版权 
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;


public class Test {

    public static void main(String[] args) {

        People p1 = new People("1","李红", 50);
        People p2 = new People("2","李逵", 20);
        List<People> list = new ArrayList<People>();
        list.add(p1);
        list.add(p2);


        People p3 = new People("1","诸葛亮", 80);
        People p4 = new People("2","李逵", 40);
        List<People> list1 = new ArrayList<People>();
        list1.add(p3);
        list1.add(p4);

        // 1、java lambda表达式检查list集合是否存在某个值
        boolean bool = list.stream().anyMatch(people -> people.getId().equals("3"));
        System.out.println("bool:"+ bool);

        List<People> data = list.stream().filter(people -> people.getId().equals("1")).collect(Collectors.toList());
        if(data != null && !data.isEmpty()){
            for (People people : data){
                System.out.println("id="+ people.getId() +":name="+ people.getName());
            }
        }

        List<People> peopleList = new ArrayList<People>();
        //2、遍历两个list 取交集
        list.forEach(people -> {
            People people1 = list1.stream().filter(people2 ->
                    people.getId().equals(people2.getId())).findFirst().orElse(null);
            if(people1 != null){
                int  score = people.getScore() == null ? 0: people.getScore();
                int  score1 = people1.getScore() == null ? 0: people1.getScore();
                people1.setScore(score + score1);
            }
            peopleList.add(people1);
        });

        if(peopleList != null && !peopleList.isEmpty()){
            for (People people : peopleList){
                System.out.println("id="+ people.getId() +":name="+ people.getName()+":score ="+ people.getScore());
            }
        }
        // 3获取某个对象的list集合 并去重复
        List<String> nameList = list.stream().map(e -> e.getName()).collect(Collectors.toList()).stream().distinct().collect(Collectors.toList());

        System.out.println(nameList.size());

    }
// list 转成 已ID为key  value 为  List<People> 对象的map

 Map<String, List<People>> collect = list.stream().collect(Collectors.groupingBy(People::getId));

// list根据对象的某个属性去重
 List<People> distinctItems = list.stream()
                    .collect(Collectors.collectingAndThen(
                            Collectors.toMap(People::getId, item -> item, (item1, item2) -> item1),
                            map -> new ArrayList<>(map.values())))

// list 转成 已ID为key  value 为  People 对象的map

 Map<String, People> collct = List.stream()
                .collect(Collectors.toMap(People::getId, people-> people));


// 取key不能为空，并且去重，相同则覆盖之后的值。 replacement ，项目不覆盖则取 existing
  Map<String, BdmsDatainfoVo> map =bdmsList.stream().filter(item -> item.getCode() != null)
                .collect(Collectors.toMap(
                        BdmsDatainfoVo::getCode, // keyMapper
                        Function.identity(), // valueMapper
                        (existing, replacement) -> replacement // mergeFunction
                ));


//排序
// 按照数量进行排序(正序)
goodsList = goodsList.stream().sorted(Comparator.comparing(Goods::getNum)).collect(Collectors.toList());
System.out.println("正序按照数量进行排序:" + JSON.toJSONString(goodsList));
 
// 按照数量进行排序(倒序)
goodsList = goodsList.stream().sorted(Comparator.comparing(Goods::getNum).reversed()).collect(Collectors.toList());
System.out.println("倒序按照数量进行排序:" + JSON.toJSONString(goodsList));
 
// 按金额进行倒序,金额相同就按照数量来进行正序
goodsList = goodsList.stream().sorted(Comparator.comparing(Goods::getPrice, Comparator.reverseOrder()).thenComparing(Goods::getNum)).collect(Collectors.toList());



//异步查询接口，提高接口查询性能问题

  ExecutorService executor = new ThreadPoolExecutor(20, 20,
            5, TimeUnit.SECONDS,  new LinkedBlockingDeque<Runnable>(100), new ThreadFactoryBuilder().setNameFormat("Risk-View-pool-%d").build());

 /**
     *  组装返回数据
     * @param poList
     * @return
     */
    private    List<RiskViewDataDto>  assembleRiskViewData(Long projectId, List<ProjectFirstIndicatorPo> poList,
                                                           Map<Integer, ProjectFirstIndicatorContentPo> contentPo ,
                                                           Map<Long, List<ProjectSecondIndicatorPo>> indicatorPo){

        List<CompletableFuture<RiskViewDataDto>> futures = poList.stream().map(item -> CompletableFuture.supplyAsync(() -> {
            RiskViewDataDto riskViewDataDto = new RiskViewDataDto();
            riskViewDataDto.setProjectIndicatorId(item.getId());
            riskViewDataDto.setSourceId(item.getSourceId());
            riskViewDataDto.setName(item.getName());
            riskViewDataDto.setStrategy(item.getCompetitiveStrategy());
         
            // 取二级指标数据
            riskViewDataDto.setViewList(getSecondRiskViewList(projectId, result, item, indicatorPo));

            return riskViewDataDto;
        }, executor)).collect(Collectors.toList());
        return  futures.stream().map(CompletableFuture::join).collect(Collectors.toList());
    }


  ExecutorService executorService = new ThreadPoolExecutor(10, 10,
            5, TimeUnit.SECONDS,  new LinkedBlockingDeque<Runnable>(100), new ThreadFactoryBuilder().setNameFormat("indicator-risk-pool-%d").build());

    private  List<SecondRiskView> getSecondRiskViewList( Long projectId, Boolean result, ProjectFirstIndicatorPo po, Map<Long, List<ProjectSecondIndicatorPo>> indicatorPo){

        List<SecondRiskView>  riskViews = Lists.newArrayList();
        List<ProjectSecondIndicatorPo> secondIndicatorPos = indicatorPo.get(po.getId());
        if(secondIndicatorPos != null && secondIndicatorPos.size() > 0){
            secondIndicatorPos.forEach( item  -> {
                SecondRiskView secondRiskView = new SecondRiskView();
                secondRiskView.setProjectIndicatorId(item.getId());
                secondRiskView.setSourceId(item.getSourceId());
                secondRiskView.setName(item.getName());
                secondRiskView.setStrategy(item.getCompetitiveStrategy());
                BigDecimal curStageCompetitivenessValue = item.getCurStageCompetitivenessValue();
                BigDecimal complianceValue = item.getCompetitivenessComplianceValue();
                secondRiskView.setComplianceScore(result ? curStageCompetitivenessValue : complianceValue);
                secondRiskView.setCompetitivenessScore(item.getProjectCoreCompetitorCompetitivenessScore());
                secondRiskView.setBaseRequirement(item.getBaseRequirement());
                // 魅点要求
                CompletableFuture<List<String> > charmRequirement = CompletableFuture.supplyAsync(() -> {
                    return projectIndicatorViewMapper.findCharmRequirementDataList(projectId,item.getId());
                },executorService);

                //目标达成路径
                CompletableFuture<List<String> > targetReachPath = CompletableFuture.supplyAsync(() -> {
                    return projectIndicatorViewMapper.findTargetReachPath(projectId,item.getSourceId());
                },executorService);

                // 风险数据列表
                CompletableFuture<List<RiskDto> > riskList = CompletableFuture.supplyAsync(() -> {
                    return projectIndicatorViewMapper.findRiskDataList(projectId,item.getId());
                },executorService);

                // t_project_indicator_view 取该表的  风险 和 进展情况
                CompletableFuture<ProjectIndicatorViewPo > projectIndicatorViewPo = CompletableFuture.supplyAsync(() -> {
                    return projectIndicatorViewMapper.findProjectIndicatorViewPo(projectId,item.getId());
                },executorService);

                CompletableFuture.allOf(charmRequirement,targetReachPath,riskList,projectIndicatorViewPo).join();

                // 目标达成路径
                try {
                    List<String> list = charmRequirement.get();
                    List<String> targetReachPathList = targetReachPath.get();
                    List<RiskDto> riskDtos = riskList.get();
                    ProjectIndicatorViewPo indicatorViewPo = projectIndicatorViewPo.get();
                    secondRiskView.setCharmRequirement(list);
                    secondRiskView.setTargetReachPath(targetReachPathList);
                    secondRiskView.setRiskDtoList(riskDtos);
                    if(indicatorViewPo != null ){
                        secondRiskView.setRisk(indicatorViewPo.getRisk());
                        secondRiskView.setContent(indicatorViewPo.getContent());
                    }
                }catch ( Exception e){
                    log.error("项目风险试图列表并发查询，出现异常:{}",e);
                    throw new AppException("项目风险试图列表数据并发查询，出现异常");
                }
                riskViews.add(secondRiskView);
            });

        }
        return riskViews;


    }


}

结果：

bool:false
id=1:name=李红
id=1:name=诸葛亮:score =130
id=2:name=李逵:score =60
2

@Test
void testAdd() {
    People p1 = new People(1,"李红", 50);
    People p2 = new People(2,"李逵", 20);
    People p3 = new People(1,"诸葛亮", 80);
    People p4 = new People(2,"李逵", 40);
    List<People> list = new ArrayList<People>();
    list.add(p1);
    list.add(p2);
    list.add(p3);
    list.add(p4);
    Map<Integer, List<People>> listMap = list.stream().collect(Collectors.groupingBy(People::getId));

    listMap.forEach((key,value)->{
        log.info("key:"+ key);
        for (int i = 0; i < value.size() ; i++) {
            People people = value.get(i);
            log.info("id="+ people.getId() +":name="+ people.getName());
        }

    });

}
import com.baomidou.mybatisplus.annotations.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

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

/**
 * @description: 燃油车月报实体对象
 * @since 2022-12-19
 */
@Data
@TableName("FV_INTERESTING_MONTH_REPORT")
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class FvInterestingMonthReport implements Serializable {
    private static final long serialVersionUID = 1L;
    /**
     * id
     */
    private Long id;

    /**
     * vin码
     */
    private String vin;

    /**
     * 年
     */
    private Integer year;

    /**
     * 月
     */
    private Integer month;

    /**
     * 拥有天数
     */
    private Integer ownerDays;

    /**
     * 本月驾驶天数
     */
    private Integer driveDays;

    /**
     * 里程排名
     */
    private Integer totalMileageRank;

    /**
     * 行驶总里程,单位：km
     */
    private BigDecimal totalMileage;

    /**
     * 平均速度,单位：km/h
     */
    private BigDecimal averageSpeed;

    /**
     * 启动次数
     */
    private Integer startUpSum;

    /**
     * 驾驶时长,单位：hh:mm:ss
     */
    private Long driveTime;

    /**
     * 油耗排名
     */
    private Integer avgFuelCostRank;

    /**
     * 百公里油耗,单位：L/100km
     */
    private BigDecimal avgFuelCost;

    /**
     * 车系代码
     */
    private String vehicleSeriesCode;

    /**
     * 车系名称
     */
    private String vehicleSeriesName;

    /**
     * 创建人
     */
    private String createBy;

    /**
     * 修改人
     */
    private String updateBy;

    /**
     * 创建时间
     */
    private Date createDate;

    /**
     * 修改时间
     */
    private Date updateDate;

    /**
     * 当月最早用车时间
     */
    private Long tripStartTime;

    /**
     * 当月最晚用车时间
     */
    private Long tripEndTime;

    /**
     * 当月刹车总次数
     */
    private int brakeSum;

    /**
     * 急加速总次数
     */
    private int rapidAcceleraSum;

    /**
     * 急减速总次数
     */
    private int rapidSlowDownSum;

    /**
     * 最大速度,单位：km/h
     */
    private BigDecimal maxSpeed;

    /**
     *行程打分
     */
    private Double tripScore;
}

lambda 用法：

//本季度拥有天数
int ownerDays = list.stream().mapToInt(FvInterestingMonthReport::getOwnerDays).sum();
//本季度驾驶天数
int driveDays = list.stream().mapToInt(FvInterestingMonthReport::getDriveDays).sum();

//总里程
double totalMileage = list.stream().mapToDouble(fvInterestingMonthReport -> fvInterestingMonthReport.getTotalMileage().doubleValue()).sum();
//驾驶时间

long driveTime = list.stream().mapToLong(FvInterestingMonthReport::getDriveTime).sum();
// 平均速度
double averageSpeed = getAverageSpeed(list);
// 启动次数
int startUpSum = list.stream().mapToInt(FvInterestingMonthReport::getStartUpSum).sum();

//百公里油耗
double avgFuelCost =avgFuelCost(list);
//最大速度
BigDecimal  maxSpeed  = list.stream().max(Comparator.comparing(FvInterestingMonthReport::getMaxSpeed)).get().getMaxSpeed();
//本季度最早用车时间
Long tripStartTime = list.stream().min(Comparator.comparing(FvInterestingMonthReport::getTripStartTime)).get().getTripStartTime();
// 本季度最晚用车时间
Long tripEndTime = list.stream().max(Comparator.comparing(FvInterestingMonthReport::getTripEndTime)).get().getTripEndTime();
// 当月刹车总次数
int brakeSum = list.stream().mapToInt(FvInterestingMonthReport::getBrakeSum).sum();
//当月急加速总次数
int rapidSum = list.stream().mapToInt(FvInterestingMonthReport::getRapidAcceleraSum).sum();
//当月急减速总次数
int downSum = list.stream().mapToInt(FvInterestingMonthReport::getRapidSlowDownSum).sum();
//行程平均分
double tripScore = avgTripScore(list);


//车系代码
String vehicleSeriesCode = list.stream().filter(fvInterestingMonthReport -> Objects.nonNull(fvInterestingMonthReport.getVehicleSeriesCode())).collect(Collectors.toList()).get(0).getVehicleSeriesCode();

// 车系名称
String vehicleSeriesName = list.stream().filter(fvInterestingMonthReport -> Objects.nonNull(fvInterestingMonthReport.getVehicleSeriesName())).collect(Collectors.toList()).get(0).getVehicleSeriesName();

/**
 * 计算平均得分
 * @param list
 * @return
 */
private double avgTripScore(List<FvInterestingMonthReport> list){
    if (list.isEmpty()) {
        return 0;
    }
    double tripScore = list.stream().mapToDouble(FvInterestingMonthReport::getTripScore).sum();

    return  CalculateUtil.doubleDivide(tripScore,list.size(), 1);
}

/**
 * 计算平均油耗

 * @param list
 * @return
 */
private double avgFuelCost(List<FvInterestingMonthReport> list){
    if (list.isEmpty()) {
        return 0;
    }
    double totalAverageSpeed = list.stream().mapToDouble(fvInterestingMonthReport -> fvInterestingMonthReport.getAvgFuelCost().doubleValue()).sum();

    return  CalculateUtil.doubleDivide(totalAverageSpeed,list.size(), 1);
}

/**
 * 计算平均速度
 * @param list
 * @return
 */
private double getAverageSpeed(List<FvInterestingMonthReport> list ) {

    List<FvInterestingMonthReport> collect = list.stream().filter(fvInterestingMonthReport -> Objects.nonNull(fvInterestingMonthReport.getAverageSpeed())).collect(Collectors.toList());
    if (collect.isEmpty()) {
        return 0;
    }

    double totalAverageSpeed = collect.stream().mapToDouble(fvInterestingMonthReport -> fvInterestingMonthReport.getAverageSpeed().doubleValue()).sum();

    return  CalculateUtil.doubleDivide(totalAverageSpeed,collect.size(), 1);
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//



import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;

public class CalculateUtil {
    public CalculateUtil() {
    }

    public static double doubleAdd(int scale, double... dd) {
        BigDecimal result = BigDecimal.ZERO;
        double[] var3 = dd;
        int var4 = dd.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            double n = var3[var5];
            result = result.add(new BigDecimal(Double.toString(n)));
        }

        return result.setScale(scale, RoundingMode.HALF_EVEN).doubleValue();
    }

    public static BigDecimal double2BigDecimal(int scale, double dd) {
        BigDecimal result = BigDecimal.ZERO;
        result = result.add(new BigDecimal(Double.toString(dd)));
        return result.setScale(scale, RoundingMode.HALF_EVEN);
    }

    public static double doubleAdd(double... dd) {
        BigDecimal result = BigDecimal.ZERO;
        double[] var2 = dd;
        int var3 = dd.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            double n = var2[var4];
            result = result.add(new BigDecimal(Double.toString(n)));
        }

        return result.doubleValue();
    }

    public static double parseString2Double(String str, int scale) {
        BigDecimal result = BigDecimal.ZERO;
        BigDecimal value = new BigDecimal(str);
        result = result.add(value);
        return result.setScale(scale).doubleValue();
    }

    public static double doubleAbs(double d, int scale) {
        BigDecimal result = BigDecimal.ZERO;
        if (d < 0.0D) {
            d = -d;
        }

        result = result.add(new BigDecimal(d));
        return result.setScale(scale, RoundingMode.HALF_EVEN).doubleValue();
    }

    public static double doubleAdd(int scale, RoundingMode mode, double... dd) {
        BigDecimal result = BigDecimal.ZERO;
        double[] var4 = dd;
        int var5 = dd.length;

        for(int var6 = 0; var6 < var5; ++var6) {
            double n = var4[var6];
            result = result.add(new BigDecimal(Double.toString(n)));
        }

        return result.setScale(scale, mode).doubleValue();
    }

    public static double doubleAdd(double d1, double d2) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        return bd1.add(bd2).doubleValue();
    }

    public static double doubleAdd(double d1, double d2, int scale) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        return bd1.add(bd2).setScale(scale, RoundingMode.HALF_EVEN).doubleValue();
    }

    public static double add(BigDecimal bd1, BigDecimal bd2, int scale) {
        return bd1.add(bd2).setScale(scale, RoundingMode.HALF_EVEN).doubleValue();
    }

    public static double doubleAdd(double d1, double d2, int scale, RoundingMode mode) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        return bd1.add(bd2).setScale(scale, mode).doubleValue();
    }

    public static double doubleSubtract(double d1, double d2) {
        return d1 != -2.0D && d1 != -1.0D ? (new BigDecimal(Double.toString(d1))).subtract(new BigDecimal(Double.toString(d2))).doubleValue() : d1;
    }

    public static double doubleSubtract(double d1, double d2, int scale) {
        BigDecimal b = (new BigDecimal(Double.toString(d1))).subtract(new BigDecimal(Double.toString(d2)));
        return b.setScale(scale, RoundingMode.HALF_EVEN).doubleValue();
    }

    public static double doubleSubtract(double d1, double d2, int scale, RoundingMode mode) {
        BigDecimal b = (new BigDecimal(Double.toString(d1))).subtract(new BigDecimal(Double.toString(d2)));
        return b.setScale(scale, mode).doubleValue();
    }

    public static double doubleSubtract(double d1, int scale, double... d2) {
        BigDecimal b = new BigDecimal(Double.toString(d1));

        for(int i = 0; i < d2.length; ++i) {
            double d = d2[i];
            b.subtract(new BigDecimal(d));
        }

        return b.setScale(scale, RoundingMode.HALF_EVEN).doubleValue();
    }

    public static double formatNubmer(double d1, int scale) {
        BigDecimal bd = new BigDecimal(Double.toString(d1));
        return bd.setScale(scale, RoundingMode.HALF_EVEN).doubleValue();
    }

    public static double formatNubmer(double d1, int scale, RoundingMode mode) {
        BigDecimal bd = new BigDecimal(Double.toString(d1));
        return bd.setScale(scale, mode).doubleValue();
    }

    public static BigDecimal formatNubmer(BigDecimal d1, int scale, RoundingMode mode) {
        return d1.setScale(scale, mode);
    }

    public static String formatNubmer(double d1, int scale, String formatter) {
        BigDecimal bd = new BigDecimal(Double.toString(d1));
        double dd = bd.setScale(scale, RoundingMode.HALF_EVEN).doubleValue();
        DecimalFormat df = new DecimalFormat(formatter);
        return df.format(dd);
    }

    public static String formatNubmer(double d1, int scale, RoundingMode mode, String formatter) {
        BigDecimal bd = new BigDecimal(Double.toString(d1));
        double dd = bd.setScale(scale, mode).doubleValue();
        DecimalFormat df = new DecimalFormat(formatter);
        return df.format(dd);
    }

    public static String formatNumberWithString(String formatter, String value) {
        if (!StringUtils.isEmpty(value) && !"null".equals(value)) {
            if (StringUtils.isEmpty(formatter)) {
                formatter = "#,##0.00#";
            }

            BigDecimal bd = new BigDecimal(value);
            DecimalFormat df = new DecimalFormat(formatter);
            String result = df.format(bd);
            return result;
        } else {
            return "0.00";
        }
    }

    public static double doubleDivide(double d1, double d2) {
        if (d1 != -2.0D && d1 != -1.0D) {
            BigDecimal bd1 = new BigDecimal(Double.toString(d1));
            BigDecimal bd2 = new BigDecimal(Double.toString(d2));
            return bd1.divide(bd2).doubleValue();
        } else {
            return d1;
        }
    }

    public static double doubleDivide(double d1, double d2, int scale) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        BigDecimal bd3 = bd1.divide(bd2, 10, RoundingMode.HALF_EVEN);
        return bd3.setScale(scale, RoundingMode.HALF_EVEN).doubleValue();
    }

    public static double doubleDivide(double d1, double d2, int scale, RoundingMode mode) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        BigDecimal bd3 = bd1.divide(bd2, 10, mode);
        return bd3.setScale(scale, mode).doubleValue();
    }

    public static double doubleMultiply(double d1, double d2) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        return bd1.multiply(bd2).doubleValue();
    }

    public static double doubleMultiply(double d1, double d2, int scale) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        return bd1.multiply(bd2).setScale(scale, RoundingMode.HALF_EVEN).doubleValue();
    }

    public static long double2Long(double d) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d));
        return bd1.setScale(0, RoundingMode.HALF_EVEN).longValue();
    }

    public static double doubleMultiply(double d1, double d2, int scale, RoundingMode mode) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        return bd1.multiply(bd2).setScale(scale, mode).doubleValue();
    }

    public static String formatFourNumber(int number) {
        NumberFormat nf = new DecimalFormat("0000");
        return nf.format((long)number);
    }

    public static boolean isDivisible(double d1, double d2) {
        return d1 % d2 == 0.0D;
    }

    public static String scaleNumber(double num) {
        BigDecimal decimal = (new BigDecimal(num)).setScale(2, 4);
        return decimal.toString();
    }

    public static String getIntValue(double num) {
        BigDecimal decimal = (new BigDecimal(num)).setScale(0, 4);
        return decimal.intValue() + "";
    }

    public static double doublePower(double num, int power, int scale) {
        BigDecimal decimal = new BigDecimal(num);
        decimal = decimal.pow(power);
        return decimal.setScale(scale, 4).doubleValue();
    }

    public static String getPercent(BigDecimal b1, BigDecimal b2, int scale, RoundingMode mode, boolean fixedScale) {
        if (b1 != null && b2 != null && b2.compareTo(BigDecimal.ZERO) != 0) {
            NumberFormat format = getFormat(scale, mode, fixedScale);
            BigDecimal radio = b1.divide(b2, 10, mode);
            return format.format(radio);
        } else {
            return (scale > 0 ? "0." : "0") + StringUtils.rightPad("", scale, '0') + "%";
        }
    }

    public static String getPercent(double b1, double b2, int scale, RoundingMode mode, boolean fixedScale) {
        return getPercent(NumberUtils.createBigDecimal(String.valueOf(b1)), NumberUtils.createBigDecimal(String.valueOf(b2)), scale, mode, fixedScale);
    }

    public static String getPercent(BigDecimal b1, BigDecimal b2) {
        return getPercent(b1, b2, 2, RoundingMode.HALF_UP, true);
    }

    public static String getPercent(double b1, double b2) {
        return getPercent(b1, b2, 2, RoundingMode.HALF_UP, true);
    }

    public static String getLavePercent(String... p) {
        return getLavePercent(2, RoundingMode.HALF_UP, true, p);
    }

    public static String getLavePercent(int scale, RoundingMode mode, boolean fixedScale, String... p) {
        List<BigDecimal> aList = new ArrayList();
        String[] var5 = p;
        int var6 = p.length;

        for(int var7 = 0; var7 < var6; ++var7) {
            String s = var5[var7];
            if (s.contains("%")) {
                aList.add((new BigDecimal(s.replaceAll("%", ""))).movePointLeft(2));
            } else {
                aList.add(new BigDecimal(s));
            }
        }

        BigDecimal lave = BigDecimal.ONE;

        BigDecimal b;
        for(Iterator var10 = aList.iterator(); var10.hasNext(); lave = lave.subtract(b)) {
            b = (BigDecimal)var10.next();
        }

        return getPercent(lave, BigDecimal.ONE, scale, mode, fixedScale);
    }

    public static NumberFormat getFormat(int scale, RoundingMode mode, boolean fixedScale) {
        NumberFormat format = DecimalFormat.getPercentInstance();
        format.setMaximumFractionDigits(scale);
        if (fixedScale) {
            format.setMinimumFractionDigits(scale);
        }

        format.setRoundingMode(mode);
        return format;
    }

    public static NumberFormat getFormat() {
        return getFormat(2, RoundingMode.HALF_UP, true);
    }

    public static String formatNumber(double number) {
        NumberFormat nf = new DecimalFormat("#,##0.00");
        return nf.format(number);
    }

    public static String formatLastZero(double value) {
        String index_s = String.valueOf(value);
        if (index_s.substring(index_s.indexOf(".") + 1, index_s.length()).length() == 1) {
            index_s = index_s + "0";
        }

        String r_str = "";
        String str = index_s.substring(0, index_s.indexOf("."));
        String index_one = index_s.substring(index_s.indexOf(".") + 1, index_s.indexOf(".") + 2);
        String index_two = index_s.substring(index_s.indexOf(".") + 2, index_s.indexOf(".") + 3);
        if (index_two.equals("0")) {
            if (index_one.equals("0")) {
                r_str = str;
            } else {
                r_str = str + "." + index_one;
            }
        } else if (!index_two.equals("0")) {
            r_str = index_s;
        }

        return r_str;
    }

    public static void main(String[] args) throws ParseException {
        System.out.println(formatNumber(0.0D));
    }
}


public class People {

    private String id ;
    private String name;
    private Integer score;

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getScore() {
        return score;
    }

    public void setScore(Integer score) {
        this.score = score;
    }

    public People(String id, String name, Integer score) {
        super();
        this.id = id;
        this.name = name;
        this.score = score;
    }

}

Java集合List按日期升序或降序：
 

public class Gps {

    private String  gs;

    private long  gpsTime;

    private Boolean Result;
    public Gps(String gs,long  gpsTime,Boolean Result){
        this.gs=gs;
        this.gpsTime=gpsTime;
        this.Result=Result;
    }
       List<Gps> list =  new ArrayList<>();
        Gps gps2 = new Gps("3",1650695209000L,false);
        list.add(gps2);
        Gps gps = new Gps("1",1650522409000L,true);
        list.add(gps);
        Gps gps1 = new Gps("4",1650781609000L,false);
        list.add(gps1);
        // 升序
        list.sort(Comparator.comparing(Gps::getGpsTime));
        //降序
//        Collections.sort(list, Comparator.comparing(Gps::getGpsTime, (t1, t2) -> t2.compareTo(t1)));
        System.out.println("list.get(0):"+list.get(0).toString());

测试升序：

 测试降序：

第二种写法：

List<Gps> listAgeAsc = list.stream().sorted(
        Comparator.comparing(Gps::getGpsTime)).collect(Collectors.toList());
System.out.println("Asc升序结果：" + listAgeAsc.toString());

List<Gps> listAgeDesc = list.stream().sorted(
        Comparator.comparing(Gps::getGpsTime).reversed()).collect(Collectors.toList());
System.out.println("Desc降序结果：" + listAgeDesc.toString());

经常碰到一个 前端穿了的需要新增  后端也需要删除 

Long[] department = new Long[]{ 1l,6l,3l}; 
List<Long> longList = new ArrayList<>(Arrays.asList(department));

List<SysDeptUser> deptUsers = new ArrayList<>();
SysDeptUser sysDeptUser = new SysDeptUser();
sysDeptUser.setDeptId(2L);
sysDeptUser.setUserId(3l);
SysDeptUser sysDeptUser1 = new SysDeptUser();
sysDeptUser1.setDeptId(4L);
sysDeptUser1.setUserId(4l);
deptUsers.add(sysDeptUser1);
deptUsers.add(sysDeptUser);
List<Long> deptList = deptUsers.stream().map(e -> e.getDeptId()).collect(Collectors.toList()).stream().distinct().collect(Collectors.toList());


List<Long>  list =new ArrayList<>();
list.addAll(longList);

// 先取出 交集  取的值是 2
longList.retainAll(deptList);
// 取差集 需要新增到部门表 1 3
list.removeAll(longList);
//取差集 需要删除部门表  4
deptList.removeAll(longList);

System.out.println("list"+list.toString()); //
System.out.println("longList"+longList.toString());// 2
System.out.println("deptList"+deptList.toString());

结果：

list[1, 6, 3]
longList[]
deptList[4, 2]

BellCalderon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java~lambda表达式让查询更优雅
weixin_33909059的博客
04-24 898
在java之前的版本里，如果希望从集合时查找符合条件的数据，如果先遍历他，这种写法是我们不能接受的，所以现在java有了lambda就很好的解决了这个问题，让代码更优雅一些！ /** * lambda filter. * @param list * @param predicate * @return */ public List&lt;Us...
Java中使用Lambda表达式和filter方法对List集合进行过滤
JavaWebEngineer的博客
07-17 9604
一、代码测试案例 package demo; import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; import entity.User; public class Test01 { public static void main(String[] args) { // 创建集合对象 List<User> list = new ArrayList<&
Java的Stream流快速在list中查找数据
最新发布
青莳的博客
06-18 267
输入指定字段值，快速查出list中字段值为指定值的对象。
JAVA使用Lambda表达式查找list集合中是否包含某值
weixin_43858882的博客
06-13 9121
JAVA使用Lambda表达式查找list集合中是否包含某值 for (String className : allClassName) { if (!classDetailList.stream().filter(o -> ToolUtil.equals(o.getClassName(), className)).findFirst().isPresent()) { classDetailList.add(new AftersaleStatisticDTO().setClassNa
java lambda表达式 操作list
tang19980327的博客
12-30 5074
工作中，经常遇到获取list对象中的某一个属性的集合，这里可以用lambda表达式快速获取，简化工作量 List<User> userList = userService.lambdaQuery().list(); List<String> userId = userList.stream() .map(User::getUserId) .collect(Collectors.toLi
java lambda表达式对List进行操作，包括过滤、指定字段去重、合计、分组统计、排序、列表转字符串
gdgztt的专栏
03-02 3680
java lambda表达式对list进行操作，包括过滤、指定字段去重、合计、分组统计、排序、列表转字符串，熟练使用将告别xml写复杂sql
lambda表达式的使用
黄黄黄黄黄的博客
07-14 1417
note：lambda是java1.8后新增的功能，一定要确保jdk在1.8及以上才能使用。 基本语法格式 (parameters) -> expression 或(parameters) ->{ statements; } 举例： // 1. 不需要参数,返回值为 5 () -> 5 // 2. 接收一个参数(数字类型),返回其2倍的值 x -> 2 * x // 3. 接受2个参数(数字),并返回他们的差值 (x, y) ->
java lambda表达式用法总结
08-25
Java Lambda 表达式用法总结 Java Lambda 表达式是 Java 8 中引入的一种新的编程方式，它允许开发者使用简洁的语法来表示单方法接口的实现。下面是 Java Lambda 表达式的详细用法总结： 一、什么是函数式编程？ ...
Java8新特性Lambda表达式的一些复杂用法总结
08-29
上述代码中的`filter()`和`collect()`方法演示了Lambda表达式的用法。`filter(op -> ids.contains(op.getId()))`用于从`storage`列表中筛选出id存在于`ids`集合中的对象。`collect()`方法结合`Collectors.toMap()`...
Java Lambda表达式和函数式接口实例分析
08-25
Java Lambda表达式和函数式接口是Java 8中引入的一种新特性，它允许开发者使用函数式编程风格来编写代码，从而提高代码的简洁性和可读性。本文将对Java Lambda表达式和函数式接口进行详细的分析和介绍。 函数式接口...
详细分析Java Lambda表达式
08-18
Lambda表达式的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。 Lambda表达式的好处是，它可以将函数作为参数传递给其他函数，或者将函数作为返回值返回。这使得开发者可以更方便地编写函数式...
Java Lambda表达式详解和实例
09-04
例如，在处理集合时，可以使用`forEach`方法结合Lambda表达式来遍历和操作元素。以下是一个例子： ```java String[] atp = {"Rafael Nadal", "Novak Djokovic", "Stanislas Wawrinka", "David Ferrer", "Roger ...
Java中Lambda表达式使用及详解
做笔记\记录遇到的程序bug
07-17 1065
Lambda表达式（闭包）：java8的新特性，lambda运行将函数作为一个方法的参数，也就是函数作为参数传递到方法中。使用lambda表达式可以让代码更加简洁。Lambda表达式的使用场景：用以简化接口实现。关于接口实现，可以有很多种方式来实现。例如：设计接口的实现类、使用匿名内部类。但是lambda表达式，比这两种方式都简单。/*** Description:Lambda表达式//使用lambda表达式实现接口 Test test =() -> {
Java lamda list集合判断数据是否有重复
还在活水泥的未来包工头
03-10 2229
可以使用Java 8中的Lambda表达式和Stream API来判断Java List中是否存在重复元素。
关于时间范围查询和时间类型转换和日周月数据查询【总汇】
weixin_52380943的博客
06-10 6009
时间总汇关于时间范围查询和数据类型转换和日周月数据查询自己容易出错总结
Java利用lambda表达式按照指定要求进行查询--Predicate函数式接口的使用-方法二
weixin_62971115的博客
08-07 271
6、查询出售价在1000到2000之间且库存在10到20之间的名字中包含电脑的商品的信息。8、查询出所有价格在1000到2000之间或者库存在10以下的商品的信息。4、查询出库存在10以下且商品名中包含电脑两个字的商品的信息。2、查询出所有价格在1000到2000之间的商品的信息。5、查询库存在10到20之间的商品的信息。7、查询出商品名中不包含电脑的商品的信息。1、查询出商品名中包含电脑的商品的信息。3、查询出库存在10以下的商品的信息。结果（两种方式结果相同）
java集合过滤出符合条件的List元素集合（lambda表达式）
angleofdeath9的博客
08-03 9537
在项目开发的过程中，我们经常会对List集合进行按条件的过滤，筛选出我们想要的结果或者是符合项目需求的数据。比如：我们有一批学生对象，每个学生都有自己的性别属性，但是我们想要再班级实体中筛选出这一批学生中性别为男或女的学生，我们就需要对这一批学生集合中的数据进行按条件的筛选，得到我们想要的结果。（多表连接:双向映射）......
java list.find_java~lambda表达式让查询更优雅
weixin_42332131的博客
02-24 3734
在java之前的版本里，如果希望从集合时查找符合条件的数据，如果先遍历他，这种写法是我们不能接受的，所以现在java有了lambda就很好的解决了这个问题，让代码更优雅一些！Predicate/*** lambda filter.*@paramlist*@parampredicate*@return*/public List conditionFilter(List list, Predicate...
javalambda表达式用法
04-29
Java 8 引入了 Lambda 表达式，可以让我们更方便地编写函数式接口的实现。Lambda 表达式是一个匿名函数，它没有名称，但有参数列表、函数主体和可能的返回类型。在 Java 中，Lambda 表达式可以用来替代匿名内部类，从而使代码更加简洁易懂。下面介绍一些 Lambda 表达式的用法： 1. 基本语法 Lambda 表达式的基本语法为：(参数列表) -> {函数主体}。 例如，下面是一个简单的 Lambda 表达式，它将两个整数相加并返回结果： ```java (int a, int b) -> { return a + b; } ``` 2. 省略参数类型 如果可以从上下文推断出参数类型，可以省略参数类型。例如，上面的例子可以写成： ```java (a, b) -> { return a + b; } ``` 3. 省略花括号和 return 如果函数主体只有一条语句，可以省略花括号和 return 关键字。例如，上面的例子可以写成： ```java (a, b) -> a + b ``` 4. 方法引用 如果 Lambda 表达式的函数主体可以通过方法调用的方式实现，可以使用方法引用。例如，下面的 Lambda 表达式可以使用 String 类的 toUpperCase() 方法实现： ```java (str) -> str.toUpperCase() ``` 可以使用方法引用简化为： ```java String::toUpperCase ``` 5. Predicate 接口 Predicate 接口是 Java 8 中的一个函数式接口，它接受一个参数并返回一个布尔值。常用的实现方式是筛选集合中符合条件的元素。例如，下面的代码使用 Lambda 表达式和 Predicate 接口来筛选出集合中大于 5 的元素： ```java List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); List<Integer> result = list.stream().filter(n -> n > 5).collect(Collectors.toList()); ``` 6. Consumer 接口 Consumer 接口是 Java 8 中的一个函数式接口，它接受一个参数并不返回任何值。常用的实现方式是对集合中的每个元素执行一些操作。例如，下面的代码使用 Lambda 表达式和 Consumer 接口来打印集合中的每个元素： ```java List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); list.forEach(n -> System.out.println(n)); ``` 以上是 Lambda 表达式的一些用法，希望能够对你有所帮助。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值