小编Axe*_*xel的帖子

我正在开发一个类库.

1. 我有一个矩阵的抽象基类Matrix,它提供了一些基本方法的实现.
2. 派生自Matrix是不同类型矩阵的具体子类.
3. 我要求矩阵可以克隆,因此Matrix实现了Cloneable接口.
4. 从Matrix派生的一些类是不可变的

对于不可变类的克隆方法而言,它是否可以接受而不是返回对象的克隆,而是返回对象本身？

一些(过于简化的)代码用于澄清:

abstract class Matrix implements Cloneable {
   ...
}

class ImmutableMatrix extends Matrix {
    ImmutableMatrix clone() {
        return this;
    }
    ...
}

class SomeOtherMatrix extends Matrix {
    SomeOtherMatrix clone() {
        SomeOtherMatrix other = super.clone();
        ...
        return other;
    }
    ...
}

Java 8引入了lambda表达式,这是一件好事.但现在考虑重写这段代码:

class B implements PropertyChangeListener {
    void listenToA(A a) {
        a.addPropertyChangeListener(this);
    }

    void propertyChange(PropertyChangeEvent evt) {
        switch(evt.getPropertyName()) {
            case "Property1":
                doSomething();
                break;
            case "Property2":
                doSomethingElse();                case "Property1":
                doSomething;
                break;

                break;
    }

    void doSomething() { }
    void doSomethingElse() { }
}

class A {
    final PropertyChangeSupport pcs = new PropertyChangeSupport(this);

    void addPropertyChangeListener(PropertyChangeListener listener) {
        pcs.addPropertyChangeListener(listener);
    }

