标签: java-stream

我想在 java 中的字符串列表中计算单个单词的出现次数。看似这个任务很简单，但我遇到了一个问题，单词以大写字母开头或包含,或.在单词末尾。我的方法看起来像：

public static Long countWordOccurence(List<String> wordList, String word) {

    return wordList.stream()
        .filter(s -> word.contains(s))
        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
        .values()
        .stream()
        .findFirst()
        .orElse((long) -1);
  }

上面的代码在正常情况下工作正常，但问题发生在像字符串末尾的昏迷Test,或以大写字母开头的字符串这样的角落情况下。

我正在拆分我的字符串列表，如：

Arrays.asList(TEXT_TO_PARSE.split(" ")); 

如果可能的话，我会很感激避免额外的依赖，但如果有必要，我不会鄙视。

我将不胜感激关于如何在流中修复我的过滤器子句以正确计算字符串的建议。

如果我在流上执行多个操作，它们是如何在内部计算的。

1. 它是否以与输入集合相同的顺序计算？
2. 它是否将函数应用于所有元素，然后移动以评估下一个函数？或者它将所有功能应用于一个元素，然后是第二个元素......依此类推。
3. 在性能方面，它与对集合执行的正常迭代有何不同。

    List<Integer> ee = new ArrayList<Integer>();
    Function<? super Integer, ? extends Integer> f1 = x -> x * 2;
    Function<? super Integer, ? extends Integer> f2 = x -> x * x;
    Function<? super Integer, ? extends Integer> f3 = x -> x / 2;
    ee.stream().map(f1.compose(f2.andThen(f3))).collect(Collectors.toList());

    ee.stream().map(f1).map(f2).map(f3).collect(Collectors.toList());

编辑问题以添加多个地图操作。在多个地图函数应用的情况下如何计算地图函数。在谈论非并行流时，元素的计算顺序是否仅取决于输入集合的类型（即对于列表、linkedHashmap、sortedset 和无序对于 hashSet 等）。另外，我能否对流的内部工作有更多的了解，以便更好地决定何时不建议使用流以及何时建议使用最多。（集合大小、序列的性质等）

我想.txt使用 Java Stream在文件中查找字谜。这是我所拥有的：

try (InputStream is = new URL("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt").openConnection().getInputStream();
     BufferedReader reader = new BufferedReader(new InputStreamReader(is));
     Stream<String> stream = reader.lines()) {

以及字谜的方法：

public boolean isAnagram(String firstWord, String secondWord) {
    char[] word1 = firstWord.replaceAll("[\\s]", "").toCharArray();
    char[] word2 = secondWord.replaceAll("[\\s]", "").toCharArray();
    Arrays.sort(word1);
    Arrays.sort(word2);
    return Arrays.equals(word1, word2);
}

如何使用 Java 8 Stream 检查 unixdict.txt 中的单词是否是字谜？有没有办法将一个词与流中的所有词进行比较？

我试图理解 Java 中流的数据流。我的任务是将每个字母出现在字符串列表中

List<String> words = Arrays.asList("Welcome", "to", "the", "java", "world");

进入

Map<String, Long>

使用单线流。

我知道，首先我们可以从列表中流式传输每个单词，然后我需要将它分成多个字符，然后将每个字符作为键并将其出现作为值进行计数，最后返回整个映射。

理解起来太复杂了。有人可以向我解释怎么做吗？

我有一个具有这种结构的 Firebase 数据库

{
  "foo" : {
    "data" : {
      "2019-12-01" : [ {
        "item1" : 8,
        "item2" : 16,
        "name" : "user1"
      }, {
        "item1" : 9,
        "item2" : 18,
        "name" : "user2"
      } ],
      "2019-12-02" : [ {
        "item1" : 2,
        "item2" : 26,
        "name" : "user1"
      }, {
        "item1" : 6,
        "item2" : 6,
        "name" : "user2"
      } ]
    }
  }
}

我正在recyclerviewer以一种非常简单的方式填写主要活动：

public class MainActivity extends AppCompatActivity {

    RecyclerView recyclerView;

    private RecyclerView.LayoutManager layoutManager;
    private …

我正在尝试学习 Java 8。有没有办法将下面的方法转换为 Java 8 Streams、filter 和 forEach。如果是这样，如何？

String[] couponList = coupons.split(",");

for(String coupon:couponList) {
  singleCouponUsageCount = getSingleCouponUsageCount(coupon);
  if(singleCouponUsageCount >= totalUsageCount)
    return 0;
}
return 1;

//

for(String coupon:couponList) {
  singleCouponUsageCount = getSingleCouponUsageCount(coupon);
  if(singleCouponUsageCount >= totalUsageCount)
    return singleCouponUsageCount;
}
return singleCouponUsageCount;

假设一个 Person 类：

public class Person {
    private String name;
    private int amount;
}

并假设一个 Person 集合：

persons = [{"Joe", 5}, {"Joe", 8}, {"Joe", 10}, {"Jack", 3}, {"Jack",6}, {"Joe" 4}, 
           {"Joe", 7}, {"Jack", 12}, {"Jack", 15}, {"Luke", 10}, {"Luke", 12}]

我想要的是获取具有相同名称且相互跟随的合并元素的人员列表并求和（使用java 8 Stream）；像这样的列表：

Perons = [{"Joe", 23}, {"Jack", 9}, {"Joe", 11}, {"Jack", 27}, {"Luke", 22}]

我有一个 Map 类型的数组列表。我想从列表中过滤掉空值并找到最大值和最小值。除了空值外，该程序运行良好。

ArrayList<Map<String, Float>> elements = new ArrayList<Map<String, Float>>();
Map<String, Float> element = new HashMap<String, Float>();
element.put("a", (float) 1.22);
element.put("b", (float) 1.33);
element.put("c", (float) 1.52);
element.put("d", (float) 1.452);
element.put("e", (float) 1.452);

Map<String, Float> element2 = new HashMap<String, Float>();
element2.put("a", (float) 1.2332);
element2.put("b", (float) 1.242);
element2.put("c", (float) 1.552);
element2.put("d", (float) 15.33);
element2.put("e",null);

elements.add(element);
elements.add(element1);
elements.add(element2);

System.out.println("Initial Mappings are: " + elements);
Map<String, Float> min = elements.stream() 
            .flatMap(m -> m.entrySet().stream())
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, Math::min));

System.out.println(min);

java.lang.OutOfMemoryError: java heap space 执行以下代码时抛出错误。

Stream<String> stream3 = Stream.generate(() -> {return "afdajfkljflks";});

System.out.println(stream3.collect(Collectors.toList()));

为什么具体是java堆空间错误以及这段代码背后的场景System.out.println(stream3.collect(Collectors.toList()));

我在一个列表中有许多输入表，每个输入表都有一个标题行，我想忽略它。

最小的例子：

List<String> a = Arrays.asList("header", "v1", "v2", "v3");
List<String> b = Arrays.asList("header", "a1", "a2");
List<String> c = Arrays.asList("header", "b1", "b2", "b3", "b4");

List<List<String>> data = Arrays.asList(a, b, c);

List<String> result = data.stream()
    .map(t -> t.subList(1, t.size()))
    .flatMap(List::stream)
    .collect(Collectors.toList());

有没有一种“更好”的方法来跳过标题行然后map在每个表上使用？

注意：我使用的是 Java 8 并且无法迁移到更新的 JDK