Петровченко Иван's questions

将元素添加到数组的末尾

数组列表

list.add(str);

Array
无法执行此操作（写在资源上）
是否无法执行此操作：

int[] array = new int[10];
array[9] = 20; // добавил последний элемент в конец массива, 9 индекс == 10 элемент

在数组中间插入一个元素

数组列表

list.add(15, str);

大批

无法执行此操作（写在资源上）
是否无法执行此操作：

 int[] array = new int[10];
 array[5] = 10; // вставил элемент в середину массива 

在数组的开头插入一个元素

数组列表

list.add(0, str);

大批

无法执行此操作（写在资源上）

不能这样做吗：

 int[] array = new int[10];
 array[0] = 2; // вставил в начало массива
 array[1] = 4;
 array[2] = 6;
 array[3] = 8;
 array[4] = 10;
 array[0] = 24; // Вставил элемент в начало массива, но только (перезаписал значение)

请更详细地解释为什么无法对数组执行这些操作，提前感谢您的帮助！

Java书说：

1. 我可以有很多方法。

   答：类，对象。

   我理解类，一个类可以有很多方法，因为它们在那里，但是一个对象呢？在对象上，因为它是类的实例并且方法也间接引用它？好吧，他们说如果类有，那么对象还因为它是类的实例吗？

2. 我可以表现得不同。

   答：类，对象。

   我真的不明白一个类如何表现不同。对象调用不同的方法，这就是它的本质：行为不同？

3. 我住在一堆。

   答：对象。

   在这里，如果可能，请写得更详细。我真的不明白为什么一个对象，既然是一个对象，那么为什么不是类呢？

预先感谢您的帮助！

每个 ArrayList 类型的对象内部都存储了一个规则的元素数组。

1. transient Object[] elementData; // non-private to simplify nested class access

   我在教室里找到的ArrayList，是他吗？为什么会这样写：“在一个类型的每个对象内部，ArrayList存储了一个规则的元素数组，而不是在一个类内部？”

2. 当您从 ArrayList 读取元素时，它会从其内部数组中读取它们。当您写入时，它会将它们写入内部数组。

   如何理解阅读？而且我并没有真正理解什么样的内部数组。

我正在看教程，我看到这些话：

在 Java 中，集合分为三个主要组：Set - 一个集合，List - 一个列表，Map - 一个字典（或映射）。

第一个问题，队列在哪里？不仅在本教程中（付费），而且在其他教程中也是这样写的，但是队列在哪里？请解释一下这种情况。

public class BankProcents {
    public static void main(String[] args) {
        double vklad = 1000;
        double procent = 0.02;

        for (int year = 1; year <= 5; year++) {
            vklad += vklad * procent;
            System.out.println("За " + year + " год, на вашем счету появилась " + vklad + " сумма долларов");
        }
    }
}

我看到这样一个计算银行利息的程序，我不明白为什么如果我们计算每年 2%，那么我们写的是 0.02，而不是 0.2？

public class Generator {
    public static void main(String[] args) {
        String[] surnameList = {"Вишневский", "Сидоров", "Заперской", "Вафлистов", "Мичурин", "Иванов", "Алеексеев", "Петухов"};
        String[] nameList = {"Александр", "Иван", "Алексей", "Максим", "Владимир", "Геннадий", "Петр", "Ярослав"};
        String[] patronymicList = {"Анатольевич", "Александрович", "Владимирович", "Алексеевич", "Сергеевич", "Максимович", "Ярославович", "Иванович"};

        // Вычисляем, сколько слов в каждом списке
        int surnameLength = surnameList.length;
        int nameLength = nameList.length;
        int patronymicLength = patronymicList.length;

        //Генерируем три случайных числа
        int rand1 = (int) (Math.random() * surnameLength);
        int rand2 = (int) (Math.random() * nameLength);
        int rand3 = (int) (Math.random() * patronymicLength);

        //Строим фразу
        String phrase = surnameList[rand1] + " " + nameList[rand2] + " " + patronymicList[rand3];

        //Выводим фразу
        System.out.println("Ваш напарник это - " + phrase);
    }
}

