小编fla*_*kes的帖子

try-with功能如何适用于AutoCloseable已声明的变量null？

我假设这会在尝试调用close变量时导致空指针异常,但它运行没有问题:

try (BufferedReader br = null){
    System.out.println("Test");
}
catch (IOException e){
    e.printStackTrace();
}

我正在为运行RedHat的服务器设计一个控制台应用程序.最终用户应该能够使用他们选择的任何终端运行此应用程序.(例如; Gnome终端,Putty SSH/Telnet,MS Telnet客户端等).

在大多数终端应用程序中没有任何错误,但是当我从MS telnet会话启动我的程序时,我注意到我的特殊输入System.in并且System.console()完全搞砸了.退格会写入^H屏幕,其他键也会写入乱码.

我已经足够了,我可以让它始终如一地工作,但我确定我所做的是粗略的:

if (!System.getenv("TERM").equals("xterm"))
{
    System.out.println("\nWARNING: The TERM type is now set to xterm\n");
    final String[] cmd = { "/bin/sh", "-c", "export TERM=xterm" };
    Runtime.getRuntime().exec(cmd);
}

对于那些不支持的终端,这里会出现问题xterm吗？我注意到Microsoft Telnet客户端不允许您在开始会话之前将TERM类型设置为xterm.然而,一旦会话开始,设置TERM=xterm似乎解决了问题.

大多数控制台应用程序如何解决此问题？

随着Java 9的出现,我认为将我的一些项目移植到Java 9是一个很好的学习练习.在我的一个项目中,我有rxjava和rxjavafx的依赖项

dependencies {
    compile 'io.reactivex:rxjava:1.2.6'
    compile 'io.reactivex:rxjavafx:1.0.0'
    ...
}

我想将此项目创建为命名模块.要做到这一点,我需要创建一个module-info.java文件,我需要指定的要求rxjava,并rxjavafx在这里.但是,这些库还没有任何模块信息.

为了解决这个问题,我读过我需要创建自动模块.根据我的理解,我需要重命名rxjava和rxjavafx罐子有一个简单的名称,然后列出--module-path参数中的罐子.然后requires我module-info.java在jar中添加一个指令.

module com.foo.bar {
    requires rxjavafx;
    requires rxjava;
}

我编写了一个gradle任务来为我编辑jar名称,它似乎在大多数情况下都有效.它需要编译所有的jar并将它们重命名为不包含version-info或slashes.然后将这些文件连接成一个:单独的字符串:

tasks.withType(JavaCompile) {
    delete { delete '/tmp/gradle' }
    copy {
        from configurations.compile + configurations.testCompile
        into '/tmp/gradle'
        rename '(.*)-[0-9]+\\..*.jar', '$1.jar'
        rename { String fileName -> fileName.replace("-", "") }
    }
    options.compilerArgs += ['--module-path', fileTree(dir: '/tmp/gradle', include: …

在Java 9中,是否允许使用循环模块？如果不是,原因是什么？

module com.foo.bar {
    requires com.foo.baz;
    exports com.foo.bar.fizz;
}

module com.foo.baz {
    requires com.foo.bar;
    exports com.foo.baz.buzz;
}

我理解注释是不可变的,但是,Java中的数组本身并不是不可变的.运行测试后,我注意到从注释参数返回的数组可以变异,但它不会影响源数组:

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface ArrayAnnotation {
    String[] value() default {};
}

@ArrayAnnotation({"foo"})
public class Main {
    public static void main(String[] args) {
        ArrayAnnotation test = Main.class.getAnnotation(ArrayAnnotation.class);

        String[] test0 = test.value();
        test0[0] = "bar";
        System.out.println(test0[0]);

        String[] test1 = test.value();
        System.out.println(test1[0]);
    }
}

这打印:

bar
foo

幕后发生了什么事？在每次调用期间是否只发生了一个数组副本value(),或者它是否更复杂？

在类型提示系统中，Optional[T]据说等价于Union[T, None]

这适用于多个类型参数吗？IE，

确实Optional[T,U]爆发了Union[T,U,None]，或者我需要把它写成Optional[Union[T,U]]

我很好奇为什么带有返回类型的lambda不能被转换为a Runnable而非void方法引用可以.

Runnable r1 = () -> 1; // not allowed
// error: incompatible types: bad return type in lambda expression
// int cannot be converted to void

Runnable r2 = ((Supplier)() -> 1)::get; // allowed

我有一个foo.service依赖于 service 的服务bar.service。我需要确保bar.service之前启动foo.service并bar.service成功启动。

从这个来源它说Requires：

该指令列出了该单元本质上依赖的任何单元。如果当前单位被激活，此处列出的单位也必须成功激活，否则该单位将失败。默认情况下，这些单元与当前单元并行启动。

那After：

此指令中列出的单元将在启动当前单元之前启动。这并不意味着依赖关系，如果需要，必须通过上述指令建立依赖关系。

在同一个单元文件中同时包含Requires和After部分是否正确？Requires表示该服务将并行启动，但After表示将在之前启动。如果bar.service在这种After情况下无法启动，它会在该Requires部分尝试再次启动吗？如果是这样，我需要找到另一种启动方式foo.service

foo.service

[Unit]
After=bar.service
Requires=bar.service

免责声明:鉴于这个问题,这可能不是最佳解决方案,但我很好奇如何实现这一实施.

问题我正在尝试处理一些遗留代码,这些代码的单例定义如下:

public class LegacySingleton {
    private static Boolean value;

    public static void setup(boolean v) {
        if (value != null) {
            throw new RuntimeException("Already Set up");
        }
        value = v;
        System.out.println("Setup complete");
    }

    public static void teardown() {
        value = null;
        System.out.println("Teardown complete");
    }

    public static boolean getValue() {
        return value;
    }
}

我无法更改此设计,并且在整个代码库中大量使用该类.此单例返回的值可以极大地改变代码的功能.例如:

public class LegacyRequestHandler {
    public void handleRequest() {
        if (LegacySingleton.getValue()) {
            System.out.println("Path A");
        } else {
            System.out.println("Path B");
        }
    }
}

现在,如果我想要代码Path A,那么我必须以 …

我想创建一个类来对一些static const值进行分组。

// SomeClass.dart
class SomeClass {
  static const SOME_CONST = 'some value';
}

dart 中防止依赖代码实例化此类的惯用方法是什么？我也想阻止扩展到这个类。在Java我会做以下事情：

// SomeClass.java
public final class SomeClass {
    private SomeClass () {}
    public static final String SOME_CONST = 'some value';
}

到目前为止，我能想到的只是抛出一个Exception，但我希望编译安全而不是在运行时停止代码。

class SomeClass {
  SomeClass() {
    throw new Exception("Instantiation of consts class not permitted");
  }
  ...