标签: java-8

在Java 8堆打印输出中,您可能会看到如下所示的行:

Metaspace 使用 2425K,容量 4498K,承诺 4864K,保留 1056768K

https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/considerations.html尝试解释该行:

在以Metaspace开头的行中,使用的值是用于加载类的空间量.该容量值可用于当前分配块的元数据的空间.该承诺值的可用空间块的数量.的保留值是用于元数据的空间保留(但不一定提交)的量.

再次,从上面的链接:

从操作系统请求空间,然后分成块.类加载器从其块中为元数据分配空间(块绑定到特定的类加载器).

我想知道每个字段的含义(使用,容量,承诺,保留),但我很难理解上面的定义.

我的理解是,元空间是从JVM进程的虚拟地址空间中划分出来的.JVM在启动时保留初始大小,基于-XX:MetaspaceSize,它具有未记录的,特定于平台的默认值.我假设保留是指元空间的总大小.空间分为块.我不确定每个块是否具有相同的大小.每个块包含与单个类加载器关联的类元数据.

容量和承诺的声音对我来说就像是免费空间(基于链接的定义).由于元数据存储在块中,因此我假设使用的+容量将等于已提交,但事实并非如此.也许承诺意味着使用的保留空间,但那么使用的意思是什么？元数据使用的空间？那么,还有什么方法可以使用这个空间？

我希望你看到我的困惑.我希望澄清这些定义.

我可以使用Arrays.stream(array)或从数组创建一个Stream Stream.of(values).同样,是否可以直接从数组创建ParallelStream,而无需创建中间集合,如Arrays.asList(array).parallelStream()？

所述partitioningBy集电极施加到谓词中的每个元素流,并产生从布尔地图以从满足或不满足谓词流元素的列表.例如:

Stream.of(1,2,3,4).collect(partitioningBy(x -> x >= 3))
// {false=[1, 2], true=[3, 4]}

正如分区的目的是什么所讨论的,观察到的行为是partitioningBy总是返回一个包含true和false条目的映射.例如:

Stream.empty().collect(partitioningBy(x -> false));
// {false=[], true=[]}

Stream.of(1,2,3).collect(partitioningBy(x -> false));
// {false=[1, 2, 3], true=[]}

Stream.of(1,2,3).collect(partitioningBy(x -> true));
// {false=[], true=[1, 2, 3]}

这种行为实际上是在某处指定的吗？Javadoc只说:

返回一个Collector,它根据Predicate对输入元素进行分区,并将它们组织成一个Map<Boolean, List<T>>.返回的Map的类型,可变性,可序列化或线程安全性无法保证.

符合实现可以返回这些:

Stream.empty().collect(partitioningBy(x -> false));
// {}, or {false=[]}, or {true=[]}

Stream.of(1,2,3).collect(partitioningBy(x -> false));
// {false=[1, 2, 3]}

Stream.of(1,2,3).collect(partitioningBy(x -> true));
// {true=[1, 2, 3]}

相应的JSR 335 …

我想将下面方法的返回类型更改为 Future[Unit]

def send(data: Array[Byte]): CompletableFuture[Void] = {
  val f:CompletableFuture[Void] = client.send(data)
  f
}

我正在使用Scala 2.12.1.有没有方便的方法从Java 8转换CompletableFuture为Scala Future？

我找到了一段代码,从Java 7切换到Java 8后停止编译.它没有任何新的Java 8内容,如lambda或流.

我将有问题的代码缩小到以下情况:

GenericData<Double> g = new GenericData<>(1d);
Double d = g == null ? 0 : g.getData(); // type error!!!

您可能猜测GenericData构造函数有一个泛型类型的参数,该getData()方法只返回该泛型类型.(有关完整的源代码,请参阅下文.)

现在困扰我的是,在Java 7中,代码编译得很好,而使用Java 8,我得到以下错误:

CompileMe.java:20: error: incompatible types: bad type in conditional expression
Double d = g == null ? 0 : g.getData();
                       ^
int cannot be converted to Double

似乎Java 7能够从int - > double - > Double进行转换,但Java 8因尝试立即从int - > Double而失败.

我觉得特别有趣的是Java 8 确实接受代码时,我改变它getData()到data,即访问GenericData通过变量本身而不是消气方法的价值:

Double …

有人可以向我解释以下行为吗？

