Questions tagged «java-stream»

在Java 8中，我们有类Stream <T>，它奇怪地有一个方法 Iterator<T> iterator() 因此，您可能希望它实现接口Iterable <T>，而该接口正是需要此方法，但事实并非如此。 当我想使用foreach循环遍历Stream时，我必须做类似的事情 public static Iterable<T> getIterable(Stream<T> s) { return new Iterable<T> { @Override public Iterator<T> iterator() { return s.iterator(); } }; } for (T element : getIterable(s)) { ... } 我在这里想念什么吗？

261 java  java-8  java-stream  iterable 

我想用 java.util.Optional.orElseThrow() 具有要求构造函数参数的Exception类型。像这样： .orElseThrow(MyException::new(someArgument)) // obviously NOT working 有没有办法创建一个将我的参数值传入的供应商？

259 java  java-8  java-stream 

Map<String, String> phoneBook = people.stream() .collect(toMap(Person::getName, Person::getAddress)); java.lang.IllegalStateException: Duplicate key当发现重复元素时，我得到提示。 在向地图添加值时是否可以忽略此类异常？ 当有重复项时，只需忽略该重复项即可继续。

257 java  java-8  java-stream 

我想知道为什么Iterable接口不提供stream()和parallelStream()方法。考虑以下类别： public class Hand implements Iterable<Card> { private final List<Card> list = new ArrayList<>(); private final int capacity; //... @Override public Iterator<Card> iterator() { return list.iterator(); } } 它是一手牌的一种实现，因为您在玩交易纸牌游戏时可以手拿牌。 本质上，它包装List<Card>，以确保最大容量并提供其他有用的功能。最好将其直接实现为List<Card>。 现在，为了方便起见，我认为最好实现Iterable<Card>，这样，如果要遍历它，可以使用增强的for循环。（我的Hand课程也提供了一种get(int index)方法，因此Iterable<Card>我认为该方法是合理的。） 该Iterable界面提供了以下内容（省略了javadoc）： public interface Iterable<T> { Iterator<T> iterator(); default void forEach(Consumer<? super T> action) { Objects.requireNonNull(action); for (T t …

241 java  java-8  java-stream  iterable 

Наэтотвопросестьответына 堆栈溢出нарусском：Лямбдыв爪哇8，чтолучшеиспользовать - Function.identity（）илиT->吨？ 我对Function.identity()方法的使用有疑问。 想象以下代码： Arrays.asList("a", "b", "c") .stream() .map(Function.identity()) // <- This, .map(str -> str) // <- is the same as this. .collect(Collectors.toMap( Function.identity(), // <-- And this, str -> str)); // <-- is the same as this. 是否有任何理由您应使用Function.identity()代替str->str（反之亦然）。我认为第二个选项更具可读性（当然是个人喜好了）。但是，有没有“真正的”理由为什么应该优先考虑呢？

240 java  lambda  java-8  java-stream 

新的Java 8流框架和新朋友创建了一些非常简洁的Java代码，但是我遇到了一个看似简单的情况，很难做到简洁。 考虑List<Thing> things和方法Optional<Other> resolve(Thing thing)。我想将Things 映射到Optional<Other>s并获得第一个Other。显而易见的解决方案是使用things.stream().flatMap(this::resolve).findFirst()，但flatMap要求您返回一个流，并且Optional没有stream()方法（或者是a Collection或提供一种将其转换为或将其视为a的方法Collection）。 我能想到的最好的方法是： things.stream() .map(this::resolve) .filter(Optional::isPresent) .map(Optional::get) .findFirst(); 但这对于一个很常见的案例来说似乎太漫长了。有人有更好的主意吗？

240 java  lambda  java-8  java-stream 

与C＃不同IEnumerable，在C＃中，执行管道可以执行任意多次，而在Java中，流只能“迭代”一次。 对终端操作的任何调用都会关闭流，使其无法使用。这种“功能”带走了很多力量。 我想这不是技术原因。这种奇怪的限制背后的设计考虑是什么？ 编辑：为了演示我在说什么，请考虑以下C＃中的Quick-Sort实现： IEnumerable<int> QuickSort(IEnumerable<int> ints) { if (!ints.Any()) { return Enumerable.Empty<int>(); } int pivot = ints.First(); IEnumerable<int> lt = ints.Where(i => i < pivot); IEnumerable<int> gt = ints.Where(i => i > pivot); return QuickSort(lt).Concat(new int[] { pivot }).Concat(QuickSort(gt)); } 现在确定，我不主张这是快速排序的良好实现！但是，这是将lambda表达与流操作相结合的表达能力的一个很好的例子。 而且用Java无法做到！我什至不能问一个流是否为空而不使它无法使用。

239 java  java-8  java-stream  api-design 

有时您想过滤Stream具有多个条件的a： myList.stream().filter(x -> x.size() > 10).filter(x -> x.isCool()) ... 或者你可以做同样的复杂条件和单 filter： myList.stream().filter(x -> x.size() > 10 && x -> x.isCool()) ... 我的猜测是第二种方法具有更好的性能特征，但我不知道。 第一种方法赢得了可读性，但是哪种性能更好？

235 java  lambda  filter  java-8  java-stream 

我正在尝试使用Java 8 Stream来查找中的元素LinkedList。但是，我想保证过滤条件只有一个匹配项。 采取以下代码： public static void main(String[] args) { LinkedList<User> users = new LinkedList<>(); users.add(new User(1, "User1")); users.add(new User(2, "User2")); users.add(new User(3, "User3")); User match = users.stream().filter((user) -> user.getId() == 1).findAny().get(); System.out.println(match.toString()); } static class User { @Override public String toString() { return id + " - " + …

228 java  lambda  java-8  java-stream 

注意：这个问题来自于以前的SO问题的无效链接，但是这里... 参见下面的代码（注意：我确实知道该代码不会“起作用”，Integer::compare应该使用-我只是从链接的问题中提取了它）： final ArrayList <Integer> list = IntStream.rangeClosed(1, 20).boxed().collect(Collectors.toList()); System.out.println(list.stream().max(Integer::max).get()); System.out.println(list.stream().min(Integer::min).get()); 据javadoc的.min()和.max()，两者的参数应该是一个Comparator。然而，这里的方法引用是针对Integer该类的静态方法的。 那么，为什么要编译呢？

215 java  java-8  java-stream 

我知道如何List从Y-> “转换”一个简单的Java Z，即： List<String> x; List<Integer> y = x.stream() .map(s -> Integer.parseInt(s)) .collect(Collectors.toList()); 现在，我想对地图进行基本相同的操作，即： INPUT: { "key1" -> "41", // "41" and "42" "key2" -> "42 // are Strings } OUTPUT: { "key1" -> 41, // 41 and 42 "key2" -> 42 // are Integers } 解决方案不应限于String-> Integer。就像List上面的示例一样，我想调用任何方法（或构造函数）。

209 java  mapreduce  java-8  java-stream  collectors 

Java 8中有很多有用的新事物。例如，我可以在对象列表上使用流进行迭代，然后对Object实例的特定字段中的值求和。例如 public class AClass { private int value; public int getValue() { return value; } } Integer sum = list.stream().mapToInt(AClass::getValue).sum(); 因此，我问是否有任何方法可以构建一个String将toString()一行实例中的方法输出连接在一起的方法。 List<Integer> list = ... String concatenated = list.stream().... //concatenate here with toString() method from java.lang.Integer class 假设list包含整数1，2并且3，我希望concatenated是"123"或"1,2,3"。

206 java-8  java-stream 

我刚刚发现了新的Java 8流功能。来自Python，我想知道现在是否有一种巧妙的方法可以对数组进行操作，例如求和，以“单行pythonic”的方式将两个数组相乘？ 谢谢

197 java  arrays  java-8  java-stream 

我有一个列表myListToParse，我想在其中过滤元素并在每个元素上应用方法，然后将结果添加到另一个列表中myFinalList。 使用Java 8，我注意到可以用2种不同的方式来做到这一点。我想知道它们之间更有效的方法，并理解为什么一种方法比另一种更好。 我愿意就第三种方式提出任何建议。 方法1： myFinalList = new ArrayList<>(); myListToParse.stream() .filter(elt -> elt != null) .forEach(elt -> myFinalList.add(doSomething(elt))); 方法2： myFinalList = myListToParse.stream() .filter(elt -> elt != null) .map(elt -> doSomething(elt)) .collect(Collectors.toList());

188 java  java-8  java-stream 

是否存在Java 8流操作来限制（可能是无限的）Stream直到第一个元素与谓词不匹配？ 在Java 9中，我们可以使用takeWhile下面的示例来打印所有小于10的数字。 IntStream .iterate(1, n -> n + 1) .takeWhile(n -> n < 10) .forEach(System.out::println); 由于Java 8中没有这样的操作，以一般方式实现它的最佳方法是什么？

187 java  java-8  java-stream