下面的代码中有2个静态块，为什么编译器不认为第一个块中未指定数据类型y是错误i？同时，如果i = 0在初始化时去掉了数据类型，也会出错，如果只在第二个块中指定数据类型，也会出错。
public class Test {
static {
i = 10;
}
static int i = 0;
static {
++i;
}
public static void main(String[] args) {
new Test();
System.out.println(i);
}
}
我试图通过命令行删除 pgsql 中的表，但它没有被删除
testdb=# 删除表发布者
testdb-# \dt+
| 方案 | 姓名 | 类型 | 所有者 | 贮存 | 接入方式 | 尺寸 | 描述 |
|---|---|---|---|---|---|---|---|
| 民众 | 出版商 | 桌子 | postgres | 永恒的 | 堆 | 8192 字节 |
但是当我在 pgadmin4 界面中执行相同的命令后，所有内容都被删除了
testdb-# \dt+
未找到关系。
我无法通过命令行删除表的原因是什么？
有如下代码，stream只是简单的将数字按升序添加到列表中：
List<Integer> integers = new ArrayList<>();
ListThread listThread1 = new ListThread(integers);
ListThread listThread2 = new ListThread(integers);
ListThread listThread3 = new ListThread(integers);
ListThread listThread4 = new ListThread(integers);
ListThread listThread5 = new ListThread(integers);
ListThread listThread6 = new ListThread(integers);
ListThread listThread7 = new ListThread(integers);
listThread1.start();
listThread2.start();
listThread3.start();
listThread4.start();
listThread5.start();
listThread6.start();
listThread7.start();
listThread1.join();
listThread2.join();
listThread3.join();
listThread4.join();
listThread5.join();
listThread6.join();
listThread7.join();
System.out.println(integers);
显示以下错误：
Exception in thread "Thread-0" java.lang.ArrayIndexOutOfBoundsException: Index 171 out of bounds for length 163
at java.base/java.util.ArrayList.add(ArrayList.java:455)
at java.base/java.util.ArrayList.add(ArrayList.java:467)
问题：据我了解，每个线程都有自己的缓存，每个线程在缓存中都有自己的字段版本integers，列表本身integers存储在 RAM 中。那么这种来自缓存的信息和来自RAM的信息的交互是如何发生的，因为如果一个线程想把一些元素放在数组之外，那么这个数组已经在这个线程的缓存中增加了。如果缓存中有很多变体，那么我们的 RAM 中的列表是如何形成的，哪个变体进入 RAM？
public class ListThread extends Thread {
private final List<Integer> list;
public ListThread(List<Integer> list) {
this.list = list;
}
@Override
public void run() {
for (int i = 0; i < 400; i++) {
list.add(i);
}
}
}
我有 2 个类 C1 和 C2（C2 继承自 C1）。我不能明确地将 C1 引导到 C2：
C2 l = (C2) new C1(5);
但它可能是这样的：
C2 c2 = new C2(5);
C1 c1 = c2;
C2 c21 =(C2) c1;
问题：当我们将c2 引用的值赋给类C1 的引用时，这是可以理解的，子类可以“缩小”到父类。但是，当我们将对类 C1 的引用转换为 C2 的引用分配给引用 c21 时，为什么这样的转换会起作用，因为在我们的例子中，c1 本质上是对父类的引用，它如何“扩展”到子类？
在研究 Reader 类时，我遇到了以下定义：“BufferedReader 从字符输入流中读取文本，缓冲读取的字符。缓冲区的使用旨在提高从流中读取数据的性能。”
问题：与使用常规读取器相比，使用缓冲区如何提高性能？
我对 collect 方法的这个变体感兴趣：
<R> R collect(Supplier<R> supplier,
BiConsumer<R, ? super T> accumulator,
BiConsumer<R, R> combiner);
为什么我不能像这样设置第一个参数？例子：
public static void main(String[] args) {
List<Integer> list1 = of(1, 2, 3, 4);
List<Integer> even = list1.stream()
.filter(a->a%2==0)
.collect(Supplier<ArrayList> sp = ()->new ArrayList<>(), (a, b)->a.add(b), (a, b)->a.addAll(b));
System.out.println(even);
}
但以下实现有效：
public static void main(String[] args) {
Supplier<ArrayList> sp = ()->new ArrayList<>();
List<Integer> list1 = of(1, 2, 3, 4);
List<Integer> even = list1.stream()
.filter(a->a%2==0)
.collect(sp, (a, b)->a.add(b), (a, b)->a.addAll(b));
System.out.println(even);
}
PS我知道一切都可以简而言之，但我想知道为什么它不起作用？
Stream类有一个map方法，<R> Stream<R> map(Function<? super T, ? extends R> mapper);
它返回Stream类型的对象，但是我不明白返回类型前面是什么意思（一般这样的参数化在这种方法中是无法理解的）。
我正在尝试使用 Scanner 填充字符串列表，但一切都取决于我可以退出 nextLine 方法这一事实，请告诉我如何解决这个问题，或者如何在不使用列表的情况下填充字符串数组？
public class StringSort {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<String> stringList = new ArrayList<>();
while (sc.hasNextLine()){
stringList.add(sc.nextLine());
sc.next();
if (stringList.get(stringList.size()-1) == "STOP"){
System.out.println("хочешь выйти?");
if (sc.nextLine() == "Yes"){
break;
}
else{
stringList.add("STOP");
}
}
}
System.out.println(stringList);
}
}
我无法进入第二个循环，请告诉我如何解决这个问题？我又添加了 1 台扫描仪，但有更好的解决方案吗？
public class Include {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<Integer> input1 = new ArrayList<>();
List<Integer> input2 = new ArrayList<>();
System.out.println("Введите последоватtльность чисел ");
while (sc.hasNextInt()) {
input1.add(sc.nextInt());
}
System.out.println(input1);
System.out.println(" введите вторую последовательность");
while (sc.hasNextInt()){
input2.add(sc.nextInt());
}
}
}
我正在编写一种使用 switch 将罗马数字转换为阿拉伯语的方法。以下是分别带有新旧开关的小示例：
public static int getArabic(char romanChar) {
return switch (romanChar) {
case 'M' -> 1000;
case 'D' -> 500;
default -> 0;
};
}
老的：
public static int getArabic(char romanChar) {
return switch (romanChar) {
case 'M' :
1000;
break;
case 'D':
500;
break;
default: 0;
};
如何将新开关改写成旧开关（我尝试引入一个通用的int变量，但它仍然在break时继续发誓）？
我正在编写一个创建“房子”对象的方法，它有一个楼层数组，每个楼层都有一个公寓数组。给公寓分配号码时，弹出这样的错误，我不知道为什么？（错误出在循环的第一行，所以全马开始给，因为有类似的操作，同样的错误）
等级类
public class Level {
private int number;
private Flat[] flats;
public void setNumber(int number) {
this.number = number;
}
HouseRun类
public class HouseRun {
public static void main(String[] args) {
ObjectCreating(5,4);
}
public static void ObjectCreating(int HouseNumber, int LevelsQuantities){
int FlatsCount = 1;
House house = new House(HouseNumber, LevelsQuantities);
Level[] levels = new Level[LevelsQuantities];
for (int i = 0; i < levels.length ; i++) {
levels[i].setNumber(i+1);
levels[i].setFlats();
Flat[] levelsFlats = levels[i].getFlats();
我有一个文本单词字典（words_dic 254 个单词），并且在 22x253 矩阵中有许多文本句子（k 22 个句子），我显示字典中的单词在给定句子中出现的次数
在 Schildt 的书中有这个片段（最后一段）：
请注意，队列大小比参数指定的大小大一
size。
为什么队列大小大于参数size（我们从哪里得到的），为什么数组的一个元素没有使用？如果我们有一个队列大小大于 的大小size，而书上说数组的大小应该大于队列的大小，那么为什么数组的大小用 表示size，这有什么矛盾呢？
完整代码：
class Queue{
char q[];
int putloc, getloc;
Queue(int size){
q=new char[size];
putloc=getloc=0;
}
void put(char ch){
if(putloc==q.length){
System.out.println("-Очередь заполнена");
return;
}
q[putloc++]=ch;
}
char get(){
if (getloc==putloc){
System.out.println("-Очередь пуста");
return (char) 0;
}
return q[getloc++];
}
}
public class Main {
public static void main(String[] args)
throws java.io.IOException {
Queue bigQ = new Queue(25);
Queue smallQ = new Queue(4);
char ch;
int i;
System.out.println("Использование очереди bigQ для хранения алфавита");
for (i = 0; i < 26; i++)
bigQ.put((char) ('A' + i));
System.out.print("Содержимое очереди bigQ: ");
for (i = 0; i < 26; i++) {
ch = bigQ.get();
if (ch != (char) 0)
System.out.print(ch);
}
System.out.println("\n");
System.out.println("Использование очереди smallQ для генерации ошибок");
for (i = 0; i < 5; i++) {
System.out.print("Попытка сохранения " + (char) ('Z' - i));
smallQ.put((char) ('Z' - i));
System.out.println();
}
System.out.println();
System.out.print("Содержимое очереди smallQ: ");
for (i = 0; i < 5; i++) {
ch = smallQ.get();
if (ch != (char) 0)
System.out.print(ch);
}
}
}
public class Main {
public static void main(String[] args) throws IOException {
char ch;
do {
System.out.println("Введите букву");
ch = (char) System.in.read();
} while (ch != 'q');
}
}