Честная очередь FIFO Queue

В данном примере цифры будут выводиться по правилу FIFO
Queue q1 = new LinkedList<>();
q1.offer(4);
q1.offer(5);
q1.offer(23);
q1.offer(1);

System.out.println(q1);
System.out.println(q1.poll());
System.out.println(q1.poll());
System.out.println(q1.poll());

В этом примере poll будет выводить цифры отсортированными по возрастанию...
Queue q = new PriorityQueue<>();
q.offer(4);
q.offer(5);
q.offer(23);
q.offer(1);

System.out.println(q);
System.out.println(q.poll());
System.out.println(q.poll());
System.out.println(q.poll());

Queue очередь

A PriorityQueue - это то, что называется бинарной кучей. Он упорядочен/отсортирован только в том смысле, что первый элемент является наименьшим. Другими словами, он заботится только о том, что находится в передней части очереди, остальные "заказываются", когда это необходимо.

Элементы упорядочиваются только по мере их удаления, т.е. удаляются из очереди с помощью poll(). Именно по этой причине PriorityQueue удается получить такую ​​хорошую производительность, поскольку она не делает больше сортировки, чем нужно в любое время.

Вычисление среднего значения >>>1

int low = 0;
int high = 75;
int mid = (low + high) / 2;
int mid1 = (low + high) >>> 1;

Для второго вычисления работает при условии
|low| <= |high|

т.е. в случае
int low = -77;
int high = 75;
int mid1 вернет неверный результат.

Convert int[] to Integer[]

Convert int[] to Integer[]:

int[] primitiveArray = {1, 2, 3, 4, 5};
Integer[] objectArray = new Integer[primitiveArray.length];

for(int ctr = 0; ctr < primitiveArray.length; ctr++) {
objectArray[ctr] = Integer.valueOf(primitiveArray[ctr]); // returns Integer value
}


Convert Integer[] to int[]:

Integer[] objectArray = {1, 2, 3, 4, 5};
int[] primitiveArray = new int[objectArray.length];

for(int ctr = 0; ctr < objectArray.length; ctr++) {
primitiveArray[ctr] = objectArray[ctr].intValue(); // returns int value
}


В Java 8 мы можем сделать это

int[] ints = {1,2,3};
List list = Arrays.stream(ints).boxed().collect(Collectors.toList());

Сортировка массива(Array) и списка(List)

Integer[] arr2 = {66,3,24,6,9};
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));

ArrayList colors = new ArrayList<>();
colors.add("red");
colors.add("yellow");
colors.add("black");
colors.add("blue");
colors.add("green");
Collections.sort(colors);
System.out.println(colors);

byte

byte
00000001 => 1
00000010 => 2
......
01111110 => 126
01111111 => 127
10000000 => -128
10000001 => -127
10000010 => -126
......
11111110 => -2
11111111 => -1

String.intern()

"123" == "123" // true
("12" + "3").intern() == "123" // true
new String("123") == new String("123") // false
new String("123") == "123" // false
new String("123").intern() == "123" // true

Наследование

Если в наследуемом классе в ручную создали default конструктор или конструктор c параметрами, то и в базовом классе должен быть создан default конструктор.

Convert List to Arrays, Arrays to List

String[] colors = {"yellow", "green", "blue"};
LinkedList ll = new LinkedList<>(Arrays.asList(colors));
ll.add("red");
ll.addFirst("black");

ListIterator listIterator = ll.listIterator();
while (listIterator.hasNext()){
System.out.println(listIterator.nextIndex() + " = " +listIterator.next());
}

colors = ll.toArray(new String[ll.size()]);

System.out.println(Arrays.toString(colors));

Boxing unboxing

Boxing
int a = 44335;
Integer b = Integer.valueOf(a);
Integer c = a; // automatic boxing

Unboxing
Integer c = 566;
int y = c.intValue();
int z = c; // automatic unboxing

Compares two strings lexicographically

"Test".compareTo("Test") => 0

"Test1".compareTo("Test") => 1
"a".compareTo("A") => 32
"z".compareTo("a") => 25

"Test".compareTo("Test1") => -1
"a".compareTo("b") => -1
"a".compareTo("c") => -2
"a".compareTo("d") => -3

Деление на ноль

System.out.println(2.0 % 0);// NaN
System.out.println(0.0 % 0);// NaN
System.out.println(2.0 / 0);// Infinity
System.out.println(0.0 / 0);// NaN
System.out.println(Math.sqrt(-1)); // NaN
System.out.println( 0.0/0 );// NaN
System.out.println(2 / 0);// Ошибка выполнения - RuntimeError
Exception in thread "main" java.lang.ArithmeticException: / by zero

Потоки Thread

public class MyThread extends Thread {
public static void main(String[] args) {
new MyThread().start();
}
}
При запуске нового потока выполняется код, размещённый в методе run(). Класс MyThread наследует от класса Thread пустой метод run() - поэтому новый поток ничего не выведет и просто завершит свою работу, а после этого закончит свою работу и всё приложение.

Default значения

Boolean b1; // = null
boolean b2; // = false
Integer b3; // = null
int b4; // =0

Списки - ArrayList

ArrayList list = new Arraylist();
В этом списке могут находиться элементы разного типа.

