标签: java-8

我每分钟在一个线程中验证目录中的许多文件.目前我正在使用下面的功能,工作正常.我的问题是我是否可以重写此方法以更快地运行(java8？),并希望缩短.

public boolean validateFile(String fileName) {
    fileName = fileName.substring(0, fileName.lastIndexOf('.'));
    String[] values = fileName.split("_");
    if (values.length == 4) {
        if(!values[1].matches("0*")) {
            if(!fileName.contains(" ")) {
                if(values[3].equals("PASS") || values[3].equals("FAIL")) {
                    return true;
                }
            }
        }
    }
    return false;
}

验证规则:

1. 文件名不能包含任何空格字符.
2. 文件名拆分器始终为_字符.
3. 值[1]不能只包含零(0).它必须有12位数字.
4. 值[3]必须包含"PASS"或"FAIL".
5. 数组值[]长度必须始终为4.

您可以使用http://ideone.com/dh8j9M上的文件名示例运行和分叉此代码

我正在尝试学习Java8。是否可以将下面的方法转换为Java 8 Streams filter和forEach。如果是这样，怎么办？

protected void isValidId(CarModel model, List<String> errors) throws DataAccessException {

    CarStyle[] styles = model.getStyles();

    for(CarStyle style : styles){
        if(!style.isModels()){
            if(style.getStyleId() > 99){
          errors.add(INVALID_ID + ", Id:" + style.getStyleId());

            }
        }
    }
}

我阅读了一些有关Java 8的教程，但不确定如何实现。谢谢。

编辑：我向该方法添加了一个列表。

从这个链接,我只是部分理解,至少在某些时候,java嵌套并行流存在问题.但是,我无法推断出以下问题的答案:

假设我有一个外部srtream和一个内部流,两者都使用并行流.事实证明,根据我的计算,如果内部流首先完全并行完成,那么它将更高效(由于数据位置,即L1/L2/L3 CPU缓存中的缓存)(如果且仅cpu核心可用)做外部流.我认为这对大多数人的情况都是如此.所以我的问题是:

Java会首先并行执行内部流,然后在outerstream上工作吗？如果是这样,它是在编译时还是在运行时做出决定？如果在运行时,JIT甚至足够聪明地意识到如果内部流确实具有比核心数量(32)更多的元素(例如数百个),那么它肯定应该使用所有32个内核来处理在从外部流移动下一个元素之前的内部流; 但是,如果元素的数量很小(例如<32),则可以"并行处理"来自"下一个"外部流的元素的元素.

我被告知不要.anyMatch(Predicate.isEqual(true))被同事使用.原因是,它不是无效的.他们建议我应该使用Optional<Boolean>.

我有一个帐户列表,我想true只有在帐户有未偿还的活跃贷款时才返回布尔值,否则返回false.

@Data
public class Account {
    private String accountNumber;
    @Getter(AccessLevel.NONE)
    private Boolean activeLoan;
    private String accountReference;
    private Double balance;
    private String status;

    public Boolean hasActiveLoan() {
        return activeLoan;
    }
}

换句话说,只有当hasActiveLoan()等于真时.

以下是我提出的解决方案:

 Boolean checkActiveLoanRule(List<Account> accounts) {

         Optional<Boolean> loanAccountExists = Optional.of(accounts.stream()
                .map(Account::hasActiveLoanAccount)
                .anyMatch(Predicate.isEqual(true)));

         return loanAccountExists.equals(Optional.of(true));
     }

这可以重构以某种方式改进吗？还有其他想法吗？

最重要的是,这样的解决方案是线程安全的吗？

在下面的代码中,我从列表中获取所有元素并在之后拆分文本"(".

for (WebElement element : measureKeys) {
    String[] measure = element.getText().split("\\(");
    testing.add(measure[0])
}

如何在上面的代码中使用lambdas

我有一个用例需要在这个对象中总结不同的字段,所以我这样编码,我可以把它放在一个流中吗？

int totalUnits = records.stream()
        .mapToInt(DynamoSalesAggregateSummaryRecord::getUnits).sum();
int totalReturns = records.stream()
        .mapToInt(DynamoSalesAggregateSummaryRecord::getReturns).sum();
int totalCancellations = records.stream()
        .mapToInt(DynamoSalesAggregateSummaryRecord::getCancellations).sum();
BigDecimal totalRevenue = records.stream()
        .map(DynamoSalesAggregateSummaryRecord::getRevenue)
        .reduce(BigDecimal.ZERO, BigDecimal::add);
BigDecimal totalRoyalties = records.stream()
        .map(DynamoSalesAggregateSummaryRecord::getRoyalties)
        .reduce(BigDecimal.ZERO, BigDecimal::add);

我试图找出一个简单的转换的最优雅的方式int排列(例如{1, 2, 3}),以一个简单的String阵列(例如,{"id", "1", "id", "2", "id", "3"}使用Java 8流串对).

传统上代码如下: -

int[] input = {1, 2, 3};

String[] output = new String[input.length * 2];

int i = 0;
for (int val : input) {
    output[i++] = "id";
    output[i++] = String.valueOf(val);
}

但假设这可以在Java 8中用1-liner完成.

我试图找出以下代码无法编译的原因:

Function<Employee, String> getLastName = (Employee employee) -> {
    return employee.getName().substring(employee.getName().indexOf(" ") + 1);
};

Function<Employee, String> getFirstName = (Employee employee) -> {
    return employee.getName().substring(0, employee.getName().indexOf(" "));
};

Function chained = getFirstName.apply(employees.get(2).andThen(getFirstName.apply(employees.get(2)))); 

不能在java 8中包含所有函数吗？

我有一张地图: Map<String, Map<String, String>> x

我想计算第二张地图中的值总和:

x.values().stream().mapToDouble(y -> Double.parse(y.get("myKey"))).sum();

但是,如果y.get("myKey")不是有效数字,它将按预期抛出错误...有没有办法可以避免它并只传递有效数字

我看到来自guava库的Doubles.tryParse会返回null,因为它不可解析.但我无法弄清楚如何使用它来只加总有效数字.

如何合并两个BehaviorSubjects,使它们表现得像一个BehaviorSubject？

我有这样的事情:

class Solution {
    public static void main(String[] args) {
        Subject<List<Integer>> left = BehaviorSubject.createDefault(Arrays.asList(1, 2, 3));
        Subject<List<Integer>> right = BehaviorSubject.createDefault(Arrays.asList(4, 5, 6));
        Single<List<Integer>> merged = left.mergeWith(right).reduce(new ArrayList<Integer>(), (l, r) -> {
            List<Integer> merged1 = new ArrayList<>(l.size() + r.size());
            merged1.addAll(l);
            merged1.addAll(r);
            return merged1;
        });
        merged.subscribe(System.out::println);
    }
}

我希望得到一些东西[1, 2, 3, 4, 5, 6],但subscribe什么都不打印.