小编nop*_*ens的帖子

我得到了一些自定义对象的流，我想创建一个Map<Integer, MyObject>以每个对象的索引为键的映射。给你一个简单的例子：

Stream<String> myStream = Arrays.asList("one","two","three").stream();
Integer i = 0;
Map<Integer, String> result3 = myStream.collect(Collectors.toMap(x -> i++, x -> x));

显然，这不能编译，因为：

从lambda表达式引用的局部变量必须是final或有效的final

有没有一种简单的方法可以将流的元素映射到它们的索引，以使上述示例的预期输出类似于：

{1=one, 2=two, 3=three}

我想验证一个字符串，它应该遵循XXYYZZX、Y、Z 可以是任何字母 az、AZ 或 0-9 的模式。

有效字符串示例：

RRFFKK
BB7733
WWDDMM
5599AA

无效：

555677
AABBCD

现在我正在使用正则表达式拆分字符串(?<=(.))(?!\\1)并迭代结果数组并检查每个子字符串的长度是否为 2。

String str = "AABBEE";
boolean isValid = checkPattern(str);

public static boolean checkPattern(String str) {
   String splited = str.split("(?<=(.))(?!\\1)");
   for (String s : splited) {
       if (s.length() != 2) {
         return false;
       }
   }
   return true;
}

我想替换我的检查方式String#matches并摆脱循环，但无法提出有效的正则表达式。有人可以帮助someRegex在下面的代码段中放入什么吗？

public static boolean checkPattern(String str) {
    return str.matches(someRegex);
}

我有三个Integer变量，我不允许更改为原始变量，int我需要检查其中至少一个的值是否大于 0。是否有更短/更简洁的方法来重写下面的代码：

Integer foo = // null or some value
Integer bar = // null or some value
Integer baz = // null or some value

boolean atLeastOnePositive = (foo != null && foo > 0) || (bar != null && bar > 0) || (baz != null && baz > 0)

return atLeastOnePositive;

我正在尝试解决此作业：

假设人们进入一个空房间，直到一对人共同过生日。平均而言，一场比赛之前，有多少人必须进入？运行实验以估算此数量的价值。假设生日是0到364之间的统一随机整数。

平均值是24.61659。有关数学，请参见此维基百科页面。生日问题

我的方法：

• 生成范围为[0-364]的随机数
• 将它们添加到集合中，直到生成重复项为止（set.add返回false）
• 将计数（或设置大小）添加到列表
• 重复这个X次
• 计算列表的平均值

码：

public static void main(String[] args) {        
    List<Integer> list = new ArrayList<>();
    for(int i = 0; i<10000; i++){
        int count = 0;
        Set<Integer> set = new HashSet<>();
        while(set.add(ThreadLocalRandom.current().nextInt(0, 365))){
            count++;
        }
        list.add(count);
    }
    double avg = list.stream().mapToInt(Integer::intValue).average().getAsDouble();
    System.out.println(avg);
}

我的输出始终低于24。例如23.6285

• 我试图运行for循环1000、10000、1000000次
• 我试过ThreadLocalRandom.current().nextInt(0, 365)，nextInt(0, 364)，nextInt(0, 366)
• 我试着list.add(count);和list.add(set.size());

但是我总是平均低于24。主要是23.629237。

您是否看到任何错误以及为什么我没有得到正确的值（大约）。？24.61659？

我想创建一个整数序列，最好是一个IntStream遵循特定条件的 。一些简单的例子来解释我想要做什么：

从 0 开始的前 10 个偶数的序列（这里我没有问题，我用下面的代码片段来做）

IntStream.iterate(0, i -> i + 2).limit(10); 

//0,2,4,6,8,10,12,14,16,18

前 10 个数字从 0 开始的序列，交替添加 2 和 3 到原始数字；所需的输出：

 //0,2,5,7,10,12,15,17,20,22

我很愿意也使用了此方案 IntStream.iterate()还是IntStream.generate()，但不能让它在我自己的。我正在使用经典的 for 循环，它可以工作，但对于这样一个相对简单的任务来说有点长

List<Integer> list = new ArrayList<>();
list.add(0);
for(int i = 1, j = 1; i < 10; i++, j *= -1){
    if(j > 0){
        list.add(list.get(i-1) + 2);
    }
    else{
        list.add(list.get(i-1) + 3);
    }
}

