小编Joh*_*hnD的帖子

我目前正在阅读JSR-133(Java内存模型),我无法理解为什么fy可能未初始化(可能看到0).有人可以向我解释一下吗？

class FinalFieldExample {
    final int x;
    int y;
    static FinalFieldExample f;

    public FinalFieldExample() {
        x = 3;
        y = 4;
    }

    static void writer() {
        f = new FinalFieldExample();
    }

    static void reader() {
        if (f != null) {
            int i = f.x; // guaranteed to see 3
            int j = f.y; // could see 0
        }
    }
}

我想让我的序列化 json 看起来像这样：

{
 "abc": "smth",
 "def": "smth",
 "ghi": "smth",
}

我怎样才能通过杰克逊实现这一目标？这是我到目前为止所做的

@Override
    public void serialize(Value value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeStartObject();
        gen.useDefaultPrettyPrinter();
        gen.writeStringField("abc", value.getAaa());
        gen.writeStringField("def", value.getDdd());
        gen.writeStringField("ghi", value.getGgg());
        gen.writeEndObject();
    }

我得到以下输出

{
"abc" : "smth",
"def" : "smth",
"ghi" : "smth",
}

我听说JIT自动内联小方法,比如getter(它们大约有5个字节).边界是什么？有没有JVM标志？

我目前正在阅读JMS一些文章，在阅读了几篇文章之后，我对使用非持久消息的持久订阅有点困惑。让我们从：http : //www2.sys-con.com/itsg/virtualcd/java/archives/0604/chappell/index.html - 它说：

• 如果非持久消息是为断开连接的持久订阅者准备的，消息服务器会将消息保存到磁盘，就好像它是持久消息一样。在这种情况下，持久消息和非持久消息之间的区别很微妙，但非常重要。对于非持久消息，JMS 提供程序可能会在它有机会代表断开连接的持久订阅者将消息写出到磁盘之前失败。消息可能会丢失

另一个来源：http : //openmessaging.blogspot.com/2009/04/durable-messages-and-persistent.html说的完全不同：

• 如果此主题上有任何持久订阅，则会将消息的副本发送给那些处于活动状态的持久订阅者。对于那些非活动的持久订阅，消息的副本保存在内存中，并在它们下次变为活动状态时发送给它们。

  如果代理重新启动，此保存的消息将丢失。由于非持久消息未保存在磁盘上，因此代理重启意味着任何尚未收到消息的非活动持久订阅都将错过消息。

那么，真相是什么:)？

我想删除函数中value指定的列表中的一些元素.如果函数的'val'等于列表中的第一个元素,则我的函数不起作用.否则它运作良好.有任何想法吗？

struct elem {
    int val;
    struct elem *next;
};

void del(struct elem *list, int val) {
    struct elem* tmp = list;
    struct elem* prev = NULL;

    while (tmp != NULL) {
        if (tmp->val == val) {
            if (prev == NULL) {
                tmp = tmp->next;
                free(list);
                list = tmp;
            } else {
                prev->next = tmp->next;
                free(tmp);
                tmp = prev->next;
            }
        } else {
            prev = tmp;
            tmp = tmp->next;
        }
    }
}

我们可以使用显式或隐式结构创建字符串.

隐含的构造示例:

String str1 = "hello";
String str2 = "hello";
str1==str2 // returns true, both str1 and str2 points to the same String object in string pool

明确的构造示例

String str3 = new String("hello");
String str4 = new String("hello")
str3==str4 // returns false because str3 and str4 points to different String object

因为使用隐式构造首选(内存保存)为什么我们不应该使用==运算符？据我所知,不使用==运算符的唯一原因是我们可以忘记不使用显式结构并尝试做类似的事情

str1==str3
str3==str4 // and so forth

在下面的代码中Intellij说"循环推理"

List<String> rows = new ArrayList<>();
rows.add("12345");
rows.add("123");
rows.add("123456");
rows = rows.stream().filter(e -> e.length() > 4).collect(Collectors::toList);
rows.stream().forEach(System.out::println);

必须有一些Collectors::toList我无法理解的问题.