小编Nam*_*man的帖子

Java的ServiceLoader类现在已经被正式编入Java语言.META-INF/services现在可以使用.而不是在寻找提供商

provides <spiClass> with <providerClass>

我无法理解的是,uses在服务加载模块声明中的使用:

uses <spiClass>

引用模块系统的状态

模块系统可以通过扫描模块工件中的类文件来识别ServiceLoader::load 方法的调用来识别服务的使用 ,但这既缓慢又不可靠.模块使用特定服务是该模块定义的一个基本方面,因此为了效率和清晰度,我们在模块的声明中用uses子句表示:

module java.sql {
   requires transitive java.logging;
   requires transitive java.xml;
   exports java.sql;
   exports javax.sql;
   exports javax.transaction.xa;
   uses java.sql.Driver;
}

为什么模块系统了解特定服务的使用是否至关重要,尤其是如何引入效率？是不是懒洋洋地加载服务？为什么服务加载器不能直接寻找提供商？

直到java9在运行时通过编程方式将所有人使用的外部jar添加到类路径:

URLClassLoader sysloader = (URLClassLoader) ClassLoader.getSystemClassLoader();
Method method = URLClassLoader.class.getDeclaredMethod("addURL", new Class[]{URL.class});
method.invoke(sysloader, new Object[]{file.toURI().toURL()});

现在用java9我们有问题:

线程"main"中的异常java.lang.ClassCastException:java.base/jdk.internal.loader.ClassLoaders $ AppClassLoader无法强制转换为java.base/java.net.URLClassLoader

URLClassLoader 在Java 9中不再有效.在jdk9下如何以编程方式在运行时向类路径添加外部jar？

我有Java 11 JDK和IntelliJ IDEA 2018.2.4(64位).当我使用Java 10.0.2时,IntelliJ IDEA中的JShell控制台工作正常.现在我已升级到Java 11,JShell控制台已停止工作.单击"运行"按钮或按Ctrl + Enter(参见屏幕截图)时,什么都没发生.

我的项目使用Java 11编译和运行很好 - 它只是JShell控制台不起作用.(此外,JShell在命令提示符下运行正常,它只在IDEA内部无效.)我可以在两台机器上重现这个问题,一台在家运行IDEA Community Edition 2018.2.4,另一台在运行Ultimate 2018.2的工作0.3.

我需要做一些配置来解决这个问题吗？

在bitbucket中,我可以将评论者添加到拉取请求中,表示我希望他们查看请求.我怎样才能在GitHub上做同样的事情？

我唯一看到的是" Assignee",这只适用于一个人.我是否必须在拉取请求消息和/或公关评论中对它们进行ping操作？

这个问题不是关于它们之间的区别 - 我知道什么是虚假故障以及为什么它会发生在LL/SC上.我的问题是,如果我使用的是intel x86并使用java-9(build 149),为什么它们的汇编代码有区别？

public class WeakVsNonWeak {

    static jdk.internal.misc.Unsafe UNSAFE = jdk.internal.misc.Unsafe.getUnsafe();

    public static void main(String[] args) throws NoSuchFieldException, SecurityException {

        Holder h = new Holder();
        h.setValue(33);
        Class<?> holderClass = Holder.class;
        long valueOffset = UNSAFE.objectFieldOffset(holderClass.getDeclaredField("value"));

        int result = 0;
        for (int i = 0; i < 30_000; ++i) {
            result = strong(h, valueOffset);
        }
        System.out.println(result);

    }