例如，我不明白它是如何工作Math.random()的，以及它产生和乘以什么surnameLength。在调试中，我看不到生成什么Math.random().
该示例的书说：
该方法random()返回一个介于 0 和 1 之间的随机数，因此我们必须将该数字乘以列表中的元素数（数组的长度）。但是如果我们的方法random()返回为写的0and 0 умножается на 8(длина каждого массива)，那么在这种情况下，总数将始终为 0 索引(8*0=0).

public class Test {
    public static void main(String[] args) {

        printNumber(new Integer(112)); // обычный int, даже без переменной
    }

    public static void printNumber(int i) {
        System.out.println("Вы ввели число " + i);
    }
}

printNumber(new Integer(112));- 划掉并写入过时的版本，在这个例子中如何正确地完成并且没有过时的版本？所以：？？？

public class Test {
    public static void main(String[] args) {
        Integer i = 223;
        printNumber(i);
    }

    public static void printNumber(int i) {
        System.out.println("Вы ввели число " + i);
    }
}

import java.util.ArrayList;
import java.util.List;

public class Unboxing {

    public static void main(String[] args) {
        Integer i = new Integer(-8);

        // 1. Unboxing through method invocation
        int absVal = absoluteValue(i);
        System.out.println("absolute value of " + i + " = " + absVal);

        List<Double> ld = new ArrayList<>();
        ld.add(3.1416);    // Π is autoboxed through method invocation.

        // 2. Unboxing through assignment
        double pi = ld.get(0);
        System.out.println("pi = " + pi);
    }

    public static int absoluteValue(int i) {
        return (i < 0) ? -i : i;
    }
}

在 JDK 5 之前它是Integer i = new Integer(-8);
但是在 JDK 5 中他们做到了，Integer i = -8;
为什么我什至在文档中看到这样一个例子

public class Test {

    Integer i;
    int j;

    public static void main(String[] args) {
        Test t = new Test();
        t.go();
    }

    public void go() {
        j = i;
        System.out.println(j);
        System.out.println(i);
    }
}

Integer i;// 包含 null // 包含int j;0null = 0NullPointerException

要问：

就像 equals() 一样，对于 hashCode() 方法也有官方要求，写在 Oracle 文档中：

1. 如果两个对象相等（即 equals() 方法返回 true），它们必须具有相同的哈希码。

否则，我们的方法将毫无意义。正如我们所说，检查 hashCode() 应该首先提高性能。如果哈希码不同，检查将返回 false，即使对象实际上是相等的（根据我们在 equals() 方法中的定义）。

2. 如果在同一个对象上多次调用 hashCode() 方法，则每次都必须返回相同的数字。

3. 规则 1 反其道而行之。两个不同的对象可以有相同的哈希码。

我很困惑帮我弄清楚：
为什么在规则 3 中写到规则 1 在相反的方向上不起作用？
事实证明 1 规则 2 对象是相等的，并且它们具有相同的哈希码。
而且第三条规则也是2个对象的哈希码相同，还是我不太明白？为什么在规则 1 中写的是 2 个对象相等，而在规则 3 中，可以为两个不同的对象编写相同的哈希码，如何理解不同的对象？

阅读可变/不可变对象 不可变对象有许多有用的属性。但是对于几乎所有不可变对象来说，有两个是典型的：

1) 不可变对象比可变对象更容易实现。2）不可变对象可以从不同的线程同时自由使用。

我有几个问题，请，如果你回答并且对你来说并不困难，请逐点回答我，提前谢谢:)

1） 如何理解对象可以更容易实现？

2) 信息是否正确？- 不可变对象是其外部可见状态在创建后无法更改的对象。Java 类库中的 String、Integer 和 BigDecimal 类是不可变对象的示例——它们表示在对象的生命周期内不能更改的单个值。

3) 除了 String (StringBuilder, StringBuffer), Integer, BigDecimal 类之外还有哪些可变/不可变对象？只是我想看到的名字

4）不可变对象可以从不同的线程同时自由使用。线程是线程？它们是同义词吗？

public class DogIsNotReadyException extends Exception {

    public DogIsNotReadyException(String message) {
        super(message);
    }
}

public class Dog {

    String name;
    boolean isCollarPutOn;
    boolean isLeashPutOn;
    boolean isMuzzlePutOn;

