标签: java-8

我正在努力学习java - stream.我能够做简单的迭代/过滤/地图/收集等.

当我试图收集每个3个元素并打印时,如本例所示,[收集每3个元素并打印等等...]

    List<String> list = Arrays.asList("a","b","c","d","e","f","g","h","i","j");

    int count=0;
    String append="";
    for(String l: list){
        if(count>2){
            System.out.println(append);
            System.out.println("-------------------");
            append="";
            count=0;
        }
        append = append + l;
        count++;
    }
    System.out.println(append);

输出:

abc
-------------------
def
-------------------
ghi
-------------------
j

我没有得到任何线索如何使用流这样做.我应该实现自己的收藏家来实现这一目标吗？

Mar 12, 2017 02:39:00 "America/Chicago"不存在.当我将日期和时间设置为此值时,它不会失败.时间设定为Mar 12, 2017 03:39:00一小时后.如何通知此时间不存在.这是时间如何向前跳跃

01:59:59
3:00:00

正如您所见02:39:00,此日期永远不会存在.

这是我正在使用的代码

package com.company;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;

public class Main {

    public static void main(String[] args) {
        ZoneId zoneId = ZoneId.of("America/Chicago");
        ZonedDateTime dateTimeStart = ZonedDateTime.of(2017, 1, 1, 15, 39, 0, 0, ZoneId.of("America/Chicago"));
        ZonedDateTime dateTimeStartUtc = dateTimeStart.withZoneSameInstant(ZoneOffset.UTC);

        ZoneId zoneIdDst = ZoneId.of("America/Chicago");
        ZonedDateTime dateTimeStartDst = ZonedDateTime.of(2017, 3, 12, 2, 39, 0, 0, ZoneId.of("America/Chicago"));
        ZonedDateTime dateTimeStartUtcDst = dateTimeStart.withZoneSameInstant(ZoneOffset.UTC);
        int y = 90;
    } …

在进行流操作时,在中间/ pleleline操作期间,将创建具有不同特征的流(例如,SORTED/SIZED/DISTINCT/ORDERED) - 掌握Lambdas(第6章)

Stream.of(8,3,5,6,7,4)//ORDERED, SIZED
.filer(i->i%2==0) // ORDERED
.sorted() // ORDERED, SORTED
.distinct() // DISTINCT, ORDERED, SORTED
.map(i->i+1) // ORDERED
.unordered(); //none

我们如何找出上面代码段中提到的流的不同特征？

最新的Avro编译器(1.8.2)使用基于Joda-Time的实现为日期逻辑类型生成java源.如何配置Avro编译器以生成使用Java 8日期时间API的源？

是否stream.spliterator()隐式关闭stream,或者之后是否需要明确关闭它？

Stream<String> stream = Stream.of("a", "b", "c");
Spliterator<T> spliterator = stream.spliterator();
// Some low lever operation with the spliterator
stream.close(); // do we need to close?

乍一看,似乎该.spliterator()方法关闭了stream,但没有调用stream.close().至少如果我在.spliterator()调用方法后立即将其关闭,似乎不会影响分裂器操作.

Stream<String> stream = Stream.of("a", "b", "c").limit(2);
Spliterator<T> spliterator = stream.spliterator();
stream.close();
// Some low lever operation with the spliterator

这个问题可以扩展到其他stream方法,例如,.findAny().

stream.findAny() // Can I assume that I don't need to close the stream?
stream.onClose(() -> System.out.println("hi!")).findAny()`
// …

我想知道是否可以将lambda存放在某个容器中,例如.ArrayList或HashMap.我想更改该代码:

public enum OPCODE implements BinaryOperator<Integer> {
    MOV((x, y) -> y),
    INC((x, y) -> ++x),
    DEC((x, y) -> --x),
    ADD((x, y) -> x + y),
    SUB((x, y) -> x - y);

    private final BinaryOperator<Integer> binaryOperator;

    OPCODE(BinaryOperator<Integer> binaryOperator) {
        this.binaryOperator = binaryOperator;
    }  

    @Override
    public Integer apply(Integer integer, Integer integer2) {
        return binaryOperator.apply(integer, integer2);
    }
}

对于这样的事情:

List<BinaryOperator<Integer>> opcodes = new ArrayList<BinaryOperator<Integer>>(){
    ((x, y) -> y),
    ((x, y) -> ++x)
};

等等

并像这样使用它:

opcodes[0].apply(a, b);

甚至可能吗？

我找到了以下代码片段:

Function<Integer, Predicate<Integer>> smallerThan = x -> y -> y < x;
List<Integer> l = Arrays.asList(5, 6, 7, 23, 4, 5645,
    6, 1223, 44453, 60182, 2836, 23993, 1);

List<Integer> list2 = l.stream()
    .filter(smallerThan.apply(l.get(0)))
    .collect(Collectors.toList());

System.out.println(list2);

作为输出我收到:

[4, 1]

smallerThan考虑到我们只传递一个参数,本例中的函数如何工作smallerThan.apply(l.get(0))？

以下代码抛出

Exception in thread "main" java.lang.ClassCastException: test.Subclass2 cannot be cast to test.Subclass1
at test.LambdaTest.main(LambdaTest.java:17)

public class LambdaTest {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ToLongFunction<B> fn1 = serde((ToLongFunction<B> & Serializable) B::value);
        ToLongFunction<C> fn2 = serde((ToLongFunction<C> & Serializable) C::value);
        fn1.applyAsLong(new B());
        fn2.applyAsLong(new C()); // Line 17 -- exception here!
    }

    private static <T extends Serializable> T serde(T t) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        new ObjectOutputStream(bos).writeObject(t);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos
                .toByteArray()));
        return (T) …

我们有一个在openjdk8中运行的Java应用程序,其最大堆内存在运行时发生变化 - 可能是什么原因造成的？

我发现问题为什么堆在java中发生了变化,这指向解释max与committed内存之间差异的文章.在我们的例子中,似乎这两个通常是相同的,但并非总是如此 - 请参阅下面截图的11:53.

堆也可以更改为年轻代串行收集器(-XX:MaxHeapFreeRatio请参阅鼓励JVM到GC而不是增长堆？),但是我们使用并行收集器,所以情况并非如此.

我们运行应用程序的内存相关JVM参数:

-XX:MaxMetaspaceSize=200M -Xms2000m -Xmx2000m

不确定它是否相关,应用程序在11:55到11:58之间对老一代进行了并行标记扫描 - 此时有超过200MB的可用内存可用,我们看不出任何这种行为的原因.

我有一个ZonedDateTime像这样构造的对象

ZonedDateTime z = ZonedDateTime.of(LocalDate.now().atTime(11, 30), ZoneOffset.UTC);

我如何将其转换LocalDateTime为瑞士时区？预期结果应该是16 april 2018 13:30.