小编Hol*_*ger的帖子

我写了这段代码:

import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) throws Exception {
        new Main();
    }

    private Main() throws Exception {
        Supplier<Thread> supplier = (Supplier<Thread> & Serializable) () -> new Thread() {};
        new ObjectOutputStream(System.out).writeObject(supplier);
    }
}

如果我运行它,我会得到一个例外:

Exception in thread "main" java.io.NotSerializableException: Main
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
at java.io.ObjectOutputStream.writeArray(ObjectOutputStream.java:1378)
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1174)
at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548)
at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)
at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
at Main.<init>(Main.java:28)

但是,我的理解是我正确地制作了lambda Serializable并且我声明它不会引用任何周围的上下文,因此它是一个非捕获的 lambda.然而,Main实例被捕获并且lambda表达式的结果无法序列​​化.我意识到我在lambda中声明了一个匿名类,但我希望lambda实例本身是它的封闭实例,而不是周围的Main类型.

这种行为是Java语言规范所期望的,如果是的话,为什么会这样？

我是android开发的新手。而且我已经在计算机上安装了eclipse，java 11和android sdk工具。但是，当我尝试构建项目时，它说要升级工具。但是我已经安装了最新的SDK。

当我在网上正在读我发现，Android不完全支持Java SE和它主要针对Java SE 6和7支持- 但是这是一个老帖子。

我发现android不完全支持java 11。

我的问题是，什么是完全支持android的JDK版本，我是否必须在计算机中安装2个JDK版本？

通过在Java中编写应用程序,有许多用例java.util.Collection.自从java.util.stream.StreamJava 8引入以来,我遇到了一些难以决定使用的用例.

例如:您将编写一些util-methods.

public static List<?> filterHashToList(int hash, Collection<?> toFilter) {
    return toFilter.stream()
        .filter((Object o) -> hash == o.hashCode())
        .collect(Collectors.toCollection(LinkedList::new));
}

怎么样这样写:

public static List<?> filterHashToList(int hash, Collection<?> toFilter) {
    List<Object> result = new LinkedList<>();

    for(Object o : toFilter) {
        if(hash == o.hashCode()) {
            result.add(o);
        }
    }

    return result;
}

两种方法都会产生相同的结果.java.util.stream.Stream并且java.util.stream.Collector是接口,因此如果我使用自定义流和收集器,实现也会有所不同.

我认为有很多实现使用旧的fashoined循环方式.

那么,是否有可能通过用例回答使用,流或循环的内容？如果是这样,是否必须在适当的时候更新所有实施？

或者我应该通过实现util-methods提供两种方式？或者我是否应该在过滤过程之后提供一个返回流的mthed,以便在需要时也可以使用该流？

我在操作一些字节码时遇到了一个问题,其中final Stringjava编译器(Java 8)没有内联某个常量,请参阅下面的示例:

public class MyTest
{
  private static final String ENABLED  = "Y";
  private static final String DISABLED = "N";

  private static boolean isEnabled(String key) {
      return key.equals("A");
  }

  private static String getString(String key, String value) {
      return key + value;
  }

  public static void main(String[] args) throws Exception {
    String flag = getString("F", isEnabled("A") ? ENABLED : DISABLED);
    System.out.println(flag);

    String flag2 = getString("F", isEnabled("A") ? ENABLED : DISABLED);
    System.out.println(flag2);
  }
}

使用javac生成的字节码(1.8.0_101)

public static void main(java.lang.String[]) …

问题:是否有计划用于任何未来Java版本的Elvis运算符的实现？或者是否有任何库将其带入Java？

我读过这个

它是为Java SE 7提出的,但没有进入该版本

http://www.oracle.com/technetwork/articles/java/java8-optional-2175753.html

我知道Java 8允许这样做

String name = computer.flatMap(Computer::getSoundcard)
                          .flatMap(Soundcard::getUSB)
                          .map(USB::getVersion)
                          .orElse("UNKNOWN");

但是我的口味太过分了.因此,如果有人能指出我将任何项目/库,将Groovy喜欢/ C#类似的语法带到Java的Null Checks,将不胜感激.

编辑:通过Elvis运算符我的意思是:

String version = computer?.getSoundcard()?.getUSB()?.getVersion();

或类似的

我正在开发一个从服务器(localhost - mssql和nodejs)接收数据的Android应用程序,保存数据然后显示它

收到服务器响应后,我收到此错误