    public Dog(String name) {
        this.name = name;
    }

    public void putCollar() {

        System.out.println("Ошейник надет!");
        this.isCollarPutOn = true;
    }

    public void putLeash() {

        System.out.println("Поводок надет!");
        this.isLeashPutOn = true;
    }

    public void putMuzzle() {
        System.out.println("Намордник надет!");
        this.isMuzzlePutOn = true;
    }

    public void walk() throws DogIsNotReadyException {

        System.out.println("Собираемся на прогулку!");
        if (isCollarPutOn && isLeashPutOn && isMuzzlePutOn) {
            System.out.println("Ура, идем гулять! " + name + " очень рад!");
        } else {
            throw new DogIsNotReadyException("Собака " + name + " не готова к прогулке! Проверьте экипировку!");
        }
    }
}


public class Test {
    public static void main(String[] args) throws DogIsNotReadyException {
        Dog dog = new Dog("Rex");
        dog.putCollar();
        dog.putMuzzle();
        dog.walk();
    }
}

为什么这段代码会输出到控制台：

Ошейник надет!
Намордник надет!
Собираемся на прогулку!
Exception in thread "main" DogIsNotReadyException: Собака Rex не готова к прогулке! Проверьте экипировку!
    at Dog.walk(Dog.java:35)<br>
    at Test.main(Test.java:6)

下面是一个输出此示例的示例：

Ошейник надет! 
Намордник надет! 
Собираемся на прогулку! 
Собака Мухтар не готова к прогулке! Проверьте экипировку! 
Проверяем снаряжение! Ошейник надет? true
Поводок надет? false 
Намордник надет? true 

这是一个例子：

public class DogIsNotReadyException extends Exception {

    public DogIsNotReadyException(String message) {
        super(message);
    }
}


public class Dog {

    String name;
    boolean isCollarPutOn;
    boolean isLeashPutOn;
    boolean isMuzzlePutOn;

    public Dog(String name) {
        this.name = name;
    }

    public void putCollar() {

        System.out.println("Ошейник надет!");
        this.isCollarPutOn = true;
    }

    public void putLeash() {

        System.out.println("Поводок надет!");
        this.isLeashPutOn = true;
    }

    public void putMuzzle() {
        System.out.println("Намордник надет!");
        this.isMuzzlePutOn = true;
    }

    public void walk() throws DogIsNotReadyException {

        System.out.println("Собираемся на прогулку!");
        if (isCollarPutOn && isLeashPutOn && isMuzzlePutOn) {
            System.out.println("Ура, идем гулять! " + name + " очень рад!");
        } else {
            throw new DogIsNotReadyException("Собака " + name + " не готова к прогулке! Проверьте экипировку!");
        }
    }
}

public class Test {
    public static void main(String[] args)  {
        Dog dog = new Dog("Rex");
        dog.putCollar();
        dog.putMuzzle();
        try{
            dog.walk();
        } catch (DogIsNotReadyException e) {
            System.out.println(e.getMessage());
            System.out.println("Проверяем снаряжение! \n Ошейник надет? " + dog.isCollarPutOn + "\r\n Поводок надет? "
                    + dog.isLeashPutOn + "\r\n Намордник надет? " + dog.isMuzzlePutOn);
        }
    }
}

问题：

1. main如果我们用标记方法，为什么第一个示例不起作用throws？它应该同样适用于第一个示例和第二个示例。好吧，throws或者try catch应该是。

2. 我不明白该方法是如何工作的getMessage()，我进入源代码并看到了这个：

   public String getMessage() {
       return detailMessage;
   }
   

   我看了看它detailMessage只是一个变量，无论如何我都不明白它是如何工作的。为了检查，我这样做了：

   public class Test {
       public static void main(String[] args)  {
           Dog dog = new Dog("Rex");
   
           try{
               dog.walk();
           } catch (DogIsNotReadyException e) {
               System.out.println(e.getMessage());
           }
       }
   }
   

   输出到控制台：

   Собираемся на прогулку!
   Собака Rex не готова к прогулке! Проверьте экипировку!
   

   在 walk 方法的调用中，它执行

   System.out.println("Собираемся на прогулку!");
   

   但后来它工作了，throw new DogIsNotReadyException("Собака " + name + " не готова к прогулке! Проверьте экипировку!");但只有当 System.out.println(e.getMessage());我们写它时，我不明白代码是如何工作的。

