标签: java-stream

哪个是从集合中创建流的最佳方法:

    final Collection<String> entities = someService.getArrayList();

1. entities.stream();

2. Stream.of(entities);

我有这个方法：

filteredListIn.addAll(Stream.of(listRef)
    .filter(results ->
            results.getTitle().contains(query.toString().toLowerCase())
     ));

有了这两个变量：

private List<Results> listRef = new ArrayList<>();
List<Results> filteredListIn = new ArrayList<>();

但我得到

为 addAll(Stream) 找到了已过滤的ListIn.addAll(Stream.of(listRef) ^ 方法 Collection.addAll(Collection) 不适用（参数不匹配；Stream 无法转换为 Collection）方法 List.addAll(Collection) 不适用

有什么问题，我该如何解决？

这可能是因为我使用外部库来支持 api 24 下的流吗？

我在尝试平均 java 中地图的值时遇到了很多麻烦。我的方法接受一个文本文件，并查看以某个字母开头的每个单词的平均长度（不区分大小写并遍历文本文件中的所有单词。

例如，假设我有一个包含以下内容的文本文件：

"Apple arrow are very common Because bees behave Cant you come home"

我的方法目前返回：

{A=5, a=8, B=7, b=10, c=10, C=5, v=4, h=4, y=3}

因为它是看字母，求单词的平均长度，但是还是区分大小写的。

它应该返回：

{A=5, a=8, B=7, b=10, c=10, C=5, v=4, h=4, y=3}

{a=4.3, b=5.5, c=5.0, v=4.0, h=4.0, y=3}

这是我到目前为止。

public static Map<String, Integer> findAverageLength(String filename) {
    
     Map<String, Integer> wordcount = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
       
        try 
        {
            Scanner in = new Scanner(new File(filename));
            List<String> wordList = new ArrayList<>();
            while (in.hasNext()) 
            {
                wordList.add(in.next());
            }

            wordcount = wordList.stream().collect(Collectors.toConcurrentMap(w->w.substring(0,1), w -> …

Java 8即将发布......在学习Streams的过程中,我进入了一个关于使用一种新方法对字谜进行分组的场景.我面临的问题是我找不到使用map/reduce函数对Strings对象进行分组的方法.相反,我必须创建一个与http://docs.oracle.com/javase/tutorial/collections/streams/reduction.html中记录的类似的方式.

根据文档,我们可以简单地使用LIST.stream().collect(Collectors.groupingBy(POJO :: GET_METHOD)),这样Collectors.groupingBy()将根据使用的方法聚合地图的键.但是,这种方法似乎很难包装简单的String表示.

public class AnagramsGrouping {

  static class Word {

    public String original;

    public Word(String word) {
      original = word;
    }

    public String getKey() {
      char[] characters = input.toCharArray();
      Arrays.sort(characters);
      return new String(characters);
    }

    public String toString() {
      return original;
    };
  }

  public static void main(String[] args) {
    List<Word> words = Arrays.asList(new Word("pool"), new Word("loop"), 
         new Word("stream"), new Word("arc"), new Word("odor"),
         new Word("car"), new Word("rood"), new Word("meats"),
         new Word("fires"), new Word("fries"), new Word("night"),
         new Word("thing"), …

我正在使用Files.lines(...)读取一个非常大的(500mb)文件.它读取文件的一部分,但在某些时候它会破坏java.io.UncheckedIOException:java.nio.charset.MalformedInputException:输入长度= 1

我认为该文件具有不同字符集的行.有没有办法跳过这些断线？我知道返回的流是由Reader支持的,读者我知道如何跳过,但不知道如何从流中获取Reader以便按我喜欢的方式设置它.

    List<String> lines = new ArrayList<>();
    try (Stream<String> stream = Files.lines(Paths.get(getClass().getClassLoader().getResource("bigtest.txt").toURI()), Charset.forName("UTF-8"))) {
        stream
            .filter(s -> s.substring(0, 2).equalsIgnoreCase("aa"))
            .forEach(lines::add);
    } catch (final IOException e) {
        // catch
    }

我有一个单词列表文本文件,我想从该文件中获取最小,最大和平均单词长度.

我有一个流方法:

public static Stream<String> readWords(String filename) {
    try {
        BufferedReader reader = new BufferedReader(new FileReader(filename));
        Stream<String> stringStream = reader.lines();
        return stringStream;
    } catch (IOException exn) {
        return Stream.<String>empty();
    }
}

在我的主要测试方法中,我打印最大和最小

System.out.println(readWords(filename)
        .min(Comparator.comparing(s -> s.length()))
        .get()
        .length()
);
System.out.println(readWords(filename)
        .max(Comparator.comparing(s -> s.length()))
        .get()
        .length()
);

它按预期工作.

问题:
是否有可能像我在min和max中那样得到单词长度的平均值？在是或否的情况下,如何做到这一点(仅作为Lambda表达式)？

我试图弄清楚如何重写这个以使用流和过滤器来缩小我的标准并在必要时从地图中删除.

Iterator<Map.Entry<String,Object>> iter = listOfPossibleParams.entrySet().iterator();
while (iter.hasNext()) {
    Map.Entry<String,Object> entry = iter.next();
    if(entry.getValue() instanceof String) {
        if (StringUtils.isBlank((String) entry.getValue())) {
            iter.remove();
        }
    }
}

我最初在想这样的事情,但它显然不起作为语法错误:

listOfPossibleParams.entrySet()
            .stream()
            .filter(p -> p.getValue() instanceof String)
            .removeIf(e -> StringUtils.isBlank((String)e.getValue()));

我需要将listB的所有元素合并到另一个列表listA中.

如果listA中已存在一个元素(基于自定义相等检查),我不想添加它.

我不想使用Set,我不想重写equals()和hashCode().

原因是,我不想在listA本身防止重复,我只想在listB中已经存在我认为相等的元素时才从listB合并.

我不想重写equals()和hashCode(),因为这意味着我需要确保,我在各种情况下对元素的equals()实现都有.然而,可能是listB中的元素未完全初始化,即它们可能会遗漏一个对象id,其中可能存在于listA的元素中.

我目前的方法涉及一个接口和一个实用功能:

public interface HasEqualityFunction<T> {

    public boolean hasEqualData(T other);
}

public class AppleVariety implements HasEqualityFunction<AppleVariety> {
    private String manufacturerName;
    private String varietyName;

    @Override
    public boolean hasEqualData(AppleVariety other) {
        return (this.manufacturerName.equals(other.getManufacturerName())
            && this.varietyName.equals(other.getVarietyName()));
    }

    // ... getter-Methods here
}


public class CollectionUtils {
    public static <T extends HasEqualityFunction> void merge(
        List<T> listA,
        List<T> listB) {
        if (listB.isEmpty()) {
            return;
        }
        Predicate<T> exists
            = (T x) -> {
                return listA.stream().noneMatch(
                        x::hasEqualData); …

我刚开始学习Java 8中的Stream API和一般的函数式编程,但不是Java新手.我有兴趣了解和理解Stream API如何选择执行计划.

它是如何知道要并行化的哪些部分以及哪些部分不是？甚至存在多少种执行计划？

基本上,我想知道为什么Java 8中的Streams有助于使事情变得更快,以及它如何做到这一点"神奇".

我找不到很多关于它如何运作的文献.

我有一个将列表转换为地图的功能.调用此函数后,映射的大小不会更改.我正在尝试在以下两个实现之间做出决定:

Map<Long, Object> listToMap(List<Object> objs) {
        /* Implementation One: */

        Map<Long, Object> map = new HashMap<>(objs.size(), 1);
        for (Object obj : objs) {
            map.put(obj.getKey(), obj);
        }
        return map;

        /* Implementation Two: */

        return objs.stream().collect(Collectors.toMap(Object::getKey, obj -> obj));

    }

在第一个实现中,我通过使用1的加载因子和列表的大小为所有元素分配了足够的内存.这确保不会执行调整大小操作.然后,我遍历列表并逐个添加元素.

在第二个实现中,我使用Java 8流来提高可读性.

我的问题是:第二个实现是否会涉及HashMap的多个调整大小,还是已经过优化以分配足够的内存？