ArrayList list = new Arraylist<>();
В этом списке могут находиться элементы только одного типа.

ArrayList()
Constructs an empty list with an initial capacity of ten (10).

Массивы - Arrays

Сортировка
int[] arr = {3,6,1,2};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));

Null

Car car = null;
System.out.println(null==null); // true
System.out.println(car==null); // true
System.out.println(car.equals(null)); // NullpointerException.

Лоигческий И

result = 255 & 1 = 1

11111111 1 & 1 = 1 0 & 1 = 0
00000001 1 & 0 = 0 0 & 0 = 0
----------------
00000001

Форматированный вывод System.out.printf

System.out.printf("%6,4f", Math.PI);
3.1416

Модификатор static

Статические методы не могут обращаться к не статическим полям.

Только static переменные класса могут быть переданы в конструктор с параметрами, вызывающийся через слово super(параметр) и this(параметр)

class Moto extends Car{
static int n;
Moto(){
super(n);
}
}

Внутренние Анонимные классы

Анонимные классы не могут иметь внутри себя статических полей, методов, классов.
Исключением является константы (static final)
Возможность реализации множественного наследования классов.

Локальные переменные доступны в блоке объявления анонимного класса. Но его нельзя изменить внутри анонимного класса.

Примеры mod %

5 % 3 =2
5 % 4 =1
5 % 5 = 0
5 % 15 = 5
10 % 100 = 10
-7 % 5 = -2
-7 % -5 = -2
7 % -5 = 2

Неявное преобразование констант

final int iii = 127;
byte j = 0;
j = iii;
System.out.println(j);

здесь нет необходимости указывать признак явного преобразования (byte), так как исходное значение является константой и не выходит на пределы конечной переменной.


В другом случае признак явного преобразования необходим.

int iii = 127;
byte j = 0;
j = (byte)iii;
System.out.println(j);

Типы ERROR

Compiler ERROR - Ошибка компиляции
Runtime ERROR - Ошибка времени выполнения программы

Ошибка времени выполнения будет возникать только тогда, когда код действительно запущен. Это наиболее сложно - и привести к сбоям программы и ошибкам в вашем коде, которые трудно отследить.

В примере может потребоваться преобразовать строку: "hello" в целое число:

string helloWorld = "hello";
int willThrowRuntimeError = Convert.ToInt32(helloWorld);
Компилятор может не рассматривать это как проблему, но при запуске будет выведена ошибка.



Ошибки компилятора связаны с неточностями в коде, где компилятор выдает ошибку, чтобы предупредить вас о том, что не будет компилироваться и, следовательно, не может быть запущено.

Пример ошибки компилятора:

int = "this is not an int";

Правила именования

Первый символ: A-Z, a-z, _ , $
Остальные символы: A-Z, a-z, _ , $, 0-9

Integer обертка для int

Java caches the integer objects in the range -128 to 127

Integer i = 126;
Integer i2 = 126;

Integer i3 = 128;
Integer i4 = 128;

System.out.println(i == i2); // true, reference pointing to same literal
System.out.println(i3 == i4); // false, reference pointing to different objects

Integer i = new Integer(126);
Integer i2 = new Integer(126);

System.out.println(i == i2); // false

Разница между & и &&

exprA | exprB < - это значит оценить exprA, затем оценить exprB, затем выполнить |.

exprA || exprB < - это означает оценку exprA, и только если это false, тогда оцените exprB и выполните ||.

int a = 4;
int b = 7;
System.out.println(a & b); // prints 4
//meaning in an 32 bit system
// 00000000 00000000 00000000 00000100
// 00000000 00000000 00000000 00000111
// ===================================
// 00000000 00000000 00000000 00000100

Вложенные (Nested) Статические классы

Объект статического класса не хранит ссылку на конкретный экземпляр внешнего класса.

Объект статического вложенного класса вполне может существовать сам по себе.

Единственный момент — при создании такого объекта нужно указывать название внешнего класса:
Boeing737.Drawing drawing = new Boeing737.Drawing();

Статический вложенный класс может обращаться только к статическим полям внешнего класса.

При этом неважно, какой модификатор доступа имеет статическая переменная во внешнем классе. Даже если это private, доступ из статического вложенного класса все равно будет.

Внутренние(Inner) классы

Объект внутреннего класса не может существовать без объекта «внешнего» класса.

У объекта внутреннего класса есть доступ к переменным «внешнего» класса. Даже с модификатором — private

Внутренний класс не может содержать статические переменные и методы.

При создании объекта внутреннего класса важную роль играет его модификатор доступа.
- Если внутренний класс объявлен как public, мы можем создавать его объекты в любом другом классе. Единственное требование — объект «внешнего» класса тоже обязательно должен существовать.
- Если же мы объявим внутренний класс как private, доступ к созданию объектов у нас будет только внутри «внешнего» класса.

Bicycle bicycle = new Bicycle("Toyota", 30,52);
Bicycle.SteeringWheel wheel = bicycle.new SteeringWheel();
Bicycle.Seat seat = bicycle.new Seat();

Functional interface

Функциональный интерфейс - это интерфейс у которого только один абстрактный метод.

Функциональный интерфейс используется в лямбда выражениях.

Пример функционального интерфейса интерфейс Runnable
@FunctionalInterface
public interface Runnable {
public abstract void run();
}