我阅读了一篇关于 Habré 的文章，以下是我的示例和信息：

我的代码：

public class Man {

    private String noseSize;
    private String eyesColor;
    private String haircut;
    private boolean scars;
    private int dnaCode;

    public Man(String noseSize, String eyesColor, String haircut, boolean scars, int dnaCode) {
        this.noseSize = noseSize;
        this.eyesColor = eyesColor;
        this.haircut = haircut;
        this.scars = scars;
        this.dnaCode = dnaCode;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Man man = (Man) o;
        return dnaCode == man.dnaCode;
    }
//геттеры сеттеры и тд

首先，为避免混淆，让我们定义一些术语。相同对象是具有相同字段内容的同一类的对象。

对于同一个对象，哈希码总是相同的；

public class Test {
    public static void main(String[] args) {
        Man man1 = new Man("Большой", "Зеленый", "Горшок", true, 13);
        Man man2 = new Man("Большой", "Зеленый", "Горшок", true, 13);
        System.out.println(man1.hashCode());
    }
}

好的，这里一切都正确，它重新启动多少次显示相同的哈希码，让我们继续：

如果对象相同，则哈希码相同

public class Test {
    public static void main(String[] args) {
        Man man1 = new Man("Большой", "Зеленый", "Горшок", true, 13);
        Man man2 = new Man("Большой", "Зеленый", "Горшок", true, 13);
        System.out.println(man1.hashCode() + "  " + man2.hashCode());
    }
}

控制台输出：1802598046 659748578 为什么这里有两个相同的哈希码？继续前行：

如果哈希码相等，则输入特征并不总是相等（碰撞）

不幸的是，目前我不知道如何获得两个相同的哈希码，所以我无法检查它。我不会介意一个例子。

如果哈希码不同，则保证对象不同；我再次回到这个哈希码不同但对象相同的示例，这就是控制台中显示的内容：

1802598046  659748578



 public class Test {
        public static void main(String[] args) {
            Man man1 = new Man("Большой", "Зеленый", "Горшок", true, 13);
            Man man2 = new Man("Большой", "Зеленый", "Горшок", true, 13);
            System.out.println(man1.hashCode() + "  " + man2.hashCode());
        }
    }

处理hashCode()和equals()

import java.util.Objects;

public class Man {

    private String noseSize;
    private String eyesColor;
    private String haircut;
    private boolean scars;
    private int dnaCode;

    public Man(String noseSize, String eyesColor, String haircut, boolean scars, int dnaCode) {
        this.noseSize = noseSize;
        this.eyesColor = eyesColor;
        this.haircut = haircut;
        this.scars = scars;
        this.dnaCode = dnaCode;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (getClass() != o.getClass()) return false;
        Man man = (Man) o;
        return dnaCode == man.dnaCode;
    }

    public String getNoseSize() {
        return noseSize;
    }

    public void setNoseSize(String noseSize) {
        this.noseSize = noseSize;
    }

    public String getEyesColor() {
        return eyesColor;
    }

    public void setEyesColor(String eyesColor) {
        this.eyesColor = eyesColor;
    }

    public String getHaircut() {
        return haircut;
    }

    public void setHaircut(String haircut) {
        this.haircut = haircut;
    }

    public boolean isScars() {
        return scars;
    }

    public void setScars(boolean scars) {
        this.scars = scars;
    }

    public int getDnaCode() {
        return dnaCode;
    }

    public void setDnaCode(int dnaCode) {
        this.dnaCode = dnaCode;
    }
}

equals我似乎知道这是如何工作的，在构造函数中，在我编写的 setter 中，但通常是if (this == o) return true;这样。

帮忙举个例子：

Map<Integer, String> map = new HashMap<>();

        map.put(1, "Vasilisa");
        map.put(2, "Marina");
        map.put(3, "Kate");

