小编Mar*_*234的帖子

java.lang.Class 定义了仅适用于某种类型的类的多种方法,例如:

• getComponentType:仅与数组相关
• getEnumConstants:仅与枚举相关

那么为什么还有,例如,没有ArrayClass哪个定义getComponentType方法呢？

目前,我正在阅读"JUnit in action"一书.在本书中,我发现了以下文字:

在调用每个@Test方法之前,JUnit会创建测试类的新实例.这有助于提供测试方法之间的独立性,并避免测试代码中的无意的副作用.因为每个测试方法都在一个新的测试类实例上运行,所以我们不能在测试方法中重用实例变量值.

现在我认为这种方法没有多大意义:

例如:

public class CalculatorTest {
    @Test
    public void testAdd_1() {
        Calculator calculator = new Calculator();
        double result = calculator.add(1, 1);
        assertEquals(2, result, 0);
    }

    @Test
    public void testAdd_2() {
        Calculator calculator = new Calculator();
        double result = calculator.add(2, 2);
        assertEquals(4, result, 0);
    }
}

对于测试类CalculatorTest,没有任何好处.

好吧,让我们去关注另一个例子:

public class OneTest {

    static byte count;

    public OneTest() {
        count++;
    }

    @Test
    public void test1() {
        System.out.println(count);
    }

    @Test
    public void test2() {
        System.out.println(count);
    }
}

对于测试类OneTest,我找到了一种方法来为许多测试方法使用相同的变量计数...

那么,如何看待书中描述的方法的真正好处呢？

Java 11java.net.http.HttpClient似乎不检查 HTTP 状态代码，重定向除外（如果启用）。wiki和 Java API 文档中找到的所有示例始终假设 HTTP 请求是成功的，即它们似乎从不检查响应的状态代码。

这很可能永远不是所需的行为，因为来自 HTTP 500（服务器错误）响应的错误页面可能具有不同的格式或没有格式，因此应用程序无法处理。

应该在哪里检查 HTTP 状态代码？

的文档HttpResponse.BodyHandler包含以下示例片段：

BodyHandler<Path> bodyHandler = (rspInfo) -> rspInfo.statusCode() == 200
    ? BodySubscribers.ofFile(Paths.get("/tmp/f"))
    : BodySubscribers.replacing(Paths.get("/NULL"));

但是，您必须检查两次状态代码，一次在BodyHandler上面显示的情况下，一次在处理响应时（因为尝试从中读取正文"/NULL"会失败）。

对我来说，仅执行 HTTP 状态代码检查似乎是最合理的BodyHandler，例如：

BodyHandler<Path> bodyHandler = (rspInfo) -> {
    if (rspInfo.statusCode() == 200) {
        return BodySubscribers.ofFile(Paths.get("/tmp/f"));
    } else {
        throw new RuntimeException("Request failed");
    }
};

但是，BodyHandler文档没有提及是否允许抛出异常，或者HttpClient在这种情况下会如何表现。

让我感到惊讶的是，JDK 似乎没有提供开箱即用的处理不成功 HTTP 响应的功能，还是我忽略了某些东西？

FileSystemAlreadyExistsException调用FileSystems.newFileSystem时应该如何处理？

一种方法是使用已经创建的 FileSystem ( getFileSystem?)，但是当原始创建者在您仍在使用它时关闭它时，您可能会遇到问题。

如果这个问题没有通用的答案，那么ZipFileSystems 呢？假设我想为 zip 文件创建一个，但我不知道也无法控制此特定 zip 文件是否已存在 FileSystem。

有没有可靠的方法来处理FileSystemAlreadyExistsException？

我的Eclipse工作正常，但是现在，定期出现一个消息框，说

代码推荐者无法下载其模型存储库索引

这是什么意思？

有多个代码示例假定以下指令(1)和(2)不能重新排序：

int value;
volatile boolean ready;

// ...

value = 1;     // (1)
ready = true;  // (2)

• “Java 中的 Volatile 是什么意思”
• “详细信息 zu volatile-Variablen”（德语）
• 堆栈溢出答案

后一个 Stack Overflow 答案是指 JLS §17.4.5：

如果 x 和 y 是同一线程的动作，并且 x 在程序顺序中排在 y 之前，则 hb(x, y)。

但是我不明白为什么这应该适用于这里，因为 JLS示例 17.4-1还指出：

