小编Ste*_*bel的帖子

我尝试ArrayType[]::new在以下示例中使用带有表达式的引用方法:

public class Main
{
    public static void main(String[] args)
    {
        test1(3,A[]::new);
        test2(x -> new A[] { new A(), new A(), new A() });

        test3(A::new);
    }

    static void test1(int size, IntFunction<A[]> s)
    {
        System.out.println(Arrays.toString(s.apply(size)));
    }

    static void test2(IntFunction<A[]> s)
    {
        System.out.println(Arrays.toString(s.apply(3)));
    }

    static void test3(Supplier<A> s)
    {
        System.out.println(s.get());
    }
}

class A
{
    static int count = 0;
    int value = 0;

    A()
    {
        value = count++;
    }

    public String toString()
    {
        return Integer.toString(value);
    }
}

产量

[null, …

(这可能与/sf/answers/2121852421/有关,但我恐怕还是没有得到它.所以我这样问我的问题,希望它能够得出一个我可以更容易理解的答案.)

通常,当我有一个Stream时,我可以使用Collectors类中的一个静态方法将其转换为集合:

List<String> strings = Stream.of("this", "is", "a", "list", "of", "strings")
    .collect(Collectors.toList());

然而,类似的过程不适用于原始流,正如其他人注意到的那样:

IntStream.of(3, 1, 4, 1, 5, 9)
    .collect(Collectors.toList());  // doesn't compile

我可以这样做:

IntStream.of(3, 1, 4, 1, 5, 9)
    .boxed()
    .collect(Collectors.toList());

或者我可以这样做:

IntStream.of(3, 1, 4, 1, 5, 9)
    .collect(ArrayList<Integer>::new, ArrayList::add, ArrayList::addAll);

问题是,为什么Collectors.toList()只为原始流做这个？难道没有办法指定包装类型吗？如果是这样,为什么这不起作用:

IntStream.of(3, 1, 4, 1, 5, 9)
    .collect(Collectors.toCollection(ArrayList<Integer>::new)); // nope

任何见解将不胜感激.

我有一堆列作为csv文件中的字符串数组.现在我想解析它们.由于这种解析需要日期解析和其他不那么快的解析技术,我正在考虑并行性(我计时,它需要一些时间).我的简单方法:

Stream.of(columns).parallel().forEach(column -> 
    result[column.index] = parseColumn(valueCache[column.index], column.type));

列包含的ColumnDescriptor元素只有两个属性,即要解析的列索引和定义如何解析它的类型.没有其他的.result是一个Object数组,它接受结果数组.

问题是现在解析函数抛出ParseException,我进一步处理调用堆栈.既然我们在这里并行,它就不能被抛出.处理这个问题的最佳方法是什么？

我有这个解决方案,但我有点畏缩阅读它.什么是更好的方法呢？

final CompletableFuture<ParseException> thrownException = new CompletableFuture<>();
Stream.of(columns).parallel().forEach(column -> {
    try {
        result[column.index] = parseColumn(valueCache[column.index], column.type);
    } catch (ParseException e) {
        thrownException.complete(e);
    }});

if(thrownException.isDone())
    //only can be done if there is a value set.
    throw thrownException.getNow(null);

注意:我不需要所有例外.如果我按顺序解析它们,我也只会得到一个.这样就可以了.

我正在尝试在我的Android项目中使用lambda表达式和流.我正在使用streamsupport库来实现流,而将本地Java 8用于lambda表达式.为了能够使用我需要添加的Java 8功能

compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
}

这个代码在我的gradle中,但是编译器显示了这个错误:

Error:Jack is required to support java 8 language features. Either enable Jack or remove sourceCompatibility JavaVersion.VERSION_1_8.

然后我加了这个

jackOptions {
    enabled true
}

并且编译器没有错误,但在运行时,同样的错误不断显示. 这是我的傻瓜

apply plugin: 'com.android.application'