//and then stream over the list to get IntStream
list.stream().mapToInt(Integer::intValue);

使用IntStream.iterate()或实现与上述相同的任何简单方法 IntStream.generate() …

我有课

public class Gezana {
    private String name;
    private long value;
}

和一个类似的列表：

List<Gezana> list = List.of(new Gezana("foo", 2), 
                            new Gezana("foo", 2),
                            new Gezana("foo", 2),
                            new Gezana("foo", 2), 
                            new Gezana("bar", 5),
                            new Gezana("bar", 5), 
                            new Gezana("bar", 5), 
                            new Gezana("doo", 9), 
                            new Gezana("doo", 9),
                            new Gezana("kee", 12));

我需要使用上面的列表创建一个地图，其中名称作为键，值的总和作为值。我曾经通过以下方式做到这一点：

Map<String, Long> oldMap = new HashMap<>(); 
for (Gezana gez : list) {            
    if (oldMap.containsKey(gez.getName())) {
        oldMap.put(gez.getName(), oldMap.get(gez.getName()) + gez.getValue());
    } else{
        oldMap.put(gez.getName(), gez.getValue());
    }          
}        
System.out.println("old map:" + oldMap);

我需要重构上面的内容并考虑使用Map.computeIfAbsent & Map.computeIfPresent …

我需要一个方法，我需要对谓词进行异或，我将其作为方法参数接收。对于两个谓词，我有一个有点工作但很麻烦的解决方案。举一个简单的、最小的和可重复的例子：

Predicate<String> pred1  = s -> s.contains("foo");
Predicate<String> pred2  = s -> s.contains("bar");
    
String toTest = "foobar";

对于给定的谓词和测试字符串，逻辑OR将返回true：

boolean oneOnly   = pred1.or(pred2).test(toTest);

但对于我的用例，它应该返回 false，因为包含两个子字符串。当且仅当满足一个条件时，它才应该返回 true。

对于两个prdeicates我有这个

static boolean xor(Predicate<String> pred1, Predicate<String> pred2, String toTest){
    return pred1.and(pred2.negate()).or(pred2.and(pred1.negate())).test(toTest);
}

是否有一种简单但方便的方法来异或谓词？

我需要检查字符串是否只包含给定字符类中的一个不同字符。一些简单的例子：

"aa", "bbbbb", "c"匹配此正则表达式[abc]+，但正则表达式也匹配"abbb" or "abcbb"在我的情况下无效的正则表达式。因此我无法使用它。

示例代码：

String[] input = {"a", "aaa", "ab", "b", "bbbb", "abc", "ccc"};
for(String str :input){
    if(str.matches("[abc]+")){
        System.out.println(str + ": valid");
    }
    else {
        System.out.println(str + ": not valid");
    }
}

上面的内容将为输入数组中的每个字符串打印有效的内容，这不是我想要的。有效输入只是具有不同字符的字符串。我可以通过以下方式实现它，我需要or在 if 语句中使用多个。

for(String str :input){
    if(str.matches("[a]+")||str.matches("[b]+")||str.matches("[c]+")){
        System.out.println(str + ": valid");
    }
    else {
        System.out.println(str + ": not valid");
    }
}

如何获得与第二种方法相同的结果，但写得紧凑，因为当字符类增长并且字符类发生变化时，这将不可读，我需要更改 if 条件？

预期的：

a: valid
aaa: valid
ab: not valid
b: valid
bbbb: valid
abc: not …

如何按一系列可能的值对列表进行分组？如果我有一个类 Foo

class Foo{
   int value;
}

和一个 foosList<Foo>列表然后

list.stream().collect(Collectors.groupingBy(Foo::getValue));
            

将我的具有相同价值的 foos 收集到一组中。但我想将一系列值归为一组。例如

values < 5 in group "A"
values > 5 && < 25 in group "B"
values >= 25  in group "C"

或者另一个例子：假设我有一个整数列表：

List<Integer> list = List.of(2,3,4,9,11,17,28,29,32);
list.stream().collect(Collectors.groupingBy(
            classifier, 
            Collectors.toList()));

我试图把类似的东西放到分类器

 i < 5 ? "A": i >= 5 && i < 25 ? "B" : "C";

这给出了编译错误。怎么做？