我有Java 8 SDK和运行时,以及只使用Java 7功能的项目.我想知道我是否可以设置intellij来构建一个Java-7级jar,这绝对可以从命令行获得？
到目前为止,我尝试将项目语言级别设置为7作为实验,但这显然是不够的,而不是我真正需要的.
我也在SO上看到了这个问题:" 当我将Java7编译器配置为使用Java6时,使用java7编译器编译Intellij IDEA ",但我的项目SDK已经设置为最新的Java版本,我只需要一个Java-7-兼容的工件/ jar编译.
编辑:我在本地系统上只有Java 6和Java 8 JRE/SDK,因为遗憾的是Java 7在我的系统上存在问题并且不兼容.
假设以下API:
package nashorn.test;
public class API {
public static void test(String string) {
throw new RuntimeException("Don't call this");
}
public static void test(Integer... args) {
System.out.println("OK");
}
}
以下Nashorn JavaScript代码段将失败:
var API = Java.type("nashorn.test.API");
API.test(1);
将调用第一种方法而不是第二种方法.这是Nashorn引擎中的一个错误吗？
为了记录,此问题先前已在jOOQ用户组上报告,其中方法重载和varargs被大量使用,并且此问题可能会导致很多麻烦.
可能有人怀疑这可能与拳击有关.它没有.当我这样做时,问题也出现了
public class API {
public static void test(String string) {
throw new RuntimeException("Don't call this");
}
public static void test(Integer... args) {
System.out.println("OK");
}
public static void test(MyType... args) {
System.out.println("OK");
}
}
和:
public class MyType {
}
然后: …
是否有一种理智的方式从列表中获取有序流(具体来说,数组列表,但它应该无关紧要)流式元素与它们在原始列表中的方式相反？
我正在寻找一种不涉及缓冲数据的解决方案(收集器,另一个列表,数组等,因为它们复制了浪费的容器),或者使用Collections.reverse(因为它修改了列表).
到目前为止,我在这里看到的最干净的方法之一是实现我自己的版本的Spliterator这ORDERED和在列表中反向前进,或实施Iterator反向迭代是,并使用Spliterators.spliteratorUnknownSize(iterator,ORDERED)它.
注意这个问题不同于Java 8流逆序:其他问题询问如何反转流(一般情况下这是不可能的),并且答案提供了以某种方式反转源(我不想这样做),然后传输反向源.逆转源的成本是O(N),如果可能的话我想完全避免它.
反正有没有得到一个java.time(Java 8中新的)兼容时间类ResultSet？
我知道你可以使用ResultSet's getDate或者getTimestamp这些方法返回java.sql.Date/ java.sql.Timestamp对象现在已被弃用,所以使用它们来创建一个ZonedDateTime或类似的似乎是不好的做法.
我想排序seq1升序和seq2降序所以我这样做:
list = list.stream().sorted(comparing(AClass::getSeq1).thenComparing(
AClass::getSeq2).reversed()).collect(toList());
但结果出来了,因为seq1和seq2都按降序排序.
我可以这样做以使seq1升序和seq2降序:
sorted(comparing(AClass::getSeq1)
.reversed().thenComparing(AClass::getSeq2).reversed()
这是真正的正确方法吗？
在下面的代码示例中,做了::什么:
public static void main(String[] args) {
List<Integer> l = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer s = l.stream().filter(Tests::isGT1)
.filter(Tests::isEven)
.map(Tests::doubleIt)
.findFirst()
.orElse(100);
System.out.println(s);
}
private static boolean isGT3(int number){
return number > 3;
}
private static boolean isEven(int number){
return number % 2 ==0;
}
private static int doubleIt(int number){
return number * 2;
}
我试图了解是否有办法终止还原操作而不检查整个流,我无法找到方法.
用例大致如下:让一长串的Integers需要折叠成一个Accumulator.每个元素检查都可能很昂贵,所以在内部Accumulator,我对传入进行检查Accumulator,看看我们是否需要执行昂贵的操作 - 如果我们不这样做,那么我只需返回累加器.
对于小(呃)列表来说,这显然是一个很好的解决方案,但是巨大的列表会产生我不想要的不必要的流元素访问成本.
这是一个代码草图 - 仅假设连续减少.
class Accumulator {
private final Set<A> setA = new HashSet<>;
private final Set<B> setB = new HashSet<>;
}
class ResultSupplier implements Supplier<Result> {
private final List<Integer> ids;
@Override
public Result get() {
Accumulator acc = ids.stream().reduce(new Accumulator(), f(), (x, y) -> null);
return (acc.setA.size > 1) ? Result.invalid() : Result.valid(acc.setB);
}
private static BiFunction<Accumulator, Integer, Accumulator> f() {
return (acc, element) -> {
if …我是Java 8的新手,我遇到了Consumer java doc,它说:"预计消费者将通过副作用进行操作." 有人可以解释为什么这么说？
我想循环一个庞大的数组并做一组复杂的指令需要很长时间.但是,如果超过30秒,我希望它放弃.
恩.
final long start = System.currentTimeMillis();
myDataStructure.stream()
.while(() -> System.currentTimeMillis() <= start + 30000)
.forEach(e ->
{
...
});
如果满足某个条件,我想避免return在forEach通话中说话.
基本上这是在试图回答另一个问题时出现的.假设这段代码:
AtomicInteger i = new AtomicInteger(0);
AtomicInteger count = new AtomicInteger(0);
IntStream.generate(() -> i.incrementAndGet())
.parallel()
.peek(x -> count.incrementAndGet())
.limit(5)
.forEach(System.out::println);
System.out.println("count = " + count);
我理解这IntStream#generate是一个无序的无限流的事实,并且要完成它必须有一个短路操作(limit在这种情况下).我也明白,在Supplier达到该限制之前,Stream实现的次数可以自由调用.
在java-8下运行它会count一直打印512(可能并不总是,但在我的机器上是这样).
在对比运行中,这在java-10下很少超过5.所以我的问题是内部发生了什么变化,短路发生得更好(我试图通过拥有源并试图做一些差异来解决这个问题......)