android {
    compileSdkVersion 25
    buildToolsVersion "25.0.3"

    defaultConfig {
        applicationId "home.gio.calorieplanner"
        minSdkVersion 16
        targetSdkVersion 25
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        multiDexEnabled true
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' …

我想为我的Python包创建一个bdist.该软件包包含一个LICENSE文件,该文件作为分发的一部分是必需的.

我LICENSE在我的文件中添加了对该文件的引用MANIFEST.IN,实际上在为我的包创建了一个sdist后,该LICENSE文件就在那里.

然而,似乎当我为我的package(python setup.py bdist_wheel)构建一个Python轮时,该LICENSE文件无处可见.

我熟悉setup.py的概念package_data和data_files- 但它们似乎与我的用例无关: package_data要求LICENSE文件在Python包中,但我需要将此文件放在顶级文件夹中该项目不是Python包. data_files要求我在安装后映射文件的目标目录,但它不是相对于项目的包,而是相对于python安装 - 我发现它非常奇怪,因为它可能取决于操作系统/平台,是否virtualenv使用等

据我所知,在一天结束时,软件包安装在site-packages安装后的"顶级文件"下面没有空间.尽管如此,我正在寻找一种方法将LICENSE文件作为我的一部分wheel,即使它在安装过程中没有被复制到任何特定位置.

我的列表包含类似的集合[1,3,5][2,6,4],大小相同.我试过这样做,但似乎没有用.

List<TreeSet<T>> block;
    for(TreeSet<T> t : block){
        block.stream().sorted((n,m)->n.compareTo(m)).collect(Collectors.toSet());

    }

我想要的最终结果是[1,2,3][4,5,6].

我可以尝试添加在所有的元素ArrayList和那种出来再做出新List的TreeSet的.但是有一种衬垫吗？

更新:

List<T> list=new ArrayList<T>();
    for(TreeSet<T> t : block){

        for(T t1 : t)
        {
            list.add(t1);   

        }
    }

    list=list.stream().sorted((n,m)->n.compareTo(m)).collect(Collectors.toList());

这有效但可以简化吗？

我很少去幻想和写硒页面对象与Java 8流,如下面的代码中提到并得到了我的代码是打破得墨忒耳定律,因为我在一行做很多操作的审查意见.我被建议将代码分解为第一个流来收集列表并运行另一个流操作来进行匹配(简而言之,根据需要将其分解为多个流).我不相信Stream是用于处理数据处理的,如果我们将其分解为多个流,那么使用流是没有意义的.在此之前,我曾参与过网络安全项目,数百万条记录通过流媒体处理,并通过多种逻辑操作对数据进行排序.

请分享您的想法,我已经按照审稿人的建议对其进行了更改,但他无法解释原因,我想了解更多关于流和正确利用这一强大的java 8补充方法的方法.

以下是示例代码:

listOfWebElements.stream().filter(element -> element.getText().contains(name)).findFirst().ifPresent(match -> match.click());

我在这个问题中指的是这条线,提供方法使它更有意义.

@FindBy(css = "#someTable td.some-name li a") List<WebElement> listOfWebElements;

public SomeClass doSomething(String name) {

    wait.until(visibilityOfAllElements(listOfWebElements));
    listOfWebElements.stream().filter(element -> element.getText().contains(name)).findFirst()
            .ifPresent(match -> match.click());
    return new SomeClass(driver);

}

我读了这篇Java 8官方文档:

流可能有也可能没有已定义的遭遇顺序.流是否具有遭遇顺序取决于源和中间操作.某些流源(例如List或数组)本质上是有序的,而其他流(例如HashSet)则不是.
如果订购了流,则在相同的源上重复执行相同的流管道将产生相同的结果; 如果没有订购,重复执行可能会产生不同的结果.

试图通过此代码了解上述行为

public class StreamOrderValidator
{
    public static void main( String[] args )
    {
        String[] colors=new String[] {"red","green","blue","orange"};
        List<String> colorsList=Arrays.asList(colors);

        HashSet<String> colorsSet=new HashSet<>();
        colorsSet.addAll(colorsList);
        System.out.println(colorsSet);            // [red, orange, green, blue]

        List<String> processedColorsSet = processStream(colorsSet.stream());
        System.out.println(processedColorsSet);   // [RED, ORANGE, GREEN, BLUE]
    }

    private static List<String> processStream(Stream<String> colorStream) {
        List<String> processedColorsList = colorStream.filter(s->s.length()<=6).
                map(String::toUpperCase).collect(Collectors.toList());
        return processedColorsList;
    }
}

我多次运行此代码,结果流中元素的顺序始终相同(显示为注释).我无法弄清楚这是如何证明以上引用的文字"订单不被保留为无序集合".

我肯定误解了javadocs提取的文本.

过滤和映射流的默认"最佳做法"是

Stream<T> source;
// ...
Predicate<T> predicate; // = ...
Function<T, U> mapper; // = ...
Stream<U> dst = source
         .filter(predicate)
         .map(mapper);

在许多软件项目中,您将达到必须在多个流上应用相同的过滤器和映射操作的程度.例如,类T的对象集合应该转换为U类对象的List,其中U是T的子类,我们只需要U的实例.所以可以写:

Collection<T> source;
// ...
List<U> dst = source.stream()
            .filter(U.class::isInstance)
            .map(U.class::cast)
            .collect(Collectors.toList());

为了概括这一点,我写了一个帮助方法,名为onlyInstancesOf:

static <T, U> Function<T, Stream<U>> onlyInstancesOf(Class<U> clazz) {
    return t -> clazz.isInstance(t)
            ? Stream.of(clazz.cast(t))
            : Stream.empty();
}

然后,此方法用于flatMap:

List<U> dst = source.stream()
            .flatMap(onlyInstancesOf(U.class))
            .collect(Collectors.toList());

我经常使用的另一个功能是optionalPresent处理包含Optionals的流:

static <T> Function<Optional<T>, Stream<T>> optionalPresent() {
    return t -> t.map(Stream::of).orElse(Stream.empty());
}

和用法:

Collection<Optional<T>> source; …

我正在尝试Java中的并行流,为此,我有以下代码来计算以前的素数n.

基本上我有两种方法

• calNumberOfPrimes(long n) - 4种不同的变种
• isPrime(long n) - 2种不同的变种

实际上我有上述每种方法的两种不同变体,一种是使用并行流的变体,另一种是不使用并行流的变体.

    // itself uses parallel stream and calls parallel variant isPrime
    private static long calNumberOfPrimesPP(long n) {
        return LongStream
                .rangeClosed(2, n)
                .parallel()
                .filter(i -> isPrimeParallel(i))
                .count();
    }

    // itself uses parallel stream and calls non-parallel variant isPrime
    private static long calNumberOfPrimesPNP(long n) {
        return LongStream
                .rangeClosed(2, n)
                .parallel()
                .filter(i -> isPrimeNonParallel(i))
                .count();
    }

    // itself uses non-parallel stream and calls parallel variant isPrime
    private static long calNumberOfPrimesNPP(long n) …