小编Ale*_*nko的帖子

我已经反转了字符串，并有一个 for 循环来迭代反转的字符串。

我正在计算字符，我知道我有逻辑缺陷，但我无法确定为什么会出现这个问题。

解决方案需要返回字符串中最后一个单词的长度。

我的第一个想法是向后迭代字符串（我不知道为什么我决定创建一个新字符串，我应该通过从字符串末尾递减 for 循环来迭代它）。

但从那时起，我的第二个 for 循环的逻辑应该是相同的。

我的逻辑基本上是尝试计算最后一个单词中非空格的字符，然后当 count 变量有值时，以及计数后的下一个空格计算最后一个单词的字符。

class Solution {
    public int lengthOfLastWord(String s) {
        int count = 0;
        int countWhite = 0;
        char ch;
        String reversed = "";
        for(int i = 0; i < s.length(); i++) {
            ch = s.charAt(i);
            reversed += ch;
        }
        
        for(int i = 0; i < reversed.length(); i++) {
            if(!Character.isWhitespace(reversed.charAt(i))) {
                count++;
                if(count > 1 && Character.isWhitespace(reversed.charAt(i)) == true) {
                    break;
                }
            }
        }
        return count;
        
    } …

首先我知道这两种方法的区别。

• Optional.of：用于保证不存在null，如果输入null，则nullPointException

• Optional.ofNullable: 可能为空，也可能不为空。用来灵活应对。

那么，如果我加上orElseThrow(() -> new NullPointerException("null data"))这个，结果会是一样的吗？

我想抛出带有显式内容的错误。

所以我得到Optional.ofNullable(data).orElseThrow(() -> new NullPointerException("null data")))

将其用作这是无意义的行为吗？

Optional.of(data).orElseThrow(() -> new NullPointerException("null data")))

我认为这也是可能的，但我只是用来ofNullable()使代码看起来一致。

总结一下，到底如果加上的话结果还是一样orElseThrow(nullPoint) 吗of？ofNullable

那么反而of.orElseThrow更好呢？

采取以下代码，对列表进行排序，然后对其进行过滤：

public static void main(String[] args) {
        List<Integer> list = List.of(3,2,1);
        
        List<Integer> filtered =  list.stream()
                .sorted() // Does sorted() sort the entire array first ? Then pass the entire sorted output to filter ?
                .filter(x -> x < 3)
                .collect(Collectors.toList());
        
        System.out.println(filtered);
    }

整个sort()过程是否先发生，然后传递给filter()？

那么这不是违反了流应该做的事情吗？

我的意思是，他们应该一次处理一个元素。

我有这样的n 地图：

HashMap<String,Double> map1;
HashMap<String,Double> map2; ...

我该怎么做才能将所有这些地图合并为一张地图？

我想在不丢失数据的情况下实现这一目标。

例子：

map1 has entries: {<X1, Y1>, <X2,Y2>, <X3,Y3>} 

map2 has entries: {<X1, Y6>, <X2, Y7>, <X3,Y8>}

mergedMap: {<X1, Y1+Y6>, <X2,Y2+Y7>, <X3, Y3+Y8>}

我已经尝试过这个：

ArrayList<HashMap<String, Double>> listHashMap = new ArrayList<>();
            
HashMap<String,Double> mergedMap = new HashMap<>();
for(HashMap<String,Double> map: listHashMap) {  
    mergedMap.putAll(map);          
}

但我知道映射到同一键的值将被替换（put），而不是添加。

我该怎么做才能将映射到同一键的每个值相加？

我试图了解如何调用非终端流操作。

Stream.of("aaa", "bbb", "ccc")
        .map(s -> {
            System.out.println(s);
            return s.toUpperCase();
        });
//prints nothing

Stream.of("aaa", "bbb", "ccc")
        .map(s -> {
            System.out.println(s);
            return s.toUpperCase();
        })
        .forEach(s -> {});
//prints "aaa" "bbb" "ccc"

这对我来说似乎很清楚。

第一个流未以终端操作结束，因此它不会调用非终端操作，并且不会打印任何内容。第二个有终端操作，因此所有元素都会被打印。

Stream.of("aaa", "bbb", "ccc")
        .map(s -> {
            System.out.println(s);
            return s.toUpperCase();
        })
        .findFirst();
//prints "aaa"

Stream.of("aaa", "bbb", "ccc")
        .map(s -> {
            System.out.println(s);
            return s.toUpperCase();
        })
        .filter(s -> s.startsWith("B"))
        .findFirst();
//prints "aaa" "bbb"

这是我感到困惑的地方，尤其是最后一个。看起来该流在某种意义上是“向后”工作的。首先，它检查终端操作返回哪些元素，然后仅对这些元素执行中间操作。但最后一个怎么解释呢？看起来它对所有元素进行了映射，直到第一个与过滤器匹配的元素为止。在最后一个示例中，如果我替换findFirst()为forEach()，它会打印所有元素，即使它最后只有一个元素。

