我正在尝试理解Java 8流.我有两节课:
public class UserMeal {
protected final LocalDateTime dateTime;
protected final String description;
protected final int calories;
public UserMeal(LocalDateTime dateTime, String description, int calories) {
this.dateTime = dateTime;
this.description = description;
this.calories = calories;
}
public LocalDateTime getDateTime() {
return dateTime;
}
public String getDescription() {
return description;
}
public int getCalories() {
return calories;
}
}
和:
public class UserMealWithExceed {
protected final LocalDateTime dateTime;
protected final String description;
protected final int calories;
protected final boolean exceed;
public …使用以下结构是否存在差异,除了后者的可读性稍好一些？
someList.stream().map(item -> new NewClass(item)).collect(Collectors.toList());
someList.stream().map(NewClass::new).collect(Collectors.toList());
我有这个代码:
List<String> strings = Arrays.asList("a", "b", "cc");
for (String s : strings) {
if (s.length() == 2)
System.out.println(s);
}
我想用过滤器和lambda来编写它:
for (String s : strings.stream().filter(s->s.length() == 2)) {
System.out.println(s);
}
我得到Can only iterate over an array or an instance of java.lang.Iterable.
我尝试:
for (String s : strings.stream().filter(s->s.length() == 2).iterator()) {
System.out.println(s);
}
我得到了同样的错误.这甚至可能吗？我真的不想做stream.forEach()并传递消费者.
编辑:对我来说重要的是不要复制元素.
从char数组,我想构建一个流来使用java 8功能,如过滤器和地图.
char[] list = {'a','c','e'};
Stream<Character> cStream = Stream.of(list);
// Stream<Character> cStream = Arrays.stream(list);
第一种方法不起作用(原因:将cStream更改为Stream<char[]>).注释行也不起作用(原因:stream(T[])类型数组中的方法不适用于arguments(char[])).
我知道如果char[] list更改为int[],一切正常使用IntStream.但我不希望每次转换char[]到int[]每个时间或更改到一个列表中,当我需要在使用流库char阵列.
我已经阅读过这个和这个问题,但仍然怀疑Stream.skipJDK作者是否打算观察到这种行为.
让我们简单输入数字1..20:
List<Integer> input = IntStream.rangeClosed(1, 20).boxed().collect(Collectors.toList());
现在让我们创建一个并行流,以不同的方式结合unordered()使用skip()并收集结果:
System.out.println("skip-skip-unordered-toList: "
+ input.parallelStream().filter(x -> x > 0)
.skip(1)
.skip(1)
.unordered()
.collect(Collectors.toList()));
System.out.println("skip-unordered-skip-toList: "
+ input.parallelStream().filter(x -> x > 0)
.skip(1)
.unordered()
.skip(1)
.collect(Collectors.toList()));
System.out.println("unordered-skip-skip-toList: "
+ input.parallelStream().filter(x -> x > 0)
.unordered()
.skip(1)
.skip(1)
.collect(Collectors.toList()));
过滤步骤在这里基本没什么,但为流引擎增加了更多的难度:现在它不知道输出的确切大小,因此关闭了一些优化.我有以下结果:
skip-skip-unordered-toList: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
// absent values: 1, 2
skip-unordered-skip-toList: …通过Katas在工作中发布的一些编码,我偶然发现了这个问题,我不知道如何解决.
使用Java 8 Streams,给定正整数列表,生成一个整数列表,其中整数前面有一个更大的值.
Run Code Online (Sandbox Code Playgroud)[10, 1, 15, 30, 2, 6]以上输入将产生:
Run Code Online (Sandbox Code Playgroud)[1, 15, 2]因为1在15之前,15在30之前,2在6之前.
public List<Integer> findSmallPrecedingValues(final List<Integer> values) {
List<Integer> result = new ArrayList<Integer>();
for (int i = 0; i < values.size(); i++) {
Integer next = (i + 1 < values.size() ? values.get(i + 1) : -1);
Integer current = values.get(i);
if (current < next) {
result.push(current);
}
}
return result;
}
我遇到的问题是我无法弄清楚如何在lambda中访问下一个.
return values.stream().filter(v -> v < next).collect(Collectors.toList());
map并映射到a …我正在讨论来自http://www.concretepage.com/java/jdk-8/java-8-unaryoperator-binaryoperator-example的例子.
我发现真正令人困惑的是,当我在形成收集器时错误地将错误的类型放入泛型中时,java编译器给了我一个非常误导性的消息:
无法从静态上下文引用非静态方法
我的错误与现实中的静态vs实例上下文无关:
Map<String, Map<Integer, Integer>> mapOfStudents = list.stream().collect(Collectors.groupingBy(Student::getClassName,
Collectors.toMap(Student::getName, Student::getAge)));
我的错误在于泛型返回类型.当我纠正它并把:
Map<String, Map<String, Integer>> mapOfStudents
一切都恢复正常.
有人可以解释这种令人困惑的错误信息背后的原因吗？我确信这是一个很好的,但我没有抓住它.
编辑:
~$ java -version
openjdk version "1.8.0_121"
OpenJDK Runtime Environment (build 1.8.0_121-8u121-b13-0ubuntu1.16.04.2-b13)
OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode)
我对Java 8中的以下构造感到好奇:
double[] doubles = //...
double sum = DoubleStream.of(doubles).parallel().sum();
切入追逐:
sum始终相同,例如在不同的计算机上运行时？更多背景......
浮点运算是有损的,并且(与实值运算不同)不是关联的.因此,除非注意工作如何分割和重新组合,否则可能导致不确定的结果.
我很高兴地发现这种sum()方法采用了Kahan Summation.这显着减少了错误,但仍未提供精确的*结果.
在我的测试中,重复调用似乎每次返回相同的结果,但我想知道我们可以安全地假设它是多么稳定.例如:
我很高兴在每台计算机上采用相同的JVM版本.
这是我掀起的一项测试:
public static void main(String[] args) {
Random random = new Random(42L);
for (int j = 1; j < 20; j++) {
// Stream increases in size and the magnitude of the values at each iteration.
double[] doubles = generate(random, j*100, j);
// Like a simple for loop
double sum1 = DoubleStream.of(doubles).reduce(0, …我有以下集合类型:
Map<String, Collection<String>> map;
我想map.size()从每个Key的集合中的单个值创建每个组的唯一组合.
例如,假设地图如下所示:
A, {a1, a2, a3, ..., an}
B, {b1, b2, b3, ..., bn}
C, {c1, c2, c3, ..., cn}
我希望获得的List<Set<String>>结果是一个结果,看起来类似于(排序并不重要,它只需要是一个由所有可能的组合组成的'完整'结果):
{a1, b1, c1},
{a1, b1, c2},
{a1, b1, c3},
{a1, b2, c1},
{a1, b2, c2},
{a1, b2, c3},
...
{a2, b1, c1},
{a2, b1, c2},
...
{a3, b1, c1},
{a3, b1, c2},
...
{an, bn, cn}
这基本上是一个计数问题,但我想看看是否可以使用Java 8流解决方案.
我有一个Parent具有20个属性的Java类(attrib1, attrib2 .. attrib20)及其相应的getter和setter.我还有两个Parent对象列表:list1和list2.
现在我想合并两个列表并避免基于attrib1和的重复对象attrib2.
使用Java 8:
List<Parent> result = Stream.concat(list1.stream(), list2.stream())
.distinct()
.collect(Collectors.toList());
但是我必须在哪个地方指定属性？我应该覆盖hashCode和equals方法吗？