[...] 允许编译器重新排序任一线程中的指令，前提是这不会影响该线程的单独执行。

这显然是这里的情况。

JLS 中特定于的所有其他定义volatile仅针对相同的 volatile 变量，而不针对其他操作：

对 volatile 字段（第 8.3.1.4 节）的写入发生在该字段的每次后续读取之前。

在人们看到 volatile （读或写）的使用可能不会重新排序的保证时，我感到困惑。

您能否将您的解释基于 JLS 或基于 JLS 的其他来源。

我有一个问题，有没有办法“强制”repr()在字符串周围创建始终单引号？

当我只使用时会发生这种情况 repr()

print repr("test")
'test'
print repr("test'")
"test'"
print repr("test\"")
'test"'
print repr("test'\"")
'test\'"'

所以最后一个实际上是我想要的，但我不想总是添加\\"以获得单引号。

编辑：我不会将答案标记为已接受，因为正如@martijn-pieters 所指出的那样，我将其repr()用于不适合的目的。

你能在Java中为泛型指定superand吗？extends

例如，假设您有这样的类结构：

但只想选择以下类：extends A和super ABB。那可能吗？

看起来Java内存模型没有定义本地缓存的“刷新”和“刷新”，相反，人们只是为了简单起见才这样称呼它，但实际上“ happens-before”关系意味着以某种方式刷新和刷新（如果您可以对此进行解释，但不能直接成为问题的一部分）。

令我感到困惑的是，JLS中有关Java内存模型的部分并未以易于理解的方式编写。

因此，能否请您告诉我我在以下代码中所做的假设是否正确以及是否可以保证正常运行？

它部分基于Wikipedia文章中有关双重检查锁定的代码，但是作者在其中使用了包装器类（FinalWrapper），但这对我来说并不完全清楚。也许支持null价值观？

public class Memoized<T> {
    private T value;
    private volatile boolean _volatile;
    private final Supplier<T> supplier;

    public Memoized(Supplier<T> supplier) {
        this.supplier = supplier;
    }

    public T get() {
        /* Apparently have to use local variable here, otherwise return might use older value
         * see https://jeremymanson.blogspot.com/2008/12/benign-data-races-in-java.html
         */
        T tempValue = value;

        if (tempValue == null) {
            // Refresh
            if (_volatile);
            tempValue = value;

            if (tempValue == null) …

在Java中，建议char[]用于存储密码或其他敏感信息，以便在不再需要数据时能够手动清除它。

如何在所有线程中清除这样的数组？如果我理解正确，线程可能只会在其缓存中执行更改，而不会在共享内存中执行更改，因此以下操作将无法可靠地运行：

char[] password = ...
...
Arrays.fill(password, '\0');

• 这个假设是正确的还是线程总是写到共享内存？
• 是否有必要使用volatile（或其他同步方式）确保共享内存已更新？
  • 是否需要事前发生关系，因为编译器/ JVM会由于优化而忽略内存同步？
• 其他线程是否必须先建立先发生后关系才能从其缓存中清除阵列内容，还是可以忽略不计？可能是因为缓存将用于其他更频繁访问的数据，并且由于不再使用该数组，因此该数组将被丢弃。

编辑：char[]应该用于密码的语句是基于为什么为什么char []优于String？但是，再次查看之后，这也引起了一些争议。

如何将Runnable其转换为Supplier？

public <T> T useSupplier(Supplier<T> supplier) {
    // Does something with supplier and returns supplied value
    ...
    return value;
}

public void useRunnable(Runnable runnable) {
    // Somehow convert runnable to Supplier
    ...
    useSupplier(supplier);
}

在这里我想重用的方法useSupplier进行useRunnable,例如,因为我不想重复的代码.useSupplier对于这个问题,行为无关紧要,假设它包装抛出异常,或者在同步块中使用供应商.

编辑:为了澄清,该方法useSupplier不与提供的值交互,它只返回它.功能useSupplier是在某些上下文中从供应商检索值,在我的情况下它捕获(特定)RuntimeExceptions,创建一个新的异常,并将其作为原因并抛出它:

public <T> T useSupplier(Supplier<T> supplier) {
    try {
        return supplier.get();
    }
    catch (RuntimeException runtimeException) {
        throw new MyException("Supplier threw exception", runtimeException);
    }
}

下面的解决方案并没有(在Java中8)工作:

useSupplier(runnable);
useSupplier(runnable::run); …