小编Jac*_* G.的帖子

为什么Bill Pugh的Singleton设计模式线程安全？

public class Logger {
    private Logger() {
        // private constructor
    }

    // static inner class - inner classes are not loaded until they are
    // referenced.
    private static class LoggerHolder {
        private static Logger logger = new Logger();
    }

    // global access point
    public static Logger getInstance() {
        return LoggerHolder.logger;
    }

    //Other methods
}

模块jta和java.sql将包javax.transaction.xa导出到模块dom4j

如您所见,两个模块jta并java.sql导出相同的包,javax.transaction.xa.但是,包中jta包含我需要的不存在的类java.sql.我根本不需要java.sql模块,但我需要java.sql.SQLException.

是否有可能阻止java.sql出口javax.transaction.xa？

编辑:原始字符串文字已从JDK 12中删除,但我将打开此问题并在重新引入Raw String Literals时相应地编辑它.

在测试Raw String Literals(这是Java 12中的预览功能)时,我遇到了以下代码片段:

System.out.println(`
        Test 1
            Test 2
                Test 3
`);

其中输出如下:

          
        Test 1
            Test 2
                Test 3
                          

但是,我希望输出类似于以下内容:

Test 1
    Test 2
        Test 3

删除前导缩进以匹配预期格式的最简单方法是什么？

我有一个方法,在流上执行处理.部分处理需要在一个锁的控制下完成 - 一个锁定部分用于处理所有元素 - 但其中一部分没有(并且不应该因为它可能非常耗时).所以我不能只说:

Stream<V> preprocessed = Stream.of(objects).map(this::preProcess);
Stream<V> toPostProcess;
synchronized (lockObj) {
    toPostProcess = preprocessed.map(this::doLockedProcessing);
}
toPostProcess.map(this::postProcess).forEach(System.out::println);

因为调用doLockedProcessing只会在forEach调用终端操作时执行,并且在锁定之外.

所以我认为我需要在每个阶段使用终端操作制作流的副本,以便在正确的时间完成正确的位.就像是:

Stream<V> preprocessed = Stream.of(objects).map(this::preProcess).copy();
Stream<V> toPostProcess;
synchronized (lockObj) {
    toPostProcess = preprocessed.map(this::doLockedProcessing).copy();
}
toPostProcess.map(this::postProcess).forEach(System.out::println);

当然,该copy()方法不存在,但如果确实如此,它将对流执行终端操作并返回包含所有相同元素的新流.

我知道实现这一目标的几种方法:

(1)通过数组(如果元素类型是泛型类型,则不是那么容易):

copy = Stream.of(stream.toArray(String[]::new));

(2)通过列表:

copy = stream.collect(Collectors.toList()).stream();

(3)通过流构建器:

Stream.Builder<V> builder = Stream.builder();
stream.forEach(builder);
copy = builder.build();

我想知道的是:这些方法中哪一种在时间和记忆方面最有效？或者还有另一种方式更好吗？

我正在使用 surifire、failsafe、mockito 和 powermock。在我尝试过的地方，我发现 power mock 不支持 Java 11。

我也尝试过最新版本的surefire，但它抛出异常。（如果我跳过测试用例，构建成功）

已用时间：0 秒 <<< 错误！org.objenesis.ObjenesisException: java.lang.reflect.InvocationTargetException

引起：java.lang.reflect.InvocationTargetException 引起：java.lang.IllegalAccessError：org.powermock.core.classloader.MockClassLoader @77cf3f8b 加载的类 jdk.internal.reflect.ConstructorAccessorImpl 无法访问 jdk/internal/reflect 超类 jdk。 internal.reflect.MagicAccessorImpl

哪个版本可以解决这个问题？为了支持Java 11 maven-compiler-plugin 3.6.0。

我正在使用 JShell 来测试一个库，我通过类路径为其提供了类、源和 javadoc，如下所示：

jshell --class-path library-javadoc.jar:library-sources.jar:library-jar-with-dependencies.jar

尽管如此，当我收到记录的 Java 标识符之后的双选项卡时：

<no documentation found>

JShell 对文档有何期待？

List<Rate> rateList = 
       guestList.stream()
                .map(guest -> buildRate(ageRate, guestRate, guest))
                .collect(Collectors.toList());  

class Rate {
    protected int index;
    protected AgeRate ageRate;
    protected GuestRate guestRate;
    protected int age;
}

在上面的代码中，可以通过guestList内部buildRate方法的索引。我在构建时还需要传递索引，Rate但无法通过来获取索引Stream。

感谢您的帮助和分享.

我的问题是关于随机搜索.该技术用于通过一般数学计算中的规定量的cicle进行数据的近似.请参阅以下代码,我尝试将其降至最低.我的期望是将此代码设置为lambda表达式,for循环,我希望它具有最佳性能.我有一些想法,但我不确定我是否充分利用它.

package stochasticsearch;
import java.util.Random;
public class StochasticSearch {
    public static double f(double x) {
        return -(x - 1) * (x - 1) + 2;
    }
    public static void main(String[] args) {
        final Random random = new Random();
        double startPointX = 0;
        double max = f(startPointX);
        long begin = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            double index = 2 * random.nextDouble();
            if (f(index) > max) {
                max = f(index);
            }
        }
        System.out.println("Elapsed time: " …

public static void shuffle(List<?> list) {\n    Random rnd = r;\n    if (rnd == null)\n        r = rnd = new Random(); // harmless race.\n    shuffle(list, rnd);\n}\n\nprivate static Random r;\n

我注意到Collections#shuffle使用new Random()而不是ThreadLocalRandom.current()，我很好奇为什么。我编写了一个基准测试来比较两者，并且使用的方法ThreadLocalRandom.current()每次迭代都更快。这是基准：

@State(Scope.Benchmark)\n@BenchmarkMode(Mode.AverageTime)\n@OutputTimeUnit(TimeUnit.NANOSECONDS)\n@Warmup(iterations = 15, time = 500, timeUnit = TimeUnit.MILLISECONDS)\n@Measurement(iterations = 20, time = 500, timeUnit = TimeUnit.MILLISECONDS)\n@Fork(5)\npublic class MyBenchmark {\n    @Param({"10", "1000", "100000"})\n    private int i;\n\n    private List<Integer> list;\n\n    private static final Random RANDOM = new Random();\n\n    @Setup\n    public void …

我有一个对象列表。我想做一个 groupBy 以便有：

• 一组数字类型，例如整数、长整数、字符串或布尔值
• 一组地图

和一个不是上述任何一个的组。

我可以：

for (Object obj: myList) {
    if (obj instanceof Long) || (obj instanceof String)  {
        // add to sublist1
    } else if (obj instanceof Map) {
        // sublist2
    } else {
        // sublist3
    }
}

我如何使用 Java 8？