我有以下型号:
public class WeightChange {
private float value;
public float getValue() {
return value;
}
public void setValue(float value) {
this.value = value;
}
}
和收藏:
private List<WeightChange> weightChanges;
我已经实现了使用Java 8功能获得平均权重值的函数:
public float getAvgChangedWeight() {
return (float) weightChanges.stream().mapToDouble(WeightChange::getValue).average().getAsDouble();
}
你能不能帮助改进它,因为我不认为铸造加倍是一个好主意.
当weightChanges集合为空时,它也会抛出异常.在这种情况下如何改进它？
使用Java 8 lambdas,有效创建新的List<T>给定的List<K>密钥和"a "的"最佳"方法是Map<K,V>什么？在这种情况下,您将获得一些List可能的Map键,并且应该生成一个List<T>where T,这是基于Vmap值类型的某些方面构造的某种类型.
我已经探索了一些并且感到不舒服声称一种方式比另一种方式更好(可能有一个例外 - 参见代码).我将澄清"最佳"作为代码清晰度和运行时效率的组合.这些是我想出来的.我相信有人可以做得更好,这是这个问题的一个方面.我不喜欢filter大多数方面,因为它意味着需要创建中间结构和多次传递名称List.现在,我选择了例6 - 一个简单的'ol循环.(注意:代码注释中有一些神秘的想法,特别是"需要外部引用......"这意味着从lambda外部.)
public class Java8Mapping {
private final Map<String,Wongo> nameToWongoMap = new HashMap<>();
public Java8Mapping(){
List<String> names = Arrays.asList("abbey","normal","hans","delbrook");
List<String> types = Arrays.asList("crazy","boring","shocking","dead");
for(int i=0; i<names.size(); i++){
nameToWongoMap.put(names.get(i),new Wongo(names.get(i),types.get(i)));
}
}
public static void main(String[] args) {
System.out.println("in main");
Java8Mapping j = new Java8Mapping();
List<String> testNames = Arrays.asList("abbey", "froderick","igor");
System.out.println(j.getBongosExample1(testNames).stream().map(Bongo::toString).collect(Collectors.joining(", "))); …以下代码是否需要包含在try-with-resources中以确保底层文件已关闭？
List<String> rows = Files.lines(inputFilePath).collect(Collectors.toList());
我已经创建了计算字母表中每个字符的方法.我正在学习流(函数式编程)并尝试尽可能多地使用它们,但在这种情况下我不知道该怎么做:
private Map<Character, Integer> numerateAlphabet(List<Character> alphabet) {
Map<Character, Integer> m = new HashMap<>();
for (int i = 0; i < alphabet.size(); i++)
m.put(alphabet.get(i), i);
return m;
}
那么,如何使用Java 8流重写它呢？
假设您有一个这样的方法来计算Collection某些方法的最大值ToIntFunction:
static <T> void foo1(Collection<? extends T> collection, ToIntFunction<? super T> function) {
if (collection.isEmpty())
throw new NoSuchElementException();
int max = Integer.MIN_VALUE;
T maxT = null;
for (T t : collection) {
int result = function.applyAsInt(t);
if (result >= max) {
max = result;
maxT = t;
}
}
// do something with maxT
}
使用Java 8,可以将其转换为
static <T> void foo2(Collection<? extends T> collection, ToIntFunction<? super T> function) {
T maxT = collection.stream()
.max(Comparator.comparingInt(function))
.get();
// …哪种方式最有效地处理不同的有序集合？
Set<MyObj> ret = new TreeSet<>();
for (Foo foo : foos)
ret.add(new MyObj(foo));
List<MyObj> ret = foos.stream().map(MyObj::new)
.distinct().sorted()
.collect(Collectors.toList());
Set<MyObj> ret = foos.stream().map(MyObj::new)
.collect(Collectors.toCollection(TreeSet::new));
第一种方式似乎是最不优雅但易于阅读的.第二种方式让我担心distinct并且sorted会两次处理流.最后一种方式感觉还可以,但是流中的TreeSet开销是多少？
有线索吗？谢谢.
我想获取输入并在其上应用并行流,然后我想输出为列表.输入可以是我们可以应用流的任何列表或任何集合.
我担心的是,如果我们想要输出作为映射它们,我们有一个来自java的选项就像
list.parallelStream().collect(Collectors.toConcurrentMap(args))
但是我没有选择以线程安全的方式从并行流中收集以提供列表作为输出.我看到另外一个选项可供使用
list.parallelStream().collect(Collectors.toCollection(<Concurrent Implementation>))
通过这种方式,我们可以在collect方法中提供各种并发实现.但我认为java.util.concurrent中只存在CopyOnWriteArrayList List实现.我们可以在这里使用各种队列实现,但那些不会像列表一样.我的意思是我们可以解决这个问题.
如果我想要输出列表,你能指导一下最好的方法吗？
注意:我找不到与此相关的任何其他帖子,任何参考都会有所帮助.
int[] ar1 = {1,2,3};
int[] ar2 = {1,2,3};
输出:
{2,3,4,3,4,5,4,5,6}
我试过这样的事情:
IntStream.range(0,ar1.length).map(x -> IntStream.range(0,ar2.length).map(y -> ar1[y]+ar2[x]));
但这不起作用:
类型不匹配:无法转换
IntStream为int.
如何使用流将Java 8中的每个值ar1与每个值相加ar2？
TL; DR; 我正在寻找一个可以查找某个中间操作或终端操作的地方.我在哪里可以找到这样的文件？
编辑这与如何确保java8流中的处理顺序不重复？,因为该问题没有提供全面的操作清单.
该软件包的文件说:
流是否具有遭遇顺序取决于源和中间操作
为了确保整个流操作中的订购维护,您必须研究流的源,所有中间操作和终端操作的文档,以确定它们是否维护订单(或者源是否在第一个订单中有订单)地点).
这一切都很好,但我应该查看哪些文档？该软件包文件提到了这样的例子map,保证订货,但它没有一个详尽的清单.Stream类的javadoc记录了一些中间操作,但不是全部.举个例子map:
返回一个流,该流包含将给定函数应用于此流的元素的结果.
这是一个中间操作.
要么 filter
返回由与此给定谓词匹配的此流的元素组成的流.
这是一个中间操作.
这些都没有描述它们是否保留了排序.
实际上,每个中间操作都默认保留订单.唯一的例外是:
- unordered(),它删除了排序约束.
- sorted()改变了顺序.
如果没有明确指定,您可以假设操作保持订单.即使distinct()保持顺序,但它为并行流增加了很多复杂性.
但是有任何官方文件可以支持吗？
实际上有两个单独的排序问题.
例如,并行map操作可以以任意顺序遍历所有元素(违反2.),但仍然保持返回流中的顺序(服从1.)
考虑以下代码：
public static void main(String[] args) {
Stream.iterate(1, i -> i + 1)
.flatMap(i -> Stream.of(i, i, i))
.peek(System.out::println)
.limit(4)
.forEach(i -> {});
}
Java 8的输出：
1
1
1
2
2
2
在Java 11中：
1
1
1
2
这是Java 8中的错误或预期的行为，在11中进行了更改吗？
上面的代码只是演示不同行为的示例，但是更重要的含义是，以下代码在Java 11中显示1,2,3，但在Java 8中进入了无限循环：
Stream.iterate(0, i -> i + 10)
.flatMap(i -> Stream.iterate(i + 1, j -> j + 1))
.limit(3)
.forEach(System.out::println);