    void removePropertyChangeListener(PropertyChangeListener listener) {
        pcs.removePropertyChangeListener(listener);
    }
}

随着lambda表达式和方法的引用,它已不再是需要有B落实PropertyChangeListner,我们可以写

class B {
    void listenToA(A a) {
        // using method …

返回类型的静态方法中的泛型似乎与继承相处得不好.请看下面的代码:

class ClassInfo<C>  {
  public ClassInfo(Class<C> clazz) {
    this(clazz,null);
  }  
  public ClassInfo(Class<C> clazz, ClassInfo<? super C> superClassInfo) {
  }
}

class A {
    public static ClassInfo<A> getClassInfo() {
        return new ClassInfo<A>(A.class);
    }
}

class B extends A {
    // Error: The return type is incompatible with A.getClassInfo()
    public static ClassInfo<B> getClassInfo() { 
        return new ClassInfo<B>(B.class, A.getClassInfo());
    }
}

我试图通过更改A.getClassInfo()的返回类型来规避这一点,现在错误弹出另一个位置:

class ClassInfo<C>  {
  public ClassInfo(Class<C> clazz) {
    this(clazz,null);
  }  
  public ClassInfo(Class<C> clazz, ClassInfo<? super C> superClassInfo) {
  }
}

class A …

所以 Java 9 就在那里，很快就会有 Java 10。是时候让我们的库准备好在 Java 9 项目中使用了。我是通过以下方式做到的：

1. 提供一个模块信息.java
2. 添加的（实验）拼图插件在build.gradle
3. 根据gradle 站点上的指南手动进行更改，而不是使用 jigsaw 插件。

到目前为止，两种方法都运行良好，我可以在 Java 9 项目中使用生成的 Jar。

问题是，生成的 Jar 与 Java 8 不兼容，尽管除了module-info.java. 当我设置时targetCompatibility = 8，一条错误消息告诉我也进行相应的设置sourceCompatibility = 8。然后拒绝module-info.java我应该设置的sourceCompatibility = 9。

如何解决这个问题？

我再次删除了拼图插件，并尝试了这个，但卡住了：

1. 设置sourceCompatibility = 8和targetCompatibility = 8
2. 创建一个moduleInfo包含单个文件的新源集module-info.java
3. 设置sourceCompatibility = 9并targetCompatibility = 9为新的源集

现在编译工作了，Gradle 在尝试编译module-info.java. 但是，缺少模块（在本例中为 log4j），并且出现此错误：

:compileJava UP-TO-DATE
:processResources …

看下面的代码,为什么不编译dump的第二次调用？如何在不删除通配符的情况下修复它？

import java.util.ArrayList;
import java.util.List;

class Column<A, T extends Object> {
}

public class Generics {

  static void main(String[] args) {
    Integer i = 5;

    // this works
    List<Column<Integer, ?>> columns1 = new ArrayList<Column<Integer, ?>>();
    dump(columns1, i);

    // this doesn't
    List<Column<Integer, String>> columns2 = new ArrayList<Column<Integer, String>>();
    dump(columns2, i);
  }

  static <A, T> void dump(Iterable<Column<A, ?>> columns, A value) {
    for (Column<A,?> col: columns) {
      System.out.println(col);
    }
  }

}

JDK的编译器给出了

Generics.java:18: <A,T>dump(java.lang.Iterable<Column<A,?>>,A) in Generics cannot be applied to (java.util.List<Column<java.lang.Integer,java.lang.String>>,java.lang.Integer)
 dump(columns2, …

我正在尝试加速用于ExecutorService并行运行任务的程序.它基本上是这样的:

1. 初始化大小固定大小的线程池 n

2. 阅读包含任务输入的一堆(大约2500个文件)XML文件

3. 使用池中的工作线程处理XML文件

一切都按预期工作,但我遇到的问题是每个工作线程都有一个类的实例,它对输入数据进行计算.这个实例存储在一个ThreadLocal.现在,所有这些线程本地实例都是在对应的工作线程启动时创建的,这意味着在读取所有XML输入文件之后.

由于计算对象的初始化需要相当长的时间,因此我宁愿让线程池从一开始就初始化所有工作线程,这样计算对象的初始化可以与读取输入文件并行运行.

这里有一些代码可以帮助您了解它当前是如何工作的(我剥离了与问题无关的代码).

初始化线程池和本地线程:

  private final ExecutorService executor = Executors.newFixedThreadPool(Math.max(1, Runtime
      .getRuntime().availableProcessors() - 1));

  private ThreadLocal<Calculator> calculator = new ThreadLocal<Calculator>() {
    @Override
    protected Calculator initialValue() {
      try {
        Calculator instance = createCalculator();
        return instance;
      } catch (Throwable e) {
        throw new RuntimeException(e);
      }
    }
  };

提交新计算:

  @Override
  public FutureTask<Output> calc(Input input) {
    FutureTask<Output> task = new FutureTask<>(
        new Callable<Rueckgabe>() {
          @Override
          public Output call() throws Exception {
            try {
              return calculator.get().calc(input); …

这是我第一次在StackOverflow上发帖,如果我的帖子格式不标准,我很抱歉,如果我的问题很愚蠢,请原谅我.

我正在对hackerrank进行挑战,目前我的问题目标如下:

您有一个空序列,您将获得N个查询.每个查询都是以下三种类型之一:

1. 将元素x推入堆栈.
2. 删除堆栈顶部的元素.
3. 打印堆栈中的最大元素.

我已经解决了,但我在讨论中看到了另一种解决方案,并考虑修改它.替代解决方案是:

public class Solution {

public static void main(String[] args) {

    Scanner inp = new Scanner(System.in);
    int n = inp.nextInt();
    Stack<Integer> S = new Stack<>();
    Stack<Integer> largest_stack = new Stack<>();
    largest_stack.push(0);

    for(int i=1; i<=n;i++) {
        int query = inp.nextInt();

        if(query==1){
            int newtop=inp.nextInt();
            S.push(newtop);

            if(S.peek()>=largest_stack.peek()){
                largest_stack.push(S.peek());     
            }
       }

        if(query==2) {
            if(S.peek()==largest_stack.peek()){
                largest_stack.pop();   
            }
            S.pop();   
        }
        if(query==3){
            System.out.println(largest_stack.peek());
        }
    }
}
}

我想在这部分用newtop替换S.peek()

            if(S.peek()>=largest_stack.peek()){
                largest_stack.push(S.peek());     
            }

所以我明白了

            if(S.peek()>=largest_stack.peek()){
                largest_stack.push(newtop);     
            }

执行此操作后,它将通过默认测试用例.但它总共失败了9/27个测试用例.以下是其中一个失败的测试用例的一小部分.有100000个查询,但我只采取了前21个.

21
1 809288903
3
1 …

当我启动应用程序时，会显示全局菜单，但无法通过鼠标或键盘访问。该应用程序本身可以运行并且响应迅速。当我切换到另一个应用程序然后再次返回时，一切都按预期进行。

如果应用程序自己提供任何菜单，这似乎并不无关紧要，因为标准“Java”应用程序菜单也会出现同样的问题，例如 FXHello（下面的代码）。

在 MACOS 10.14 Mojave 上不会出现此问题。

还有其他人经历过吗？如果是这样，有解决方法吗？

示例代码取自 JavaFX 示例：

package hellofx;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class HelloFX extends Application {

    @Override
    public void start(Stage stage) {
        String javaVersion = System.getProperty("java.version");
        String javafxVersion = System.getProperty("javafx.version");
        Label l = new Label("Hello, JavaFX " + javafxVersion + ", running on Java " + javaVersion + ".");
        Scene scene = new Scene(new StackPane(l), 640, 480);
        stage.setScene(scene);
        stage.show();
        stage.requestFocus();
    }

    public static void main(String[] args) …

我正在创建一个序列化 GWT 请求的脚本，但我在编码日期值以符合 RPC-GWT 标准时遇到了问题。通过 HTTP 日志，我注意到日期值被转换为一些 7 个字符的字符串，但我无法识别这些模式使用的算法。

有谁知道使用哪种算法来加密这些日期值？

我尝试在 Gradle 项目中使用 JUnit 5。compileJava并且compileTestJava都成功，但test失败并显示奇怪的消息Could not execute test class 'module-info'.（来自堆栈跟踪的消息）：

> Task :test FAILED

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':test'.
> There were failing tests. See the report at: file:///Users/axel/git/utility/build/reports/tests/test/index.html

测试结果文件提示我“ failed to execute tests”，但堆栈跟踪看起来很奇怪。似乎 JUnit 正在尝试运行与我的module-info.java文件对应的类：

org.gradle.api.internal.tasks.testing.TestSuiteExecutionException: Could not execute test class 'module-info'.
    at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:53)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.base/java.lang.reflect.Method.invoke(Method.java:566)
    at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)
    at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)
    at …