我按照下面的说明在这里输入链接描述而不是我使用localhost的Web服务器.谢谢

 Illegal character in scheme at index 0: 192.168.2.7:3000
    java.net.URISyntaxException: Illegal character in scheme at index 0: 192.168.2.7:3000
            at java.net.URI.validateScheme(URI.java:419)
            at java.net.URI.parseURI(URI.java:363)
            at java.net.URI.<init>(URI.java:204)
            at cz.uhk.fim.jedlima3.searchrooms.asyncTask.DownloadDatabaseAsync.doInBackground(DownloadDatabaseAsync.java:30)
            at cz.uhk.fim.jedlima3.searchrooms.asyncTask.DownloadDatabaseAsync.doInBackground(DownloadDatabaseAsync.java:15)
            at android.os.AsyncTask$2.call(AsyncTask.java:287)
            at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:305)
            at java.util.concurrent.FutureTask.run(FutureTask.java:137)
            at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:230)
            at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1076)
            at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:569)
            at java.lang.Thread.run(Thread.java:864)

我阅读了有关Lambda表达式的Java 8教程,并且不太了解"引用特定类型的任意对象的实例方法"的方法参考示例

在同一个教程中,有一个示例"引用特定对象的实例方法"看起来很喜欢.

public int compareByName(Person a, Person b) {
        return a.getName().compareTo(b.getName());
}
Arrays.sort(rosterAsArray, myComparisonProvider::compareByName);

我可以看到这个有效,因为方法compareByName与Comparator.compare具有相同的签名,lambda(a,b) - > myComparisonProvider.compareByName(a,b)接受两个参数并调用具有相同两个参数的方法.

现在,"引用特定类型的任意对象的实例方法"示例使用String :: compareToIgnoreCase

String[] stringArray = { "Barbara", "James", "Mary", "John",
    "Patricia", "Robert", "Michael", "Linda" };
Arrays.sort(stringArray, String::compareToIgnoreCase);

该方法的签名int compareTo(String anotherString)与Comparator.compare不同.教程不是很清楚,但似乎暗示你最终得到一个lambda,如(a,b) - > a.compareToIgnoreCase(b)我不明白编译器如何决定Arrays.sort的第二个参数可以接受什么想也许它足够聪明,可以理解如何调用该方法,所以我创建了一个例子.

public class LambdaTest {

    public static void main(String... args) {
        String[] stringArray = { "Barbara", "James", "Mary", "John", "Patricia", "Robert", "Michael", "Linda" };

        Arrays.sort(stringArray, String::compareToIgnoreCase);      // This works

        // using Static methods
        Arrays.sort(stringArray, FakeString::compare);              // …

我不明白为什么Map.compute(),并Map.computeIfPresent()采取BiFunction参数以及Map.computeIfAbsent()一个Function:

V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)

我期待一个普通的Function<? super V, ? extends V>,将旧值映射到一个新值,resp.a Supplier<? extends V>为新值.调用者已经拥有密钥(第一个参数),因此函数或供应商已经可以使用它.我找到的所有例子都不使用密钥.我想到的原因:

• 关键必须(有效)final- 这很容易管理
• 有一些花哨的易用方法参考

但我不相信这些是这种设计的可行原因.你有什么想法？

如果我执行以下代码"连接"两个流

• 首先通过flatMapping a Stream<Stream<Integer>>
• 然后通过减少Stream<Stream<Integer>>使用Stream.concat()

在两种情况下我都获得了相同的正确结果,但过滤操作的数量是不同的.

public class FlatMapVsReduce {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

        Predicate<Integer> predicate1 = i -> {
            System.out.println("testing first condition with " + i);
            return i == 3;
        };

        Predicate<Integer> predicate2 = i -> {
            System.out.println("testing second condition with " + i);
            return i == 7;
        };

        System.out.println("Testing with flatMap");
        Integer result1 =
            Stream.of(list.stream().filter(predicate1),
                      list.stream().filter(predicate2))
                  .flatMap(Function.identity())
                  .peek(i -> System.out.println("peeking " …

自从他引入Java 8以来,我真的迷上了lambdas,并且尽可能地开始使用它们,主要是为了开始习惯它们.最常见的用法之一是当我们想要迭代并对一组对象进行操作时,在这种情况下我要么求助于forEach或者stream().我很少写旧for(T t : Ts)循环,我差点忘了for(int i = 0.....).

然而,我们前几天与我的主管讨论过这个问题,他告诉我,lambdas并不总是最好的选择,有时会阻碍性能.从我在这个新功能上看过的一个讲座中我感觉lambda迭代总是被编译器完全优化,并且(总是？)比裸迭代更好,但他不同意.这是真的？如果是,我如何区分每种方案中的最佳解决方案？

PS:我不是在谈论建议申请的案例parallelStream.显然那些会更快.