小编Zab*_*uza的帖子

我有以下代码块：

public static void main(String[] args) {
    Integer[] test = new Integer[100];
    comparableTest(test);
    genericsTest(test);
}

private static void comparableTest(Comparable[] c) {

}

private static <E extends Comparable<E>> void genericsTest(E[] e) { }

我使用泛型到底要完成什么？这些都没有编译错误。我仍然可以使用 compareTo 方法。那么我得到的是什么E extends Comparable<E>而不是仅仅使用Comparable？

这个问题的上下文是我让排序算法使用E extends Comparable<E>而不是Comparable.

考虑

boolean b = Boolean.parseBoolean("100");

我认为它会抛出异常，因为"100"既不是也不"true"是"false"。但它过去了，没有例外。

为什么方法不抛出？

一位同事在 PR 中添加了评论评论，我们应该使用1L而不是(long)1。我同事给的唯一解释是使用和阅读1L很方便。所以我的问题是除了可读性之外，1L 是否还有其他一些好处？

我的代码

void getUserId() {
    assert((long) 1, userService.getUserId())
}

userService.getUserId() returns long value i.e 1
assert() accepts two long object

考虑以下示例：

public class Example {
    public static <T> void f(T obj) {
        Integer i = (Integer) obj; // runtime error
    }
    public static void main(String[] args) {
        f("hello");
    }
}

有什么理由让 Java 无法确定第 3 行中的强制转换在编译时是非法的吗？当然，由于类型擦除，运行时函数的签名将是f(Object obj)，但在我看来，在编译时它有足够的信息来捕获错误。

将此与案例进行比较：

List<String> ls = new ArrayList<>();
ls.add(42); // compile-time error
ls.add("foo");
Integer i = ls.get(0); // compile-time error

其中涉及类型参数但在编译时成功检测到错误。

如果答案是“编译器不够聪明”，那么有什么理由（为了向后兼容？）为什么不能让它变得更聪明？

我有一些代码synchronized用来保护我递增的计数器count++。

我希望我正确地保护了代码部分，因此得到2_0000_0000了结果，因为count在多次执行它之后，这将是正确的值，多线程。

但是，在运行代码时，我得到一个低于预期的值2_0000_0000，就好像我synchronized没有正确保护代码部分一样。

为什么会这样，我做错了什么？

public class Test {
    private static Integer count = 0;

    private static void add10K() {
        long idx = 0;
        while (idx++ < 1_0000_0000) {
            synchronized (count){
                count += 1;
            }
        }
    }

    public static long calc() {
        Thread th1 = new Thread(Test::add10K);
        Thread th2 = new Thread(Test::add10K);
        th1.start();
        th2.start();
        try {
            th1.join();
            th2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return count;
    }

    public …

如何将 a 转换String[]为long[]？

我有一个String[] inputArray包含Stringat 的inputArray[31]。我想在特定的 上拆分该字符串SPLIT_CHAR，结果String[]如下：

String[] numbersText = inputArray[31].split(SPLIT_CHAR);

现在，每个元素都代表一个我想解析为 的数字long，因此可以有效地接收long[]. 我怎样才能做到这一点？

当程序员无法向类编写任何构造函数时，编译器会提供默认构造函数。据说这些构造函数用于初始化类属性的默认值。但是，如果程序员提供了一个构造函数，则可以是简单的构造函数，例如：

public class Main {
  int a;

  Main() { // user defined simple constructor
    System.out.println("hello");
  }

  public static main(String[] args) {
    Main obj = new Main();
  }
}

在上面的代码中，用户包含了一个构造函数。但是它不会初始化实例变量(a)。此外，默认构造函数不会被调用。那么为什么变量“a”被初始化为其默认值呢？

如果默认构造函数不会将类变量初始化为其默认值，而编译器会自动执行此操作，那么默认构造函数的实际用途是什么？

为什么在用户无法编写构造函数的情况下，编译器会添加默认构造函数？

当我简单地写代码时

String x = null;

System.out.println(x instanceof Object);

输出为false，正如预期的那样。

但当我尝试将其写得略有不同时，即：

public class Main {
        public static void main(String[] args) {
        String x = null;
        System.out.println("Result is: " + x instanceof Object);
    
  }
}

我得到true作为输出。为什么？

x instanced Object应该还是false这样吧？我想得到像这样的输出

Result is: false

为什么打印以下代码？

float called long called 20.0 21

代替

float called 20.0 long called 21

这是代码:

public class Test5 {
    static float fun(int a) {
        System.out.print("float called ");
        return a;
    }

    static long fun(long a) {
        System.out.print("long called ");
        return a;
    }

    public static void main(String[] args) {
        System.out.println(fun(20) + " " + fun(21L));
    }
}

这是我在自动化中的第一个代码：

package Automationframework;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;

public class FirstTestClass {
    public static void main(String[] args) throws InterruptedException {
        System.setProperty("webdriver.gecko.driver", "D:\workbox\Online Store\geckodriver.exe");

        WebDriver driver = new FirefoxDriver();
        driver.get("http://www.store.demoqa.com");
        System.out.println("Successfully opened the website www.Store.Demoqa.com");
        Thread.sleep(5000);
        driver.quit();
    }
}

它正在抛出错误：

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Invalid escape sequence (valid ones are  \b  \t  \n  \f  \r  \"  \'  \\ )
    at Automationframework.FirstTestClass.main(FirstTestClass.java:13)**

我有一个字符串数组的链表。

List<String[]> list = new LinkedList<>();

此列表的每个元素都包含以下形式的元素：

["word1", "example1", "2"]

如何按每个数组字典中的第一个字符串元素对列表进行排序？

编译时出现错误。此外，如果我可以在实际编写方法和声明变量之前创建对象 Overload，我仍然感到困惑。

 class Overload {

    public static void main( String args[] ) {
    Overload overload = new Overload();
    Overload.methodOne();
    Overload.methodOne( 8 );
}

    void methodOne() {
    System.out.println(“no arguments”);
}

    void methodOne( int x) {
    System.out.println(“ integer value=” + x );
}

}

在行中，我收到了一个错误的非法字符：

'\u201c'

我不明白以下代码的结果如何6被称为sum(3).有人可以解释一下吗？

public int sum(int number) {
    if (number == 1) {
        return number;
    } else {
        return number + sum(number - 1);
    }
}