Question

我想重构此代码以使用lambda表达式Java 8

for(int i = 0; i < customers.getCUSTOMER().size(); i++){
   if (customers.getCUSTOMER().get(i).getINCOME().getGROSSMONTH1().toBigInteger()
     < customers.getCUSTOMER().get(i).getINCOME().getNETTSALMONTH1().toBigInteger()){

        log.error("")
        throw new RuntimeException();
   }
}

Answer 1

customers.getCUSTOMER().stream().forEach(customer -> {
    if(customer.getINCOME().getGROSSMONTH1().toBigInteger() < customer.getINCOME().getNETTSALMONTH1().toBigInteger()){
      log.error("");
      throw new RuntimeException();
    }
});

您还应该尝试使用camelcase重命名您的方法，例如getIncome（），以使其更易于阅读并符合常规Java编写标准。

Answer 2

customers.getCUSTOMER().forEach(customer -> {
        if (customer.getINCOME().getGROSSMONTH1().toBigInteger() < 
             customer.getINCOME().getNETTSALMONTH1().toBigInteger()) {
            log.error("")
            throw new RuntimeException();
        }
 });

一种简单的方法

使用流和可选的另一种方式：

  customers.stream().filter(customer ->    
            customer.getINCOME().getGROSSMONTH1().toBigInteger() < 
             customer.getINCOME().getNETTSALMONTH1().toBigInteger())
       .findAny().ifPresent(c -> {
           log.error("")
           throw new RuntimeException();
    });;

Answer 3

您正在遍历customers.getCUSTOMER()的元素，这些元素似乎是List（为此回答，我假设它是一个）。大概，然后，您将处理该列表的流：

customers.getCUSTOMER().stream()

您正在两次使用每个元素的getINCOME()，而根本没有使用它的任何其他方面，因此也许您想通过该方法映射元素。假设客户列表中的元素类型为Customer，则可能是

        .map(Customer::getINCOME)

有多种方法可以解决，但是由于满足条件时会引发异常，因此我个人会选择Stream.anyMatch()：

        .anyMatch(x -> x.getGROSSMONTH1().toBigInteger().compareTo(
                x.getNETTSALMONTH1().toBigInteger()) < 0)

这会产生一个布尔结果，告诉您是否有任何元素满足条件，并且一旦找到满足条件的元素，它就会停止查找（并且anyMatch()的谓词是lambda）。您可以在if表达式中使用它，类似于现在的表达式：

if (customers.getCUSTOMER().stream()
        .map(Customer::getINCOME)
        .anyMatch(x -> x.getGROSSMONTH1().toBigInteger().compareTo(
                x.getNETTSALMONTH1().toBigInteger()) < 0) {
    log.error("")
    throw new RuntimeException();
}

由于您要抛出RuntimeException，因此也可以在流中使用lambda来执行此操作，但是如果您抛出了Checked，通常是不可能的例外。在检查例外情况下，通常需要遵循此处介绍的内容。

另一方面，如果您想记录有关失败元素的信息，则需要在流中进行操作。此外，在这种情况下，您可能要跳过map()。您可以改为基于谓词filter()，并保留元素中的findFirst()（如果有的话）（或者findAny()，如果您不在意它是否是第一个报告的元素）。结果是一个Optional，您可以使用另一个lambda对其进行处理：

customers.getCUSTOMER().stream()
        .filter(x -> x.getINCOME().getGROSSMONTH1().toBigInteger().compareTo(
                x.getINCOME().getNETTSALMONTH1().toBigInteger()) < 0)
        .findFirst()
        .ifPresent(x -> {
            log.error(x.getName() + " invalid: net salary is larger than gross")
            throw new RuntimeException();
        });

请注意，这不能解决检查异常问题。您不能从ifPresent lambda内部抛出已检查的异常。

Answer 4

通过使用Java-8流，使用filter作为条件，findFirst在一次匹配后终止

customers.getCUSTOMER().stream()
                       .filter(c->c.getINCOME().getGROSSMONTH1().toBigInteger() < c.getINCOME().getNETTSALMONTH1().toBigInteger())
                       .findFirst()
                       .ifPresent(cu->{
                               log.error("")
                               throw new RuntimeException();
                           });

Answer 5

在这种情况下，您需要的是BiPredicate<TypeOfMonths>，它看起来像这样

BiPredicate<TypeOfMonths> biPredicate = (tom1, tom2) -> tom1.toBigInteger() < tom2.toBigInteger();

然后像这样使用它

boolean shouldThrowException = customers.getCUSTOMER()
                                        .stream()
                                        .anyMatch(cust -> {
                                            TypeOfMonth tom1 = getINCOME().getGROSSMONTH1();
                                            TypeOfMonth tom2 = getINCOME()..getNETTSALMONTH1();
                                            return biPredicate.test(tom1, tom2);
                                        });

if (shouldThrowException) {
    log.error("");
    throw new RuntimeException();
}

在Java 8

5 个答案: