Дмитрий Осипов

Есть две взаимосвязанных причины такого поведения. Во-первых, спецификация языка, стандартизирующая факт того, что перемножение int'ов даёт int:

When an operator applies binary numeric promotion to a pair of operands, each of which must denote a value that is convertible to a numeric type, the following rules apply, in order:

1. If any operand is of a reference type, it is subjected to unboxing conversion (§5.1.8).
   
2. Widening primitive conversion (§5.1.2) is applied to convert either or both operands as specified by the following rules:
   
   • If either operand is of type double, the other is converted to double.
     
   • Otherwise, if either operand is of type float, the other is converted to float.
     
   • Otherwise, if either operand is of type long, the other is converted to long.
     
   • Otherwise, both operands are converted to type int.
     
   
   

After the conversion(s), if any, value set conversion (§5.1.13) is then applied to each operand.

Binary numeric promotion is performed on the operands of certain operators:

• The multiplicative operators *, /, and % (§15.17)
  
• ...
  

Во-вторых, принципы работы стековых виртуальных машин. Вот так выглядит байткод метода main:

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=4, locals=6, args_size=1
         0: ldc           #2   // int 300000
         2: istore_1
         3: getstatic     #3   // Field java/lang/System.out:Ljava/io/PrintStream;
         6: ldc           #4   // String Input days:
         8: invokevirtual #5   // Method java/io/PrintStream.print:(Ljava/lang/String;)V
        11: new           #6   // class java/util/Scanner
        14: dup
        15: getstatic     #7   // Field java/lang/System.in:Ljava/io/InputStream;
        18: invokespecial #8   // Method java/util/Scanner."<init>":(Ljava/io/InputStream;)V
        21: astore        5
        23: aload         5
        25: invokevirtual #9   // Method java/util/Scanner.nextInt:()I
        28: istore        4
        30: iload         4
        32: ldc           #10  // int 86400
        34: imul
        35: iload_1
        36: imul
        37: i2l
        38: lstore_2
        39: getstatic     #3   // Field java/lang/System.out:Ljava/io/PrintStream;
        42: new           #11  // class java/lang/StringBuilder
        45: dup
        46: invokespecial #12  // Method java/lang/StringBuilder."<init>":()V
        49: ldc           #13  // String Light distance:
        51: invokevirtual #14  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        54: lload_2
        55: invokevirtual #15  // Method java/lang/StringBuilder.append:(J)Ljava/lang/StringBuilder;
        58: ldc           #16  // String  km.
        60: invokevirtual #14  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        63: invokevirtual #17  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        66: invokevirtual #18  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        69: return
     LocalVariableTable:
       Start  Length  Slot  Name   Signature
           0      70     0  args   [Ljava/lang/String;
           3      67     1 lightSpeed   I
          39      31     2 calculatedDistance   J
          30      40     4 runningTime   I
          23      47     5 input   Ljava/util/Scanner;

Интересны смещения с 30-го по 38-е. В стек загружаются два целых числа, перемножаются операцией imul, в результате которой с вершины стека убираются исходные два числа и помещается результат их перемножения, загружается ещё одно, ещё раз перемножаются, потом значение на вершине стека приводится к long операцией i2l и сохраняется в переменную calculatedDistance. Естественно, если результат работы imul окажется слишком большим, то произойдёт переполнение.

Исправить это легко, достаточно изменить тип константы:

calculatedDistance = runningTime * 86400L * lightSpeed;

Тогда компилятор выберет другие опкоды, оперирующие long'ами:

30: iload         4
32: i2l
33: ldc2_w        #10  // long 86400l
36: lmul
37: iload_1
38: i2l
39: lmul
40: lstore_2

import java.util.Arrays;

public class Test {
    public static void main(String[] args){
        int[] tab = {12, 1, 21, 8};
        int min = Arrays.stream(tab).min().getAsInt();
        int max = Arrays.stream(tab).max().getAsInt();
        System.out.println("Min = " + min);
        System.out.println("Max = " + max)
    }

}

Вы можете просто использовать новый Java 8 Stream s, но вам нужно работать с int.

Stream метод класса Arrays дает вам IntStream, на котором вы можете использовать min. Вы также можете сделать max, sum, average,...

Метод getAsInt используется для получения значения из OptionalInt

FileOutputStream может выкинуть исключение, его надо обработать в try или добавить в метод

class Test{
    public static void main(String[] args) throws FileNotFoundException {
        OutputStream output = new FileOutputStream("E:\\java_file\\Files_io\\fileTest.txt");
        PrintStream printOut = new PrintStream(output);

        System.setOut(printOut);
    }
}

В java нужно перехватывать исключения если их может бросить вызываемая функция. Ну либо пробрасывать еще выше. В данном случае не обрабатывается FileNotFoundException, его нужно перехватить и обработать.

В Java строки являются объектами, а объекты равны между собой, только если это один и тот же объект. Для сравнивания строк используйте метод equals.

Один из классических способов обработки остановки java-приложения, как сказали выше - Runtime.getRuntime().addShutdownHook. В свою очередь в нем можно подать команду на остановку всем остальным потокам, либо используя флаг "interrupt" класса Thread, либо используя в рабочих потоках предусмотрительно заведенный собственный флаг остановки.

Соответственно, останавливаемые потоки должны либо периодически проверять флаг остановки, либо корректно обрабатывать InterruptedException.

Пример с флагом "interrupt"

public static void main(String[] args) {
    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
      Thread.getAllStackTraces().keySet().stream()
          //Не стоит останавливать поток в котором отрабатывает хук, а тем более пытаться заджойниться
          .filter(thread -> !thread.equals(Thread.currentThread()))
          //Демоны предполагают безопасное завершение в любой момент, останавливать их не нужно
          .filter(thread -> !thread.isDaemon())
          //Устанавливаем флаг "interrupt" для всех остальных 
          .peek(Thread::interrupt) 
          .peek(thread -> System.out.println(thread.getClass()))
          .forEach(thread -> {
            try {
              thread.join(); //Ждем завершения всех потоков, которым установлен флаг "interrupt"
            } catch (InterruptedException e) {
              // ...
            }
          });
    }));
    
    while (true) {
      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
        System.out.println("Thread was interrupted once");
        //После перехвата исключения флаг "interrupt" возвращается в исходное состояние, поэтому его нужно установить снова
        Thread.currentThread().interrupt(); 
        break;
      }
    }

    while (true) {
      try {
        Thread.sleep(100); // Мы бы зависли здесь, если бы не установили флаг "interrupt" повторно
      } catch (InterruptedException e) {
        System.out.println("Thread was interrupted");
        Thread.currentThread().interrupt();
        break;
      }
    }
    
    while (!Thread.currentThread().isInterrupted()) {
      doSomeUninterruptableWork();
    }
  }

Как я понял, ядра имеют доступ только к своему L1 кэшу, а если поток будет исполняться на другом ядре, то он не увидит свои объекты, которые находятся в кэше другого ядра
Я правильно мыслю?

Нет. Все системы поддерживающие SMP имеют когерентный кеш. Т.е. если ядро обращается к данным, находящимся в L1 кеше другого ядра, то данные перемещаются в кеш запрашивающего ядра. См.