小编Dmi*_*kiy的帖子

在我的多模块项目中,我module-info.java只创建了几个模块.在编译期间maven-compiler-plugin:3.7.0我得到下一个警告:

[警告]*检测到必需的基于文件名的自动模块.请不要将此项目发布到公共工件库!*

这是什么意思？是因为我只有几个模块,module-info.java而不是整个项目？

我上过一堂课：

class A {
   public final Integer orgId;
}

我将其替换为Java 17中的记录：

record A (Integer orgId) {
}

另外，我有一个通过反射进行验证的代码，该代码适用于常规类，但不适用于记录：

Field[] fields = obj.getClass().getFields(); //getting empty array here for the record
for (Field field : fields) {
}

在 Java 17 中通过反射获取 Record 对象字段及其值的正确方法是什么？

现在,对于我拥有的每个模块,我需要明确指定要导出的包.例如:

module core {
    exports cc.blynk.server.core;
    exports cc.blynk.server.core.protocol.handlers.decoders;
    exports cc.blynk.server.core.protocol.handlers.encoders;
}

但是,它不是很方便.我想做那样的事情:

module core {
    exports cc.blynk.server.core.*;
}

有没有办法做到这一点？这种限制来自哪里？

我一直在玩jmap,发现简单的"Hello World"Java程序创建了数千个对象.以下是Oracle JVM update 131在启动时创建的截断对象列表:

 num     #instances         #bytes  class name
----------------------------------------------
   1:           402        4903520  [I
   2:          1621         158344  [C
   3:           455          52056  java.lang.Class
   4:           194          49728  [B
   5:          1263          30312  java.lang.String
   6:           515          26088  [Ljava.lang.Object;
   7:           115           8280  java.lang.reflect.Field
   8:           258           4128  java.lang.Integer
   9:            94           3760  java.lang.ref.SoftReference
  10:           116           3712  java.util.Hashtable$Entry
  11:           126           3024  java.lang.StringBuilder
  12:             8           3008  java.lang.Thread
  13:            74           2576  [Ljava.lang.String;
  14:            61           1952  java.io.File
  15:            38           1824  sun.util.locale.LocaleObjectCache$CacheEntry
  16:            12           1760  [Ljava.util.Hashtable$Entry;
  17: …

我最近玩了一些基准测试,发现了非常有趣的结果,我现在无法解释.这是基准:

@BenchmarkMode(Mode.Throughput)
@Fork(1)
@State(Scope.Thread)
@Warmup(iterations = 10, time = 1, batchSize = 1000)
@Measurement(iterations = 10, time = 1, batchSize = 1000)
public class ArrayCopy {

    @Param({"1","5","10","100", "1000"})
    private int size;
    private int[] ar;

    @Setup
    public void setup() {
        ar = new int[size];
        for (int i = 0; i < size; i++) {
            ar[i] = i;
        }
    }

    @Benchmark
    public int[] SystemArrayCopy() {
        final int length = size;
        int[] result = new int[length];
        System.arraycopy(ar, 0, result, 0, length);
        return result; …

我摆弄唱片，发现一些对我来说看起来不合逻辑的东西：

记录：

record R(@NotEmpty Integer i) {}

代码：

RecordComponent[] recordComponents = R.class.getRecordComponents();
System.out.println(recordComponents[0].isAnnotationPresent(NotEmpty.class));
//prints false

但是，如果我这样做：

System.out.println(R.class.getDeclaredFields()[0].isAnnotationPresent(NotEmpty.class));
//prints true

这是预期的吗？因为RecordComponent implements AnnotatedElement，所以我认为RecordComponent应该有关于注释的信息。我的期望是错误的吗？

用户给我带来byte / short / int / long价值。我必须将其作为POST HTTP请求的一部分发送，并且必须将数字作为字符串发送。

所以现在我做下一个：

//simplified version
byte[] data = Integer.toString(myInt).getBytes(US_ASCII);
sendPost(data);

我正在寻找更快的替代品

Integer.toString(myInt).getBytes(US_ASCII);

由于这种流动产生char[]，String和byte[]对象。虽然我只需要byte[]。我想知道是否还有其他更快/更好的选择。

我最近在分析我的代码并发现了一个有趣的瓶颈.这是基准:

@BenchmarkMode(Mode.Throughput)
@Fork(1)
@State(Scope.Thread)
@Warmup(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
public class Contains {

    private int[] ar = new int[] {1,2,3,4,5,6,7};

    private int val = 5;

    @Benchmark
    public boolean naive() {
        return contains(ar, val);
    }

    @Benchmark
    public boolean lambdaArrayStreamContains() {
        return Arrays.stream(ar).anyMatch(i -> i == val);
    }

    @Benchmark
    public boolean lambdaIntStreamContains() {
        return IntStream.of(ar).anyMatch(i -> i == val);
    }

    private static boolean contains(int[] ar, int value) {
        for …

我一直在寻找通过Java的9个新特性的方法和发现,现在的方法Class.cast 是内在的与太一起Class.isInstance.

我做了简单的基准来检查:

@BenchmarkMode(Mode.Throughput)
@Fork(1)
@State(Scope.Thread)
@Warmup(iterations = 10, time = 1, batchSize = 1000)
@Measurement(iterations = 20, time = 1, batchSize = 1000)
public class Casting {

    public Object msg;
    public Class<String> type;

    @Setup
    public void setup(BenchmarkParams params) {
        type = String.class;
        msg = "123";
    }

    @Benchmark
    public boolean isInstanceMethod() {
        return type.isInstance(msg);
    }

    @Benchmark
    public boolean isInstanceMethodExplicit() {
        return String.class.isInstance(msg);
    }

    @Benchmark
    public boolean isInstanceRegular() {
        return msg instanceof String;
    }

    @Benchmark
    public String …