使用streams返回字母所在字符串的总和

Question

我有一个单词列表（编程语言），我想找出字母表中的哪个字母出现在这些单词中，然后将这些单词的字符串总长度相加，最后返回一个字母，返回与这些单词匹配的最长字符串。这是我到目前为止所得到的，我几乎没有进一步的进展。

这是我试图更好地理解java流的一个练习。

package com.example;

import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class DemoApplicationTests {

    @Test
    public void argh() {

        List<String> list = new ArrayList<>();
        list.add("java");
        list.add("php");
        list.add("python");
        list.add("perl");
        list.add("c");
        list.add("lisp");
        list.add("c#");

        Supplier<Stream<String>> streamSupplier = () -> list.stream();
        IntStream.range('a', 'z').forEach(i -> {
                int strlen = streamSupplier.get()
                    .filter(k -> {
                            char ch = (char) i;
                            return k.contains("" + ch);
                        }
                    )
                    .map(s -> s.length())
                    .mapToInt(Integer::new)
                    .sum();
                System.out.println((char) i + " : " + strlen);
            }
        );
   }
}

我期望的最终输出（结果）类似于“p:17”

由于字符p出现在单词php、python、perl、lisp中，它对这些单词求和并返回字符串长度为17。

最好是在

map<String,int> with the size of 1

或者只包含最长字符串的东西。

这里有一些伪代码，关于我如何用“普通”java编写它：

int previousSum = 0;
for (string ch in ('a' to 'z') ) {
    int stringlengthSum =     findallMatchesInListandSumStringlength(stringlist,ch);
if (stringlengthSum > previousSum) {
    previousSum = stringLengthSum;
    longestCharacter = ch;
}
}
System.out.println("The longest sum is: " + previousSum + " by the character: " + longestcharacter);

Answer 1

你离得很近，基本上只是错过了流的顺序。

为了使整个排序更加容易，您可以创建一个专用类：

class CharacterLengthSumResult implements Comparable<CharacterLengthSumResult> {
        final char c;
        final int sum;

        CharacterLengthSumResult(char c, int sum) {
            this.c = c;
            this.sum = sum;
        }

        @Override
        public int compareTo(CharacterLengthSumResult o) {
            return Integer.compare(o.sum, sum);
        }
    }

然后，流逻辑变成：

Optional<CharacterLengthSumResult> first = IntStream.range('a', 'z').mapToObj(i -> {
            String c = ((char) i) + "";
            int sum = list.stream().filter(s -> s.contains(c)).mapToInt(String::length).sum();
            return new CharacterLengthSumResult((char)i, sum);
        }).sorted().findFirst();

        if (first.isPresent()) {
            System.out.println(first.get().c + " -> " + first.get().sum);
        }

如果你想把整个东西作为一张地图，你可以用一个收集器来扩展排序：

...sorted().collect(Collectors.toMap(s -> s.c, s -> s.sum));

Answer 2

我不得不稍微修改和优化你的代码。最终解决方案将是：

Map.Entry<Integer, Integer> max = IntStream.range('a', 'z').boxed().collect(Collectors.toMap(i -> i, i -> list.stream()
        .filter(k -> k.contains("" + (char) i.intValue()))
        .map(String::length)
        .mapToInt(Integer::new)
        .sum()))
        .entrySet().stream()
        .max((e1, e2) -> e1.getValue().compareTo(e2.getValue())).get();

System.out.println((char)max.getKey().intValue() + ":" + max.getValue()); 

变化是：

1） 将IntStream转换为Stream

2） 收集对：符号的int值-

至少3）找到包含最大元素的地图条目