如何在Java 8 Stream上实现"分区"操作？通过分区,我的意思是,将流划分为给定大小的子流.不知何故,它将与Guava Iterators.partition()方法完全相同,只是希望分区是懒惰评估的Streams而不是List的.
Loop.times(5, () -> {
System.out.println("looping");
});
哪些有效编译到？
for(int i = 0; i < 5; i++)
System.out.println("looping");
或类似的东西
new CallableInterfaceImpl(){
public void call(){
for(int i = 0; i < 5; i++)
System.out.println("looping");
}
}.call();
它会替换(内联类),还是实际创建一个匿名类？
Java 8引入了lambda函数,我想实现像factorial这样的东西:
IntToDoubleFunction fact = x -> x == 0 ? 1 : x * fact.applyAsDouble(x-1);
编译返回
error: variable fact might not have been initialized
我怎样才能参考功能本身.类是匿名的但是实例存在:它被调用fact.
我正在审查Java 8的API更改,我注意到新方法java.util.Arrays并没有为所有原语重载.我注意到的方法是:
目前,这些新的方法只能处理int,long和double原语.
int,long和double,可能是最广泛使用的原语,所以有意义的是,如果他们必须限制API,他们会选择这三个,但为什么他们必须限制API？
有时我想在流上执行一组操作,然后以不同的方式处理结果流与其他操作.
我是否可以这样做而无需指定两次常见的初始操作？
例如,我希望dup()存在以下方法:
Stream [] desired_streams = IntStream.range(1, 100).filter(n -> n % 2 == 0).dup();
Stream stream14 = desired_streams[0].filter(n -> n % 7 == 0); // multiples of 14
Stream stream10 = desired_streams[1].filter(n -> n % 5 == 0); // multiples of 10
在Java 8及更高版本中可用Duration的新JSR 310 date API(java.time包)中的类中,javadoc说:
此类以秒和纳秒为单位模拟时间量或时间量.它可以使用其他基于持续时间的单位进行访问,例如分钟和小时.此外,DAYS单位可以使用,并且被视为完全等于24小时,因此忽略了夏令时效果.
那么,为什么以下代码崩溃？
Duration duration = Duration.ofSeconds(3000);
System.out.println(duration.get(ChronoUnit.MINUTES));
这提出了一个UnsupportedTemporalTypeException:
java.time.temporal.UnsupportedTemporalTypeException: Unsupported unit: Minutes
at java.time.Duration.get(Duration.java:537)
那么从持续时间对象中提取分钟和小时的推荐方法是什么？我们是否必须从秒数开始计算？为什么这样实现？
通常情况下,Java源代码已向前兼容.在Java 8之前,据我所知,编译类和源代码都已经与后来的JDK/JVM版本向前兼容.[更新:这是不正确的,请参阅下面的注释'en en'等.]但是,在Java 8中添加了默认方法后,似乎不再是这种情况.
例如,我一直使用的库的实现java.util.List包括一个List<V> sort().此方法返回已排序的列表内容的副本.这个库作为jar文件依赖项部署,在使用JDK 1.8构建的项目中运行良好.
但是,后来我有机会使用JDK 1.8重新编译库本身,我发现库不再编译: - List使用自己的sort()方法实现的类现在与Java 8 java.util.List.sort()默认方法冲突.Java 8 sort()默认方法对列表进行排序(返回void); 我的库的sort()方法 - 因为它返回一个新的排序列表 - 具有不兼容的签名.
所以我的基本问题是:
也:
以下是在1.7下编译和运行并在1.8下运行的一些代码示例 - 但不在1.8下编译:
import java.util.*;
public final class Sort8 {
public static void main(String[] args) {
SortableList<String> l = new SortableList<String>(Arrays.asList(args));
System.out.println("unsorted: "+l);
SortableList<String> s = l.sort(Collections.reverseOrder());
System.out.println("sorted : "+s);
}
public static class SortableList<V> extends ArrayList<V> { …我有一些使用Java Optionals的(简化)代码:
Optional<User> maybeTarget = userRepository.findById(id1);
Optional<String> maybeSourceName = userRepository.findById(id2).map(User::getName);
Optional<String> maybeEventName = eventRepository.findById(id3).map(Event::getName);
maybeTarget.ifPresent(target -> {
maybeSourceName.ifPresent(sourceName -> {
maybeEventName.ifPresent(eventName -> {
sendInvite(target.getEmail(), String.format("Hi %s, $s has invited you to $s", target.getName(), sourceName, meetingName));
}
}
}
不用说,这看起来很糟糕.但我想不出另一种以较少嵌套和更易读的方式做到这一点的方法.我考虑过流式传输3个选项,但放弃了这个想法,因为做了.filter(Optional::isPresent)一个.map(Optional::get)感觉甚至更糟.
那么是否有更好的,更"Java 8"或"可选识字"的方式来处理这种情况(基本上需要多个Optionals来计算最终操作)？
我正在开发一个严重依赖泛型类型的项目.它的一个关键组件是所谓的TypeToken,它提供了一种在运行时表示泛型类型并在其上应用一些实用函数的方法.为了避免Java的类型擦除,我使用大括号notation({})来创建一个自动生成的子类,因为这使得类型可以恢复.
TypeToken基本上做这是一个强烈简化的版本,TypeToken比原始实现更宽松.但是,我正在使用这种方法,所以我可以确保真正的问题不在于其中一个效用函数.
public class TypeToken<T> {
private final Type type;
private final Class<T> rawType;
private final int hashCode;
/* ==== Constructor ==== */
@SuppressWarnings("unchecked")
protected TypeToken() {
ParameterizedType paramType = (ParameterizedType) this.getClass().getGenericSuperclass();
this.type = paramType.getActualTypeArguments()[0];
// ...
}
基本上,这种实现几乎适用于所有情况.处理大多数类型没有问题.以下示例完美运行:
TypeToken<List<String>> token = new TypeToken<List<String>>() {};
TypeToken<List<? extends CharSequence>> token = new TypeToken<List<? extends CharSequence>>() {};
由于它不检查类型,上面的实现允许编译器允许的每种类型,包括TypeVariables.
<T> void test() {
TypeToken<T[]> token = new TypeToken<T[]>() {};
}
在这种情况下,type …
更新:看到每个方法可能会遇到不同的性能问题,我决定将这个问题分成两个:
最初的讨论可以在下面找到......
当我遇到一些令人惊讶的数据时,我正在比较我的库在Java 8和11下的性能.这是基准代码:
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.infra.Blackhole;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class MyBenchmark
{
@Benchmark
public void emptyMethod()
{
}
@Benchmark
public void throwAndConsumeStacktrace(Blackhole bh)
{
try
{
throw new IllegalArgumentException("I love benchmarks");
}
catch (IllegalArgumentException e)
{
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
bh.consume(sw.toString());
}
}
}
运行jmh 1.21,OracleJDK 1.8.0_192返回:
MyBenchmark.emptyMethod avgt 25 0.363 ± 0.001 ns/op
MyBenchmark.throwAndConsumeStacktrace avgt …