标签: java-8

我有来自用户的三个输入

字符串key1
字符串key2
字符串key3

用户一次只能传递一个键作为输入。我正在验证它如下。

在我的代码中，我正在检查

if(key1 == null && key2 == null && key3 == null){
      throw new Exception("invalid input");
}else if((null != key1 && null != key2) || (null != key2 && null != key3) || (null != key1 && null != key3)){
    throw new Exception("invalid input");
}

我们可以避免这些or条件吗？可能正在使用Java-8？

对此的任何想法/建议将不胜感激。

注意：我有一个 JUnit 测试代码，所以我也需要减少测试用例的数量。

我想根据一个字段将三种不同类型的列表合并到一个列表中。

A(id, val1)
B(id, val2)
C(id, val3)
D(id, val1, val2, val3)

List<A> AList;
List<B> BList;
List<C> CList;

List<D> DList;

使用流和谓词将 AList、BList、CList 合并到 DList。

一种方法是首先使用 n^2 复杂度合并 AList 和 BList 以获得 DList（带有 val1 和 val2）；然后循环 DList 以再次使用 n^2 用 CList 填充 val3。所以复杂性将是 n^2 + n^2 = n^2

一季度。有没有更好的方法来提高复杂性？Q2。我想使用 Predicate 和 Stream 来解决这个问题，所以使代码可读性强。

哪里return;在Stream.forEach()休息控制？

我预计在打印此语句后，forEach 将退出并进入方法的其余部分。

返回 nMissing: 2

但是相反，我发现它反而返回处理流的其余部分。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class MissingKInteger {
    int currentItem = 0;
    int nMissing = 0;
    ArrayList<Integer> al = new ArrayList<Integer>();

    public int findKthPositive(int[] arr, int k) {
        Arrays.stream(arr).forEach(x -> {
            System.out.format("--- examine x %d ---\n", x);
            if (x - currentItem == 1) {
                currentItem++;
                System.out.format("step. currentItem %d, nMissing %d\n", currentItem, nMissing);
            } else {
                do {
                    nMissing++;
                    currentItem++;
                    al.add(currentItem);
                    System.out.format("loop. currentItem %d, nMissing …

问题：哪种方法更好，为什么

1- 使用 Apache Commons

if(StringUtils.isNotBlank(str) {
     list.add(str)
}

2- 可选和过滤器

Optional.ofNullable(str)
                .filter(s -> StringUtils.isNotBlank(s))
                .ifPresent(result -> list.add(result));

我有以下格式的列表，我想将此列表分组为分钟间隔。

 List<Item> myObjList = Arrays.asList(
                new Item(LocalDateTime.parse("2020-09-22T00:13:36")), 
                new Item(LocalDateTime.parse("2020-09-22T00:17:20")),
                new Item(LocalDateTime.parse("2020-09-22T01:25:20")),
                new Item(LocalDateTime.parse("2020-09-18T00:17:20")),
                new Item(LocalDateTime.parse("2020-09-19T00:17:20")));

例如，给定 10 分钟的间隔，列表的前 2 个对象应该在同一个组中，第三个应该在不同的组中，依此类推。

可以使用 Java 的 8groupingBy函数将此 List 分组为间隔吗？

我的解决方案是将列表中的每个日期与列表中的所有其他日期进行比较，并在新列表中添加不同 X 分钟的日期。这似乎是非常缓慢和“hacky”的解决方法，我想知道是否有更稳定的解决方案。

我在ArrayListas 中有值Value1, Value2, Value3。
现在我需要String像Value1_Value2_Value3使用 Java一样以 Single 的方式返回它们Streams。

我试过这个，但没有用

myList.stream().map((s)->s+"_").toString();

我也尝试过，collect(toList());但我不确定如何进一步将其转换为String.

我该怎么做？

题：

举一个ArrayList的Player秒- List<Player>。以一个Player与POJO String Name，int age和int runs。使用list.add.

找到第一个年龄小于 30 且跑数大于 5000 的玩家并打印姓名。否则打印“没有选择参加世界杯的球员”

POJO类：

public class Player {
    String name;
    int age;
    int runs;
    
    public Player(String name, int age, int runs) {
        super();
        this.name = name;
        this.age = age;
        this.runs = runs;
    }
    
    @Override
    public String toString() {
        return "Player [name=" + name + "]";
    }
}

逻辑：

List<Player> players = Arrays.asList(
    new Player("Sachin",45,10252),
    new Player("Virat",29,7000),
    new …

我有以下 Dto 类：

@AllArgsConstructor
@ToString
@Getter
public class Dto {
    private String cityName;
    private String personName;
}

我想从上面的 Dtos 列表创建一个 Map<String, List>。逻辑是这样的，所有具有相同城市的Dto都应该以该城市名称作为关键字一起列出。可以使用普通的 foreach 轻松完成，但我想知道这是否可以使用 Java 8 完成。

可以使用computeIfAbsent、computeIfPresent、stream.collect(toMap())等来做些什么吗？

public class Runner {
    public static void main(String[] args) {
        Map<String, List<Dto>> map = new HashMap<>();
        List<Dto> tempList = null;

        List<Dto> dtos = Arrays.asList(
                new Dto("Indore", "A"),
                new Dto("Indore", "B"),
                new Dto("Pune", "C"),
                new Dto("Pune", "D")
        );

        for (Dto dto : dtos) {
            if(map.containsKey(dto.getCityName())) {
                map.get(dto.getCityName()).add(dto);
            }
            else {
                tempList = new …

我有两个班级 A 级和 B 级。如下：

A类：

class A {

  public String a;

  public A() {

  }

  public A(final String a) {
    this.a = a;
  }
}

B类：

class B {

  private A a;

  private String b;

  public B() {

  }

  public B(final A a) {
    this.a = a;
  }
}

我将 A[] 转换为 B[] 的地方如下：

public static void main(final String[] args) {

    final A[] myA = new A[3];
    myA[0] = new A("a");
    myA[1] = new A("b");
    myA[2] = new A("c"); …

我试图更好地理解方法引用是如何工作的。在这个例子中，我遵循了代码的逻辑，但我不明白这样做的价值。基本上，在 STEP 2 中的方法引用赋值之后，someMethod() 被用作 MyInterface 的 display() 抽象方法的实现。但为什么呢？这样做我们得到了什么？这在架构上什么时候有意义？好像我们把与类无关的Interface和这个赋值关联起来。

@FunctionalInterface
interface MyInterface {
       void display();
}

class DerivClass {
    public void someMethod(){  
            System.out.println("Derived class method");  
    }
}

public class RefTest {

    public static void main(String[] args) {
        DerivClass dc = new DerivClass(); // STEP1: class instance
        MyInterface myInterf = dc::someMethod; // STEP 2: assign method ref to interface    
        myInterf.display(); // STEP 3: executes someMethod(), prints "Derived class method"
    }
}