标签: java-8

以下代码模仿高阶函数和闭包.

static Function<Integer, Integer> getDoubleFunc(int multi) {
    return (val) -> {
        return val * multi;
    };
}

但为什么它不被认为是一个？是因为这里的函数是一个接口吗？

我想整理一个简单的清单.示例Integers:

List<Integer> numbers = Arrays.asList(4, 2, 7, 1, 4);
numbers.stream().sorted((n1, n2) -> {
    System.out.println("comparing: " + n1 + " with " + n2);
    return Integer.compare(n1, n2);
});

结果:没有打印出来!没有应用排序.因此,甚至不执行排序方法.为什么？

旁注:我的目的是直接修改列表(在一个对象中),因此我试图阻止创建一个新列表.

我编写了一段代码来计算文件中的行数(我无法找到可以在IO类中实现这一点的内置方法).我的代码如下:

try {
    while(!line.equals("null")) {
        line = bufferedReader.readLine();
        a = a + 1;
        System.out.println(a + " " + line);
    }
} catch (NullPointerException N) {}

我遇到的问题是,当变量'line'计算为"null"时,计数仍然增加.我明白为什么会这样; 在整个代码块运行之后,while语句才会检查条件,在这种情况下,'a'将再次增加.我考虑过的解决方案:

1)设置'a = -1',而我在此代码块之前当前有'a = 0'2)使用if语句在达到count变量之前打破循环.这是我修改代码块的方法:

try {
    while(!line.equals("null")) {
        line = bufferedReader.readLine();
        if (line.equals("null")) {break;}
        a = a + 1;
        System.out.println(a + " " + line);
    }
} catch (NullPointerException N) {}

我上面的问题？(1)似乎太做作,而(2)似乎多余.我想看看是否有更好的方法来解决这个问题 - 感谢您的建议.

我试图读取一个看起来像这样的简单文本文件:

operationName1 Value
operationName2 Value

操作名称是字符串(只有两种可能的操作),值是整数.

我的目标是将数组作为输出,如下所示:

[[1,10],[2,5]]

在指定的数组中,我将operationName1转换为1,将operationName2转换为2,并使用相应的值.

这是我试过的:

try{
    Path path = Paths.get("./myFile.txt");
    String[][] array = Files.lines(path)
                    .map(s -> s.split("\\s+", 2))
                    .map(a -> new String[]{a[0], a[1]})
                    .toArray(String[][]::new);

    System.out.println(Arrays.toString(array));
    }catch(IOException e){  
}

我没有在这段代码中将名称更改为整数,我只是尝试获取一个字符串数组,我可以打印以查看我是否正确读取文件.

我的输出如下:

