标签: java-8

正在浏览这里Java 8提到的功能.无法理解究竟是什么.有人可以解释一下和之间的实际区别是什么？parallelSort()sort()parallelSort()

有没有办法用java 8填充数组Supplier？

我想写:

Supplier<Object> supplier = () -> new Object();
Object[] array = new Object[size];
Arrays.fill(array, supplier);

注意:我知道我可以编写自己的方法.

我试图在Java 8中使用新的Stream API生成随机的整数数组.但我还没有清楚地理解这个API.所以我需要帮助.这是我的代码.

Random random = new Random();
IntStream intStream = random.ints(low, high);
int[] array =  intStream.limit(limit) // Limit amount of elements
                                    .boxed() // cast to Integer
                                    .toArray();

但是这段代码返回了一些对象.这有什么问题？

在Java 8中,方法引用是使用::运算符完成的.

例如

// Class that provides the functionality via it's static method
public class AddableUtil {
  public static int addThemUp(int i1, int i2){
    return i1+i2;
  }
}

// Test class
public class AddableTest {
  // Lambda expression using static method on a separate class
  IAddable addableViaMethodReference = AddableUtil::addThemUp;
  ...
}

你可以看到addableViaMethodReference现在的行为就像是一个别名AddableUtil::addThemUp.因此addableViaMethodReference()将执行相同的操作 AddableUtil.addThemUp()并返回相同的值.

他们为什么选择引入新的运营商而不是现有运营商？我的意思是,当函数名称结束时执行函数,()并在没有尾随时返回函数引用().

方法执行

AddableUtil.addThemUp();

方法参考

AddableUtil.addThemUp;

这不是更简单直观吗？AFAIK,AddableUtil.addThemUp当前不(Java 7)用于任何其他目的并抛出编译错误.为什么不利用这个机会而不是创建一个全新的运营商呢？

让我们说我们必须使用这段无聊的代码:

ArrayList<Long> ids = new ArrayList<Long>();
for (MyObj obj : myList){
    ids.add(obj.getId());
}

切换到Java 8后,我的IDE告诉我我可以用这个代码替换collect call它,并自动生成:

ArrayList<Long> ids = myList.stream().map(MyObj::getId).collect(Collectors.toList());

但是它给了我这个错误:

Steam中的collect(java.util.stream.Collector)无法应用于:(java.util.stream.Collector,capture,java.util.List>)

我试图铸造参数,但它给我不确定的A和R,而IDE没有给任何建议.

我很好奇你collect call在这种情况下如何使用,我找不到任何可以指导我的信息.任何人都可以光明吗？

Javadoc Stream.forEach表示(强调我的):

此操作的行为明确是不确定的.对于并行流管道,此操作不保证遵守流的遭遇顺序,因为这样做会牺牲并行性的好处.对于任何给定元素,可以在任何时间以及库选择的任何线程中执行该动作.如果操作访问共享状态,则它负责提供所需的同步.

Java 9 Early Access Javadoc中提供了相同的文本.

第一句("明确不确定")表明(但没有明确说明)此方法不会保留遭遇顺序.但是明确说明顺序没有保留的下一个句子是以"For parallel stream pipeline"为条件的,如果不管并行性如何应用该句子,那么这个条件就没有了.这让我不确定forEach是否会保留顺序流的顺序.

这个答案指出了流库实现调用的位置.sequential().forEach(downstream).这表明forEach旨在保留顺序流的顺序,但也可能只是库中的错误.

我通过使用forEachOrdered安全的方式回避了我自己的代码中的这种模糊性,但今天我发现NetBeans IDE的"使用功能操作"编辑器提示将转换

for (Foo foo : collection)
    foo.bar();

成

collection.stream().forEach((foo) -> {
    foo.bar();
});

如果forEach不保留遭遇顺序,则会引入错误.在我报告针对NetBeans的错误之前,我想知道库实际上保证了什么,并由源备份.

