blocks|key|4417256|text|如果在不修改原始集合的情况下需要过滤视图，可以考虑使用Guava的Collections2.filter()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4417257|entityMap|0|LINK|mutability|MUTABLE|url|http://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/Collections2.html#filter(java.util.Collection,%2520com.google.common.base.Predicate))^0|X|L|X|L|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

If you need a filtered view without modifying the original collection, consider Guava's <a href="http://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/Collections2.html#filter(java.util.Collection,%20com.google.common.base.Predicate)" rel="nofollow"><code>Collections2.filter()</code></a>.

blocks|key|4417311|text|Streams有一个定义良好的架构，which+you+can+read+a+lot+about。在开始这条路之前，你可能想先读一读这篇文章。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4417312|但是为什么不实现一个集合，实现一个类似的流接口，为您包装代码呢？|4417313|public+class+StreamableCollection+implements+Collection,+Stream+{
...
}|code-block|syntax|javascript|4417314|然后你可以为你的用例做一些棘手的假设。你仍然可以从collections接口打开一个流，但是你也可以直接跳进去，然后在打开流的句柄的内部。|4417315|++++streamableCollection+cs+=+new+streamableCollection();
++++cs.filter();
++++cs.stream();|4417316|您的IDE将帮助您正确地实现一切……只需将所有内容传递回默认实现即可。|4417317|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/28513908/703644^0|I|U|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Streams had a well defined architecture going in, <a href="https://stackoverflow.com/a/28513908/703644">which you can read a lot about</a>. You might want to read about that before you start down this road.

But why not implement a collection, that implements a similar stream interface that wraps up that code for you? 

<pre><code>public class StreamableCollection implements Collection, Stream {
...
}
</code></pre>

Then you could do some tricky assumptions for your use case. You could still open a stream from the collections interface, but you could also jump straight in and then on the inside of that handle the opening of the stream I suppose. 

<pre><code> streamableCollection cs = new streamableCollection();
 cs.filter();
 cs.stream();
</code></pre>

Your IDE will hop you right to implementing everything... just pass everything back to the default implementations.

blocks|key|4417462|text|您可能喜欢使用StreamEx|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4417463|StreamEx.of(collection).filter(PClass::isCorrect).toList();|code-block|syntax|javascript|4417464|这样做的好处是在保持不变性的同时稍微简短一些。|4417465|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/amaembo/streamex^0|7|8|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

You might like using <a href="https://github.com/amaembo/streamex">StreamEx</a>

<pre><code>StreamEx.of(collection).filter(PClass::isCorrect).toList();
</code></pre>

This has the advantages of being slightly more brief while keeping immutability.

blocks|key|4417531|text|如果你想对集合进行操作，Guava's+FluentIterable是个不错的选择！|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4417532|示例(获取前10个vip客户的id)：|4417533|FluentIterable
+++++++.from(customers)
+++++++.filter(customer+->+customer.isVIP())
+++++++.transform(Client::getId)
+++++++.limit(10);|code-block|syntax|javascript|4417534|entityMap|0|LINK|mutability|MUTABLE|url|http://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/FluentIterable.html^0|C|M|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

If you want to operate on collections <a href="http://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/FluentIterable.html" rel="nofollow">Guava's FluentIterable</a> is a way to go!