[[Ljava.lang.String;@682a0b20, [Ljava.lang.String;@3d075dc0, [Ljava.lang.String;@214c265e, [Ljava.lang.String;@448139f0, [L ...

我只得到一个流而不是字符串？

路径是正确的,我可以使用标准语法正常读取文件.但我真的很想理解从右脚开始的新语法,因为理解它似乎很有帮助.

我的问题:您是否知道如何纠正这个问题,或者更好的是,如何使用最新语法获得预期输出？(如果可能,Java 8？)

PS:我也看到了这种语法,但我不知道如何完成它以获得我的结果,我不确定这是好还是坏(但它似乎是Java 8).

Files.lines(Paths.get(ClassLoader.getSystemResource("myFile.txt")
    .toURI())).forEach(System.out::println);

我有一套钥匙.

class X {
  private static String[] keys = {"k1", "k2", ... };

我必须从请求中提取键的值.我想我可以map用来提取值并在一些请求处理方法中创建列表必需的对象,如下所示:

  public void processReq(Request req) {
    ...
    Stream.of(keys).map(k-> new Pack(k, req.getHeader(k)));

但是Stream根据每个请求创建看起来不必要的任 如果Stream在多个线程之间共享实例是安全的,我想我可以像这样修改代码:

class X {
  private static Stream<String> keys = Stream.of("k1", "k2", ...);
  ...

  public void processReq(Request req) {
    ...
    keys..map(k-> new Pack(k, req.getHeader(k)));

那么,Stream在多个线程之间共享实例是否安全？

为什么我有下一个例外？

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
at java.util.stream.AbstractPipeline.<init>(AbstractPipeline.java:203)...

com.search.offer.OffersSelector.isGood(OffersSelector.java:23)如何更改代码来修复它？

Stream<String> titleExclusions = ResourceUtility.contentToUtf8TreeSet("+.txt").
        stream().filter(item -> item.length() == 0).collect(Collectors.toSet()).stream();
//...
titleExclusions.filter(tittle::contains).collect(Collectors.toSet()).size() == 0;//line 23

我需要打印当月的过去6个月的名字.

例如,在2016年4月运行时,我需要打印:nov(2015),dec(2015),jan(2016),feb(2016),march(2016),4月(2016)

Format formatter = new SimpleDateFormat("MMMM YYYY");
Calendar c = Calendar.getInstance();

String[] thisAndLastFiveMonths = new String[6];
for (int i = 0; i < thisAndLastFiveMonths.length; i++) {
    thisAndLastFiveMonths[i] = formatter.format(c.getTime());
    c.add(Calendar.MONTH, -1);
    System.out.println(c);

我在理解流时遇到了一些麻烦.我环顾四周,似乎无法找到与我的用例匹配的示例.

我有一个现有的嵌套for循环:

List<ObjectB> objectBs = new ArrayList<ObjectB>();
for (ObjectA objA: objectAList) {
    for (ObjectB objB: objA.getObjectBList()) {
        if (objB.getNumber() != 2) {
            objectBs.add(objB);
        }
    }
}

很多示例显示如何添加objB.getNumber()到列表但不是objB.

我想找出一个简单的实现等同于Java的8 流,让我去探索的查询算法计算懒洋洋的发展(如map(),filter(),reduce(),等).注意:实现比Stream更好的解决方案不是我的目标.另一方面,我唯一的目标是了解Stream内部.

然而,我发现的每个实现都基于Iterable<T>,例如以下答案中提供的解决方案:

• 如何在Java 8中实现延迟流？
• 流不是数据的容器,而是逻辑容器
• Java8内部迭代

然而,我对这些解决方案感到不舒服,因为:

1. 他们太冗长了.
2. 它们对于新的查询方法不灵活.包含新的查询方法需要进行结构修改.
3. 尽管存在查询参数,但它们并没有利用新的Java 8功能,例如:第一类函数或默认方法.
4. 他们都没有使用上面使用的Spliterator<T>方法Stream<T>.

我知道这Spliterator<T>是为了允许分区和并行处理,但我认为它的独特迭代器方法(boolean tryAdvance(Consumer<t>))可以被利用到新的替代品而不是上面列出的那些.此外,正如Brian Goetz所述:

SpliteratorIterator即使没有并行性,也是更好的.(他们通常也更容易写,更容易出错.)

那么,是否有可能开发出一种更易读,更简单,更简洁,更灵活的查询API实现,并且基于相同的原理Stream<T>(并行处理部分除外)？

如果是的话,你怎么能这样做？我希望看到比上面列出的更简单的实现,如果可能的话,利用新的Java 8功能.

要求:

• 不要重用Java 8 API中的现有方法
• 并行处理功能超出了本问题的范围.
• 如果可能,更好,不要使用该Iterable<T>方法.

我的问题的原因？我认为学习查询API(如Stream)的最佳方法是尝试自己实现这些相同的方法.我在学习时已经成功完成了.net Linq.当然,我没有比Linq更好的实现,但这有助于我理解内部部分.所以,我试图按照相同的方法学习Stream.

这并不是那么不寻常.有以下这种方法对于其他技术,如许多作坊功能的JavaScript车间,其中大部分练习要求对现有方法这样实现:map(),filter(),reduce(),call(),bind(),等...

选择的答案:现在我认为米格尔·甘博亚的答案是我的选择,而不是Tagir Valeev的答案,因为后者不允许的implementaton findAny()或findFirst() …

我试图通过使用lambda表达式实例化一个数组.

我试图使用的代码是:

public class Main {

    static int x = 0;

    public static void main(String[] args) {

        Test[] t = (Test[]) Stream
                .generate(() -> new Test(x++, 0))
                .limit(10)
                .map((Test v) -> {
                    v.a = v.a * 2;
                    return v;
                }) 
        );

我试图实例化的类名为Test:

public class Test {

int a, b;

 Test(int a, int b) {
    this.a = a;
    this.b = b;
 }
}

我无法执行演员表,它引发了一个例外:

java.lang.ClassCastException:[Ljava.lang.Object; 不能被投射到[Lperson.Test; at person.Main.main(Main.java:37)Java返回:1

但是如果你看一下对象类:

该数组是"[Ljava.lang.Object;" 例

//class "[Ljava.lang.Object;"
        System.out.println(
                Stream.generate(() -> new Test(x++, 0))
                .limit(10)
                .map((Test …