    private static int strong(Holder h, long offset) {
        int sum = 0;
        for (int i = 33; i < 11_000; ++i) { …

我只需要针对特定​​条件执行转换.我做这个转变:

// filter 1: less date - group by max date by groupId
        List<Info> listResult = new ArrayList<>(listInfo.stream()
                .filter(info -> info.getDate().getTime() < date.getTime())
                .collect(Collectors.groupingBy(Info::getGroupId, Collectors.collectingAndThen(
                        Collectors.reducing((Info i1, Info i2) -> i1.getDate().getTime() > i2.getDate().getTime() ? i1 : i2),
                        Optional::get))).values());

但是对于超过指定日期的情况,我不需要转换任何东西,我只需要返回这些数据:

// filter 2: more date - nothing change in list
        List<Info> listMoreByDate = listInfo.stream()
                .filter(info -> info.getDate().getTime() >= date.getTime())
                .collect(Collectors.toList());

接下来,要结合这两个过滤器 - 我将两个列表组合在一起:

listResult.addAll(listMoreByDate);

我的问题是,这可以在一个流中完成吗？因为过滤器2绝对没用,它只返回这个条件的列表.

是否可以通过一个连续表达式执行这些转换？

我的完整代码:

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

public class App {
    public static …

试用JDK/12 EarlyAccess Build 20,其中JEP-325 Switch Expressions已作为预览功能集成.表达式的示例代码(如在JEP中一样):

Scanner scanner = new Scanner(System.in);
Day day = Day.valueOf(scanner.next().toUpperCase());
int i = switch (day) {
    case MONDAY,TUESDAY, WEDNESDAY:
        break 0;
    default:
        System.out.println("Second half of the week");
        // ERROR! Group doesn't contain a break with value
};

我试图按照上一个问题中所述的相同步骤,如何使用Maven编译JDK12预览功能并使用命令行执行上面的代码块:

java --enable-preview -jar target/jdk12-updates-1.0.0-SNAPSHOT.jar

有点像我的期望我得到以下错误:

Error: Unable to initialize main class
com.stackoverflow.nullpointer.expression.SwitchExpressionMustComplete
Caused by: java.lang.VerifyError: Bad local variable type Exception
Details:   Location:
    com/stackoverflow/nullpointer/expression/SwitchExpressionMustComplete.main([Ljava/lang/String;)V @66: iload   
Reason:
    Type top (current frame, locals[4]) …

Run Code Online (Sandbox Code Playgroud)

这是我正在使用的代码的最小示例:

public class Temp {
    enum SomeEnum {}

    private static final Map<SomeEnum, String> TEST = new EnumMap<>(
               Arrays.stream(SomeEnum.values())
                     .collect(Collectors.toMap(t -> t, a -> "")));

}

编译器输出是:

Temp.java:27: error: cannot infer type arguments for EnumMap<>
    private static final Map<SomeEnum, String> TEST = new EnumMap<>(Arrays.stream(SomeEnum.values())
                                                      ^

我发现,这可以通过更换被合作周围t -> t有Function.identity()或(SomeEnum t) -> t,但我不理解为什么是这样的情况.javac有什么限制导致这种行为？

我最初在java 8中发现了这个问题,但已经证实它仍然发生在java 11编译器中.

我正在使用使用 Java 11 构建的微服务，该服务具有在 Java 8 中构建的依赖项。依赖项中有 rest-clients，并且有一种方法可以执行此操作：

    public <T> ResponseEntity<my.company.Wrapper<T>> getForList(String url, HttpHeaders headers) {
        try {
            return template.exchange(url, GET, new HttpEntity<>(headers), new ParameterizedTypeReference<Wrapper<T>>() { });
        } catch (RestClientException restEx) {
            logger.error("RestClientException!, restEx: {}", restEx);
            throw restEx;
        }
    }

休息调用刚刚成功， response -> <200,Wrapper [ elements = [{id=dbfc2557-1738-45e4-8ecd-235d35158957, .....

然后，在微服务（使用 Java 11）中，当它使用 java Stream 时有一点：

        var found = enttsResponse.stream()
                .map(MyCompanyResponse::getId)
                .collect( toList() );

异常消息是：

java.lang.ClassCastException: class java.util.LinkedHashMap cannot be cast to class com.mycompany.commons.v2.entitlement.MyCompanyResponse (java.util.LinkedHashMap is in module java.base of loader …

有没有办法用 Java 记录做空对象？对于课程，我会这样做：

public class Id {

  public static final Id NULL_ID = new Id();

  private String id;

  public Id(String id) {
    this.id = Objects.requireNonNull(id);
  }

  private Id() {}
}

但这不起作用，因为每个构造函数都需要经过规范的 ( Id(String id)构造函数，而我不能只是调用super()来绕过不变量。

public record Id(String id) {
  public static final Id NULL_ID = null; // how?

  public Id {
    Objects.requireNonNull(id);
    // ...
  }
}

现在我解决了这个问题

public Id {
  if (NULL_OBJECT != null)
    Objects.requireNonNull(id);
}

但这感觉不对，并且容易出现并发问题。

我还没有发现很多关于记录背后的设计思想的讨论，这可能已经讨论过了。如果像这样保持简单，那是可以理解的，但感觉很尴尬，我已经在小样本中多次遇到这个问题。