对我来说似乎有点违反直觉。谁能给我正确的解释流如何识别它应该执行中间操作的元素？

给定以下类Order和Item以及 s 的列表Order。

@Getter
@AllArgsConstructor
@ToString
public class Order {
    String customerName;
    List<Item> items;
}

@Getter
@AllArgsConstructor
@ToString
@EqualsAndHashCode
public class Item {
    long id;
    String name;
}

我需要创建一个映射Map<String,Set<String>> itemsByCustomerName，其中键是客户名称以及属于该客户名称Order的所有名称的一组名称。Item

输入示例：

List<Order> orders = List.of(
        new Order("John", List.of(new Item(1, "A"), new Item(2, "B"), new Item(3, "C"))),
        new Order("Alex", List.of(new Item(1, "A"), new Item(8, "H"), new Item(11, "K"))),
        new Order("John", List.of(new Item(1, "A"), new Item(6, "F"), new Item(7, "G"))),
        new …

我想生成一个数组，其内容代表两个给定字符串数组的笛卡尔积。

换句话说，我需要将String第一个数组中的每个arr1与String第二个数组中的每个连接起来arr2。

这是我的代码：

String[] arr1 = {"a", "b", "c"};
String[] arr2 = {"d", "e", "f"};

String[] result = new String[arr1.length * arr2.length];

for (int k = 0; k < result.length; k++) {
    for (int i = 0; i <arr1.length; i++) {
        for (int j = 0; j < arr2.length; j++) {
            result[k] = arr1[i] + arr2[j];
        }
    }
}

System.out.println(Arrays.toString(result));

电流输出：

[cf, cf, cf, cf, cf, cf, cf, cf, cf]

期望的输出： …

如何创建Map<String,List<Product>> 如下。这里，String(的keyMap ) 是categorya 的Product。

一种产品可以属于多个类别，如下例所示。

我正在尝试使用以下代码，但无法进行下一步操作：

products.stream()
    .flatMap(product -> product.getCategories().stream())
    . // how should I progress from here?

结果应如下所示：

{电子=[p1,p3,p4], 时尚=[p1,p2,p4], 厨房=[p1,p2,p3], abc1=[p2], xyz1=[p3],pqr1=[p4]}

Product p1 = new Product(123, Arrays.asList("electonics,fashion,kitchen".split(",")));
Product p2 = new Product(123, Arrays.asList("abc1,fashion,kitchen".split(",")));
Product p3 = new Product(123, Arrays.asList("electonics,xyz1,kitchen".split(",")));
Product p4 = new Product(123, Arrays.asList("electonics,fashion,pqr1".split(",")));
List<Product> products = Arrays.asList(p1, p2, p3, p4);

class Product {

    int price;
    List<String> categories;

    public Product(int price) { …

假设我们有一个动物流。

我们有不同的动物子类，并且我们希望在流上应用过滤器以仅包含流中的斑马。我们现在仍然有动物流，但只包含斑马。为了获得斑马流，我们仍然需要进行投射。

Stream<Zebra> zebraStream = animalStream
    .filter(Zebra.class::isInstance)
    .map(Zebra.class::cast);

Java 14 引入了instanceof 的模式匹配，所以我们现在可以使用：

if (animal instanceof Zebra zebra) {
    System.out.println(zebra.countStripes());
}

有没有办法在流管道中使用模式匹配？当然你可以这样做：

Stream<Zebra> zebraStream = animalStream.map(animal -> {
        if (animal instanceof Zebra zebra) {
            return zebra;
        }
        return null;
    })
    .filter(Objects::nonNull);

但恕我直言，这真的很难看。

peek关于Java Streams API有很多问题。我正在寻找一种使用 Java Streams 完成以下常见模式的方法。我可以让它与 Streams 一起工作，但它是不明显的，这意味着如果没有评论的话会有点危险，这并不理想。

boolean anyPricingComponentsChanged = false;
for (var pc : plan.getPricingComponents()) {
    if (pc.getValidTill() == null || pc.getValidTill().compareTo(dateNow) <= 0) {
        anyPricingComponentsChanged = true;
        pc.setValidTill(dateNow);
    }
}

我的选择：

long numberChanged = plan.getPricingComponents()
    .stream()
    .filter(pc -> pc.getValidTill() == null || pc.getValidTill().compareTo(dateNow) <= 0)
    .peek(pc -> pc.setValidTill(dateNow))
    .count(); //`count` rather than `findAny` to ensure that `peek` processes all components.

boolean anyPricingComponentsChanged = numberChanged != 0;

顺便说一句， whilecompareTo在这里并不是一个昂贵的操作，并且始终返回相同的结果，在其他情况下这可能不是真的，我宁愿避免为此模式多次运行它。