小编Ste*_*bel的帖子

我想为我的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());

这有效但可以简化吗？

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

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; …

我想使用mapMulti而不是flatMap重构以下代码：

// using flatMap (version 1) => returns Set<Item>
var items = users.stream()
                 .flatMap(u -> u.getItems().stream())
                .collect(Collectors.toSet());

进入这个（版本2）：

// using mapMulti (version 2) => returns Set<Item>
var items = users.stream()
                 .<Item>mapMulti((u, consumer) -> u.getItems().forEach(consumer))
                 .collect(Collectors.toSet());

两者都返回相同的元素。然而，我怀疑我是否真的应该用flatMap更冗长的mapMulti. 为什么需要在mapMuli( .<Item>mapMulti)之前添加类型信息。如果我不包含类型信息，它将返回一个Set<Object>. （如何）我可以简化吗mapMulti？

我试图使用以下代码将2D int数组转换为2D String数组:

Arrays.stream(intArray).map(a -> 
    Arrays.stream(a).map(i -> 
        Integer.toString(i)).toArray()).toArray(String[][]::new);

但是cannot convert from String to int在做的时候我得到了编译时的错误Integer.toString(i).我以为可能是因为我正在收集int数组中流式传输数据的结果String,但是没有map创建新的Collection？

我有一个int数组列表.我想通过唯一的数组进行分组.

int[] array1 = new int[]{1, 2, 3};
int[] array2 = new int[]{1, 2, 3}; //array1 = array2 
int[] array3 = new int[]{0, 2, 3};

List<int[]> test = new ArrayList<>();

test.add(array1);
test.add(array2);
test.add(array3);

test.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); 

不幸的是,它不起作用.它分组就好像任何数组都是唯一的:

{1, 2, 3} - 1
{1, 2, 3} - 1 
{0, 2, 3} - 1

我预计:

{1, 2, 3} - 2
{0, 2, 3} - 1

我能做什么？

如何使用java8流过滤列表并返回找到的元素(如果它是过滤列表中的唯一元素),否则(如果有更多满足条件,或者没有满足条件的结果)返回例如 Optional.empty()

我需要这样的东西:

假设我有一个:

List<String> list = Arrays.asList("Apple","Banana","Peach");

然后我想:

Optional<String> string = list.stream()
    .filter(item -> item.startsWith("A"))
    .findOne();

我知道我可以做到:

boolean singleElement = list.stream()
        .filter(item -> item.startsWith("A"))
        .count() == 1;

String string = null;

if(singleElement){
  string = list.stream().filter(item -> item.startsWith("A")).iterator().next();
}

但我想知道我是否可以在一个流中完成它？

有没有单流解决方案？

我在练习竞争性编程时遇到了以下问题.我手动解决了,有点设计方法,但我的答案是错误的,我无法想象如何扩展我的方法.

问题:

N个咖啡连锁店正在通过激烈的广告战争争夺市场份额.每天,一定比例的客户将被说服从一个链转换到另一个链.

给出了当前的市场份额和每日客户转换的概率.如果广告永远存在,那么市场份额的最终分配是什么？

假设:总市场份额为1.0,客户转换的概率独立于其他客户和天数.

例如:2个咖啡连锁店:A和B市场份额A:0.4市场份额B:0.6.

每天,客户从A切换到B的概率为0.2每天,客户从B切换到A的概率为0.1

input: market_share=[0.4,0.6],

switch_prob = [[.8,.2][.1,.9]]

output: [0.3333 0.6667]

直到这里的一切都是问题的一部分,我没有形成例子或假设,他们给出了问题.

My_attempt:根据我的理解,切换概率表示从A切换到B的概率.

因此,

market_share_of_A = current_market_share - lost_customers + gained_customers and 
marker_share_of_B = (1 - marker_share_of_A)

iter_1: 
    lost_customers = 0.4 * 0.8 * 0.2 = 0.064
    gained_customers = 0.6 * 0.2 * 0.1 = 0.012
    market_share_of_A = 0.4 - 0.064 + 0.012 = 0.348
    marker_share_of_B = 1 - 0.348 = 0.652

iter_2:
    lost_customers = 0.348 * 0.1 * 0.2 = …

我想使用Java的流API在对象列表上进行一些计算:

List<Item>.stream()...

本Item类包含许多属性.对于其中一些我需要取集合中所有项目的平均值,对于其他属性我需要做其他形式的计算.我一直在做单独的流/收集器调用来实现这一点,虽然我没有遇到任何性能问题(因为列表大小通常大约为100)我想学习如何更简洁,也就是循环一次.

ItemCalculation itemCalculation = ItemCalculation.builder()
    .amountOfItems(itemList.size())
    .averagePrice(itemList.stream()
            .mapToDouble(item -> item.getPrice())
            .average()
            .getAsDouble())
    .averageInvestmentValue(itemList.stream()
            .mapToDouble(item -> getTotalInvestmentValue(item.getInvestmentValue(), item.getInvestmentValuePackaging()))
            .average()
            .getAsDouble())
    .highestWarrantyLimit(itemList.stream()... etc.

我读到了创建一个自定义收集器,但让我的"计算"类只是一行(stream-> customCollector)然后有一个非常臃肿的收集器类来执行实际逻辑似乎有点奇怪.特别是因为以不同的方式收集不同的属性,我需要许多不同的中间计数和其他变量.有什么想法吗？

我有一个BigDecimals列表.

List<BigDecimal> amounts = new ArrayList<>()

如何使用Java 8流获取上述列表的摘要统计信息,而不会丢失BigDecimal最多3-4个小数位的精度？