        for (Map.Entry<Integer, String> entry: map.entrySet()){
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }

来自 Java 文档，不是很专业的英语，所以我使用了翻译器。

Map.entrySet 方法返回其元素属于此类的地图的集合视图。获取对映射条目的引用的唯一方法是从该视图集合的迭代器。这些 Map.Entry 对象仅在迭代期间有效；更正式地说，如果在迭代器返回条目后修改了基本映射，则映射条目的行为是未定义的，除了对映射条目的 setValue 操作。

我真的不明白我们为什么要这样做：

Map.Entry <Integer, String> entry: map.entrySet()

首先是Type，然后是Variable，然后是Collection / Array，但我真的不明白为什么要写Map.Entry + 然后不只是map，而是map.entrySet()。
帮助我用清晰简单的语言理解，提前谢谢！

说说插入和删除的速度吧，我不是很明白它是константное время什么，什么样的构造O(1), O(n)。
之前在谷歌上搜索过这个：

在 O(1) 时间内按索引快速访问元素

在线性时间内按值访问元素 O(n)

什么是 O(1) 时间内的快速访问，什么是线性 O(n) 时间，它是如何测量/验证的？
提前致谢！

import java.util.Arrays;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<String> states = new TreeSet<>();

        states.add("Germany");
        states.add("France");
        states.add("Italy");
        states.add("Spain");
        states.add("Great Britain");

        System.out.println(states);

        // возвращаем набор в котором все элементы меньше текущего
        SortedSet<String> setLower=states.headSet("Germany");

        System.out.println("Это headSet " + setLower);

        // возвращаем набор в котором все элементы больше текущего
        SortedSet<String> setGreater=states.tailSet("Germany");
        System.out.println("Это tailSet " + setGreater);

        // получим поднабор от одного элемента до другого
        SortedSet<String> set = states.subSet("Germany", "Italy");
        System.out.println("Это subSet " + set);
    }
}

我将从headSet：

这是我添加后的排序方式。

[France, Germany, Great Britain, Italy, Spain]

headSet工作正常，这是我读到的关于这个方法的内容：
返回一个集合，其中所有元素都小于当前元素

输出到控制台：

Это headSet [France]

原来，如果我们排在第二位，那么仅仅因为她排在第Germany一位就意味着比他（现在的那个）少？France这就是为什么它带来了法国？

tailSet：
返回一个集合，其中所有元素都大于当前元素

输出到控制台：

Это tailSet [Germany, Great Britain, Italy, Spain]

原来tailSet方法显示的是当前元素和大于它的元素？也就是说，我们Germany排在第 2 位，但排Great Britain在第Italy3、4 和Spain5 位。为什么我们得到：[德国、英国、意大利、西班牙] 而不是 [英国、意大利、西班牙]？

subSet:
从一个元素到另一个元素的子集

输出到控制台：

Это subSet [Germany, Great Britain]

但我不明白为什么？Germany据说我们从到写到，为什么在控制台里Italy出来了？为什么不只？GermanyGreat BritainGreat Britain

我看到了这个设计：

SortedSet<String> setLower=states.headSet("Germany");

像这样：

`setLower.headSet("Germany");` ?

为什么要立即写给构造函数？
我也见过这样的事情：

Set setLower = states.headSet("Germany");<br>

这个构造和SortedSet有什么区别？

 public static void main(String[] args) {
        HashSet<String> values = new HashSet<>();

        values.add("Ivan");
        values.add("Petr");
        values.add("Alexandr");
        values.add("Dmitriy");

        System.out.println(values);
    }

[Petr, Alexandr, Ivan, Dmitriy]这是我在控制台中得到的。
为什么值是以这种方式出来的，而不是像ArrayList中那样的顺序？

我看到它应该是这样声明的，所以它更正确。

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

但是当我通过 object: 调用方法时addFirst()，这个想法本身就替代了以下构造：

((LinkedList<String>) list).addFirst();

为什么我不能这样做，list.addFirst()请告诉我！我注意到它只有在你这样声明时才有效：

LinkedList<String> list = new LinkedList<>();

但正如我在上面已经展示的那样，使用这种结构更正确：

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

如我错了请纠正我

我在项目（Spring）中看到了这段代码：

manRepository.findAll().forEach(mans::add);

这个 forEach 有什么有趣的？
我只熟悉这个：

for(int i: list(массив или коллекция)){
       //тело цикла
}