我正在寻找权威人士的答案.这可能是图书馆实施中的一个明确的评论,关于Java开发邮件列表的讨论(谷歌没有找到任何东西,但我可能不知道这些神奇的词汇),或者是图书馆设计师的声明(其中我知道两个,Brian Goetz和Stuart Marks,积极参与Stack Overflow).(请不要回答"只是使用forEachOrdered" - 我已经这样做了,但我想知道代码是否错误.)

我正在编写一个自定义java 8收集器,它应该计算具有getValue()方法的POJO的平均值.这是代码:

public static Collector<BoltAggregationData, BigDecimal[], BigDecimal> avgCollector = new Collector<BoltAggregationData, BigDecimal[], BigDecimal>() {

        @Override
        public Supplier<BigDecimal[]> supplier() {
            return () -> {
                BigDecimal[] start = new BigDecimal[2];
                start[0] = BigDecimal.ZERO;
                start[1] = BigDecimal.ZERO;
                return start;
            };
        }

        @Override
        public BiConsumer<BigDecimal[], BoltAggregationData> accumulator() {
            return (a,b) ->  {
                a[0] = a[0].add(b.getValue());
                a[1] = a[1].add(BigDecimal.ONE);
            };
        }

        @Override
        public BinaryOperator<BigDecimal[]> combiner() {
            return (a,b) -> {
                a[0] = a[0].add(b[0]);
                a[1] = a[1].add(b[1]);
                return a;
            };
        }

        @Override
        public Function<BigDecimal[], …

我对我的应用程序进行了一些分析,其中一个结果发现堆上大约18%的内存被类型的对象使用Double.事实证明这些对象是Maps 中的值,我不能使用原始类型.

我的理由是原始类型double消耗的内存少于它的对象Double.有没有办法有一个像数据结构的地图,可以接受任何类型的键和基元double作为值？

主要业务是:

• 插入(可能只有一次)
• 查找(按键包含)
• 检索(按键)
• 迭代

我拥有的典型地图是:

• HashMap<T, HashMap<NodeData<T>, Double>> graph
• HashMap<Point2D, Boolean> onSea (虽然不是双倍价值)
• ConcurrentHashMap<Point2D, HashMap<Point2D, Double>>

全部用于Java 8.

附录

我主要对那些有这些类型的地图解决方案的框架不感兴趣,但对解决这些问题时需要考虑的内容感兴趣.如果您愿意,任何此类框架背后的概念/想法/方法是什么.或者解决方案也可能在另一个层面,其中地图被替换为像@Ilmari Karonen在他的答案中指出的特定模式的对象.

我现在正在学习lambda,我想知道如何用lambda一行编写这段代码.

我有一个Person包括ID和name字段的类

目前,我有一个List<Person>存储这些Person对象.我想要完成的是获取一个由人的id组成的字符串.

"id1,id2,id3".

我怎样才能用lambda实现这个目标？

A HashMap有一个来自它的文档的短语:

如果初始容量大于最大条目数除以加载因子,则不会发生重新加载操作.

注意文档怎么说的老调重弹,没有调整 -即使翻版只会当调整大小会发生; 那就是当桶的内部大小增加两倍时.

当然HashMap,我们可以提供这样一个构造函数来定义这个初始容量.

使用指定的初始容量和默认加载因子(0.75)构造一个空的HashMap.

好的,似乎很容易:

// these are NOT chosen randomly...    
List<String> list = List.of("DFHXR", "YSXFJ", "TUDDY", 
          "AXVUH", "RUTWZ", "DEDUC", "WFCVW", "ZETCU", "GCVUR");

int maxNumberOfEntries = list.size(); // 9
double loadFactor = 0.75;

int capacity = (int) (maxNumberOfEntries / loadFactor + 1); // 13

所以容量是13(内部是16- 下一个2的幂),这样我们保证文档部分不重复.好吧,让我们测试一下,但首先介绍一个方法,进入HashMap并查看值:

private static <K, V> void debugResize(Map<K, V> map, K key, V value) throws Throwable …