Example (get id's of 10 first vip customers):

<pre><code>FluentIterable
 .from(customers)
 .filter(customer -&gt; customer.isVIP())
 .transform(Client::getId)
 .limit(10);
</code></pre>

blocks|key|4417454|text|你可以试试这个，从芭乐图书馆。它看起来没有Stream方法那么杂乱。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4417455|+ImmutableList.copyOf(Iterables.filter(collection,+MyClass::isCorrect));|code-block|syntax|javascript|4417456|有关该技术的讨论，请参阅Google+Collections+(Guava+Libraries):+ImmutableSet/List/Map+and+Filtering。|offset|length|4417457|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/6176918/google-collections-guava-libraries-immutableset-list-map-and-filtering^0|0|0|C|21|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

You might try this, from the guava library. It seems a little less cluttered than the Stream approach.

<pre><code> ImmutableList.copyOf(Iterables.filter(collection, MyClass::isCorrect));
</code></pre>

See <a href="https://stackoverflow.com/questions/6176918/google-collections-guava-libraries-immutableset-list-map-and-filtering">Google Collections (Guava Libraries): ImmutableSet/List/Map and Filtering</a> for a discussion on the technique.

blocks|key|4417625|text|我也认为Stream+API很好，但对于短操作来说太冗长了。我在几个项目中使用了这些实用方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4417626|import+java.util.List;
import+java.util.function.Function;
import+java.util.function.Predicate;
import+java.util.stream.Collectors;
import+java.util.stream.Stream;

public+class+Functions+{

++++public+static+<T,V>+List<V>+map(final+List<T>+in,+final+Function<T,+V>+function)+{
++++++++return+in+==+null+?+null+:+map(in.stream(),+function);
++++}

++++public+static+<T,V>+List<V>+map(final+Stream<T>+in,+final+Function<T,+V>+function)+{
++++++++return+in+==+null+?+null+:+in
++++++++++++.map(function)
++++++++++++.collect(Collectors.toList());
++++}

++++public+static+<T>+List<T>+filter(final+List<T>+in,+final+Predicate<T>+predicate)+{
++++++++return+in+==+null+?+null+:+filter(in.stream(),+predicate);
++++}

++++public+static+<T>+List<T>+filter(final+Stream<T>+in,+final+Predicate<T>+predicate)+{
++++++++return+in+==+null+?+null+:+in
++++++++++++.filter(predicate)
++++++++++++.collect(Collectors.toList());
++++}
}|code-block|syntax|javascript|4417627|这让我可以做例如|4417628|List<String>+wrapped+=+Functions.map(myList,+each+->+"["+%2B+each+%2B+"]");|4417629|通常，我也会静态导入该方法。|4417630|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I also think the Stream API is good, but verbose for short operations. I've used these utility methods in a few projects:

<pre><code>import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Functions {

 public static &lt;T,V&gt; List&lt;V&gt; map(final List&lt;T&gt; in, final Function&lt;T, V&gt; function) {
 return in == null ? null : map(in.stream(), function);
 }

 public static &lt;T,V&gt; List&lt;V&gt; map(final Stream&lt;T&gt; in, final Function&lt;T, V&gt; function) {
 return in == null ? null : in
 .map(function)
 .collect(Collectors.toList());
 }

 public static &lt;T&gt; List&lt;T&gt; filter(final List&lt;T&gt; in, final Predicate&lt;T&gt; predicate) {
 return in == null ? null : filter(in.stream(), predicate);
 }

 public static &lt;T&gt; List&lt;T&gt; filter(final Stream&lt;T&gt; in, final Predicate&lt;T&gt; predicate) {
 return in == null ? null : in
 .filter(predicate)
 .collect(Collectors.toList());
 }
}
</code></pre>

This lets me do e.g.

<pre><code>List&lt;String&gt; wrapped = Functions.map(myList, each -&gt; "[" + each + "]");
</code></pre>

Normally I static import the method as well.

blocks|key|4417547|text|如果你对使用第三方库持开放态度，你可以使用Eclipse+Collections，它有丰富的API，直接在集合中可用。您的示例可以使用Eclipse+Collections编写，如下所示。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4417548|collection.select(p->p.isCorrect)
collection.select(MyClass::isCorrect)|code-block|syntax|javascript|4417549|注意:我是Eclipse+Collections的提交者。|4417550|entityMap|0|LINK|mutability|MUTABLE|url|https://www.eclipse.org/collections/^0|L|J|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

If you are open to using a third party library, you could use <a href="https://www.eclipse.org/collections/" rel="nofollow">Eclipse Collections</a> which has rich APIs directly available under collections. Your example can be written as below with Eclipse Collections.

<pre><code>collection.select(p-&gt;p.isCorrect)
collection.select(MyClass::isCorrect)
</code></pre>

Note: I am a committer for Eclipse Collections.

blocks|key|4417706|text|对于cyclops-react，您有许多选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4417707|我们可以利用惰性扩展集合|4417708|++CollectionX<String>+collection+=+ListX.of("hello","world");
++CollectionX<String>+filtered+=+collection.filter(p->p.isCorrect());|code-block|syntax|javascript|4417709|支持可变的、不可变的和持久的扩展集合。集合上的函数操作是惰性的(即，行为类似于可重放的流)，并且仅在第一次访问时才实现。|4417710|我们可以利用一个强大的扩展流类型|4417711|++ReactiveSeq.fromIterable(collection)
+++++++++++++.filter(p->p.isCorrect())
+++++++++++++.toList();|4417712|我是cyclops+react的首席开发者。|4417713|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/aol/cyclops-react^0|2|D|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|C|$]]|$1|O|3|P|5|H|7|18|8|@]|9|@]|C|$I|J]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

With <a href="https://github.com/aol/cyclops-react" rel="nofollow noreferrer">cyclops-react</a> you have a number of options.

We can make use of Lazy Extended Collections

<pre><code> CollectionX&lt;String&gt; collection = ListX.of("hello","world");
 CollectionX&lt;String&gt; filtered = collection.filter(p-&gt;p.isCorrect());
</code></pre>

There is support for mutable, immutable and persistent extended collections. Functional operations on collections are lazy (i.e. behave like replayable Streams) and are materialized only on first access.

We can make use of a powerful extened Stream type

<pre><code> ReactiveSeq.fromIterable(collection)
 .filter(p-&gt;p.isCorrect())
 .toList();
</code></pre>

[Disclosure I am the lead developer of cyclops-react]

Java 8 stream api is very nice feature and I absolutely like it. One thing that get's on my nerves is that 90% of the time I want to have input as a collection and output as collections. The consequence is I have to call <code>stream()</code> and <code>collect()</code> method all the time:

<pre><code>collection.stream().filter(p-&gt;p.isCorrect()).collect(Collectors.toList());
</code></pre>

Is there any java api that would let me skip the stream and directly operate on collections (like <code>linq</code> in c#?):

<pre><code>collection.filter(p-&gt;p.isCorrect)
</code></pre>

Java 8 - omitting tedious collect method

Eclipse

Java

Java 8流api是一个非常好的特性，我非常喜欢它。有一件事让我心烦意乱，那就是90%的时间我希望输入作为集合，输出作为集合。结果是我不得不一直调用stream()和collect()方法：collection.stream().filter(p->p.isCorrect()).collect(Collectors....

问Java 8-省略繁琐的收集方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java 8-省略繁琐的收集方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java 8-省略繁琐的收集方法
EN