我有一个列表X并使用该addAll()方法添加元素.这些元素由使用泛型类型的方法返回.方法getA()返回< T extends A >与A作为一类.方法getI()返回< T extends I >与I作为一个接口(见下面的代码).

差异:listX.addAll(getA())我得到编译错误(如预期的那样),但是listX.addAll(getI())编译(当元素被强制转换时抛出运行时错误X).

简化代码:

interface I {}
class A implements I {}

class X {}

public void test() {   
    List<X> listX = new ArrayList<>();
    listX.addAll(getA());

    listX.addAll(getI());
    for (X x : listX) {}
}
public <T extends A> List<T> getA() {
    return new ArrayList<>();
}
public <T extends I> List<T> getI() …

请考虑以下代码:

 List<Integer> odd = new ArrayList<Integer>();
 List<Integer> even = null;  
 List<Integer> myList = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
 even = myList.stream()
              .filter(item -> {
                   if(item%2 == 0) { return true;}
                   else { 
                           odd.add(item); 
                           return false;
                   }
              })
              .collect(Collectors.toList());

我在这里要做的是将列表中的偶数和奇数值分别放入单独的列表中.

stream filter()方法返回true偶数项,流收集器将收集它们.
对于奇数情况,过滤器将返回false,项目将永远不会到达收集器.

所以我在else块之前创建的另一个列表中添加了这些奇数.

我知道这不是一种优雅的流式处理方式.例如,如果我使用并行流,那么奇数列表将出现线程安全问题.由于性能原因,我不能使用不同的过滤器多次运行它(应该是O(n)).

这只是一个用例的示例,列表可以包含任何对象,并且过滤器内的lambda需要根据某些逻辑将它们分离到单独的列表中.

简单来说:从列表中创建多个列表,其中包含基于某些条件分隔的项目.

如果没有流,只需运行for循环并执行简单的if-else并根据条件收集项目.

我已经在JDK 1.8上工作了几天,在那里我遇到了一些与此类似的代码:

List<Integer> list = Arrays.asList(1,2,3,4,5);
list.stream();

现在,对于使用streams(java.util.stream)的人来说,它看起来既简单又干净,我找不到实现该java.util.Collection.stream()方法的实际类.

当我说list.stream():我有以下问题:

1. 我java.util.stream.Stream从哪里得到的？
2. 他们是如何实现它而不实际"扰乱"现有的集合？(假设他们没有触及它们)

我也尝试过的单证看java.util.AbstractCollection和java.util.AbstractList,但未能找到它.

我想从地图地图转换内部地图.

旧地图:Map<String, Map<LocalDate, Integer>>整数表示秒

新地图: Map<String, Map<LocalDate, Duration>>

我试过创建了新的内部地图,但是出了错误

错误:java:找不到适合方法的putAll(java.util.stream.Stream<java.lang.Object>) 方法java.util.Map.putAll(java.util.Map<? extends java.time.LocalDate,? extends java.time.Duration>)不适用

oldMap.entrySet().stream()
            .collect(Collectors.toMap(Map.Entry::getKey,
                e -> new HashMap<LocalDate, Duration>() {{
                    putAll(
                        e.getValue().entrySet().stream()
                            .map(x -> new HashMap.SimpleEntry<LocalDate, Duration>
                                (x.getKey(), Duration.ofSeconds(x.getValue())))
                    );
                }}
            ));

假设我已经List<Car>并且我想搜索该列表以验证我同时拥有思域和焦点.如果它是一个OR,它很容易,因为我可以在它上面应用OR .filter().请记住,我不能filter().filter()为这种类型的AND做.

一个有效的解决方案是:

boolean hasCivic = reportElements.stream()
        .filter(car -> "Civic".equals(car.getModel()))
        .findFirst()
        .isPresent();

boolean hasFocus = reportElements.stream()
        .filter(car -> "Focus".equals(car.getModel()))
        .findFirst()
        .isPresent();

return hasCivic && hasFocus;

但后来我基本上处理了两次列表.我不能&&在过滤器中应用,也不能filter().filter().

有没有办法处理流一次,以查找列表是否包含思域和焦点汽车？

重要更新:提供的解决方案的关键问题是它们都保证O(n),而我的解决方案可以在两次比较后完成.如果我的汽车列表是1000万辆汽车,那么将会有非常显着的性能成本.然而,我的解决方案感觉不对,但也许这是性能最佳的解决方案......