小编Nam*_*man的帖子

我的 Java 代码有一些问题。我应该使用循环而不是任何其他方法。假设我的ArrayList 包含

【狗猫狗狗猫狗马】

我的目标也是删除 Dog 和 Cat 的副本，因此我的最终结果等于

[狗猫马]

public void removeDouble(){

int counter = 0;
for (int i = 0 ; i < animals.size(); i++) { 
    for (int j = 1+i;  j < animals.size() ; j++)  
        //don't start on the same word or you'll eliminate it.
        if ( animals.get(j).equals( animals.get(i) )  ) {
            animals.remove(animals.get(j));
           counter++;

        }                                
    } 
}

感觉“逻辑”是正确的，但我的代码运行得不太好。有人可以帮我一点吗？

我们在服务代码中将模型定义为-

@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
public class SomeData {

    public boolean tnAvailable;

    @NonNull
    public String sTempChange;

    public boolean isTnAvailable() {
       return faAvailable;
    }

    public void setTnAvailable(boolean faAvailable) {
        this.faAvailable = faAvailable;
    }

    @Nonnull
    public String getSTempChange() {
        return sTempChange;
    }

    public void setSTempChange(@Nonnull String sTempChange) {
        this.sTempChange = sTempChange;
    }

}

当查询包含上述模型的api作为响应时，我们得到的响应为-

"someData": {
    "tnAvailable": true,
    "stempChange": "trial_001"
}

使我们感到惊讶的是stempChange（注意小写t）而不是sTempChange响应的属性。

在API调用期间对对象进行序列化和反序列化时，怀疑原因是Jackson com.fasterxml.jackson.core：jackson-core：2.5.2，因为我们没有使用任何其他getter-setter ot包装器来更改属性。为什么会发生这种情况，并且序列化/反序列化是寻找此结果的正确方向？

编辑 -从@Windle发表的评论中，尝试解释这里的不同之处。我再次重申： “尽管那里的问题在很大程度上与相同的情况有关。但是我也期待在fastxml中实现和编写文档的原因。”

如何java.lang.Module通过Java 9中的字符串名称获取？

例如,我们有

String name = "some.module";
Module module = //how to get here it?

在Java 10中,这给了我一个警告 -

ArrayList a = new ArrayList<>();
a.add(23);
a.add("str");

"ArrayList是一个原始类型.应该参数化对泛型类型ArrayList的引用"

原因是Generic背后,但对于这个代码

var b = new ArrayList<>();//Object type
b.add(3);
b.add("string");

为什么编译器没有给出任何警告？

注意: - 我知道var仅限于方法范围.只是想知道切换到var的泛型的设计概念

编辑1: - 不要像我想知道的内部设计那样重复标记,以及为什么java没有为var添加泛型内容？

每当我尝试运行以下代码时，它都会抛出UnsupportedOperationException

但是，根据我的理解，它应该可以正常工作，因为我正在计算其值K已经存在于Map

public class MyClass {
public static void main(String[] args) {
    Collections.singletonMap("k", "v").computeIfAbsent("k", k -> "v" ); 
   }
}

有人可以帮助我理解这种行为吗？

我试图使用 Java1.8 使用 help Stream 函数将下面的 for 循环转换为 forEach 方法，但我很困惑，也很困惑这样做。

List<A> valueList = new ArrayList<>();
List<B> responseList = getResponses();
List<A> value = new ArrayList<>();

for (B getResponse: responseList) {
    valueList = getValues(getResponse);
    value.addAll(valueList);
}

我有这样一个地图，Map<String,String[]>我想总结它的值，值是字符串表，我知道它们是数字。请告诉我如何使用流来做到这一点。我试过了 ：

Map<String, String[]> map = new HashMap<>();
int sum = map.values().stream().mapToInt(Integer::parseInt).sum();

我试图在Java中导入SecureRamdom，但是

import java.security.SecureRandom;

不工作。我在Eclipse中使用Java SE 8。有人知道如何导入吗？

我想将转换List<String>为IntStream。假设我的清单是["abc", "de", "fghi"]。然后IntStream，我要像1,1,1,2,2,3,3,3,3。（一些出现的次数i在IntStream取决于长度i个串中的给定的列表）

为此，我编写了以下方法（它将不会编译）：

private static IntStream getSingleIntStream(List<String> list) {
    final AtomicInteger atomicInteger = new AtomicInteger();
    return list.stream()
            .map(str -> {
                        atomicInteger.incrementAndGet();
                        return IntStream.range(0, str.length())
                                .map(i -> atomicInteger.get());
                    }); // Now I don't understand how can I convert this Stream<IntStream> to a single IntStream 

}

但是我不明白如何将a转换Stream<IntStream>为单个IntStream。（我的猜测是我们可以flatMap以某种方式使用，但我不完全了解如何使用它。）

我使用IntStream而不是Stream<Integer>避免自动装箱，并使我的整个系统更高效。

我正在阅读有关函数式接口（https://www.baeldung.com/java-8-function-interfaces）的内容，并且关于 a Supplier<T>，它是这样说的：

\n

供应商的另一个用例是定义序列生成的逻辑。为了演示它，让\xe2\x80\x99s 使用静态 Stream.generate 方法来创建斐波那契数字流：

\n

int[] fibs = {0, 1};\nStream<Integer> fibonacci = Stream.generate(() -> {\n    int result = fibs[1];\n    int fib3 = fibs[0] + fibs[1];\n    fibs[0] = fibs[1];\n    fibs[1] = fib3;\n    return result;\n});\n

\n

传递给 Stream.generate 方法的函数实现了Supplier 功能接口。请注意，要用作生成器，供应商通常需要某种外部状态。在这种情况下，其状态由最后两个斐波那契数列组成。

\n\n

为了实现这种状态，我们使用一个数组而不是几个变量，因为 lambda 内部使用的所有外部变量实际上都是 Final。

\n

我理解为什么变量在 lamdba 或匿名类中需要是最终的，我不明白的是为什么数组的值是“有效的最终”。

我用下面的例子来说明这一点：

final boolean run = true;\nexecutor.execute(() -> {\n    while (run) {\n        // do something\n    }\n});\n

这里run …