标签: java-8

我有一张像波纹管的地图,

 [key = "car", value = ["bmw", "toyota"]]
 [key = "bike", value = ["honda", "kawasaki"]]

我想使用java 8功能apis将其转换为另一个地图,如bellow,

 [key = "bmw", value = "car"]
 [key = "toyota", value = "car"]
 [key = "honda", value = "bike"]
 [key = "kawasaki", value = "bike"]

我已经知道我们可以用数字方式对字符串数组进行排序,将它们转换为整数数组,然后使用Arrays.sort()或使用任何比较器.

所以我的问题是如果这些字符串超出了整数或长整数的限制,那么我们如何对它们进行排序.例如,考虑以下字符串数组:

14829435897932384626433832795
4159265358979323846264338327
1937286535897932384626433832795296523
23746289

在那些情况下,传统的比较器或任何排序方法将无法工作,因为它们反过来使用整数(或任何其他数据类型).

我在Haskell中有这个函数,我想知道如何将它转换为Java,特别是使用流:

build = [(w,m,n,g) | w <- [240..1280], m <- [2,4..20], n <- [2..100], g <- [240..1280], ((w - 2*m - n*g) `mod` (n+1) == 0), n*g+2*m <= w, n*g <= w]

我想把a的内容读InputStream成String:

private String readToString(InputStream stream) {
    return new BufferedReader(new InputStreamReader(stream))
            .lines().collect(Collectors.joining("\n"));
}

流来自java.lang.Process.

问题:我是否必须明确关闭任何一个InputStream,InputStreamReader或者BufferedReader在这种情况下？

旁注:链接的问题不是重复的,因为我的问题是如何正确关闭流,而不是如何将流读取到字符串!

在这种情况下,为什么Arrays.setAll比Arrays.parallelSetAll更快？

int[] array = new int[30000000];
Random rnd = new Random();
Arrays.parallelSetAll(array, i->rnd.nextInt(200));

我不喜欢forEach的部分,但我不知道如何用lambda做得更好.

list1.stream().map(element -> {
    list2.forEach(item -> {
       if (element.getKey().equals(item.getKeyNextYear())) {
          element.setSummPreviosYear(item.getSumm());
          element.setCashboxCountPreviosYear(item.getCashboxCount());
          element.setCheckCountPreviosYear(item.getCheckCount());
          element.setArticleCountPreviosYear(item.getArticleCount());
       }
    });
    return element;
}).collect(Collectors.toList());

我想简单地传递一个lambda(代码块)并在需要时执行它.如何executeLambda(...)在下面的代码中实现该方法(以及方法签名是什么):

public static void main(String[] args)
{
    String value = "Hello World";
    executeLambda(value -> print(value));
}

public static void print(String value)
{
    System.out.println(value);
}

public static void executeLambda(lambda)
{
    someCode();
    lamda.executeLambdaCode();
    someMoreCode();
}

我在许多Java 8参考资料和示例中看到了以下代码:

List <Integer> l = Arrays.asList(7, 3, 9, 8, 6, 5, -1, -100);  

l.stream().filter(y -> y <l.get(0)).collect(Collectors.toList()).
      forEach(System.out::println);

但是,我可以使用以下方法获得相同的结果:

l.stream().filter(y -> y <l.get(0)).forEach(System.out::println);

那么,使用几乎普遍使用的collect(Collectors.toList())的神圣性是什么？

总之,以下代码意味着筛选第二个参数中的实体的第一个参数.如果在第二个参数中指定了"更改",则应该过滤较窄的结果.

当我运行它时,我得到一个错误'IllegalStateException:stream已被操作或关闭.

有没有办法可以重用相同的流？
我见过人们实现像Supplier这样的东西,但我认为这不适合这种情况.或者,我只是不熟悉它以了解我如何使用供应商.

/**
     * Filters through DocumentAuditEntityListing to find existence of the entities
     * ActionEnum, ActionContextEnum, LevelEnum, & StatusEnum.
     *
     * @param audits A list of audits to search
     * @param toFind The audit entities to find
     * @return If entities found, return DocumentAudit, else null
     */
    public DocumentAudit verifyAudit(DocumentAuditEntityListing audits, DocumentAudit toFind) {
        //Filter for proper entities
        Stream stream = audits.getEntities().stream().filter(doc -> (
                doc.getAction().equals(toFind.getAction())) &&
                doc.getActionContext().equals(toFind.getActionContext()) &&
                doc.getLevel().equals(toFind.getLevel()) &&
                doc.getStatus().equals(toFind.getStatus()));

        //If changes were specified, filter further.
        if …

Stream Guru的问题非常简单:

我有这个:

    List<MyBean> beans = new ArrayList<>();
    beans.add(new MyBean("tutu"));
    beans.add(new MyBean("toto"));
    beans.add(new MyBean("titi"));

比较:

 StringBuilder reduced
            = beans.parallelStream()
                    .map(MyBean::getName)
                    .reduce(new StringBuilder(), (builder, name) -> {
                        if (builder.length() > 0) {
                            builder.append(", ");
                        }

                        builder.append(name);
                        return builder;
                    }, (left, right) -> left.append(right));

和

 StringBuilder reduced
            = beans.parallelStream()
                    .map(MyBean::getName)
                    .reduce(new StringBuilder(), (builder, name) -> {
                        if (builder.length() > 0) {
                            builder.append(", ");
                        }

                        builder.append(name);
                        return builder;
                    }/* WITHOUT THIRD PARAM*/);

为什么,第二个解决方案没有编译...第三个参数是针对并行流...

你能解释为什么我无法编译第二个代码部分吗？