@Serializable
sealed class Navigation {
  
  // одно из самых ленивых решений просто сделать data object
  @Serializable
  data object Splash : Navigation()
}

@Serializable
sealed class Navigation {

  @Serializable
  class Splash : Navigation() {

    override fun equals(obj: Any?) 
      = obj is Splash  

    override fun hashCode() = 0
  }
}

class ArrayList<E> {

  private var modCount = 0

  fun add(element: E) {
    modCount++
    ...
  }

  fun remove(element: E) {
    modCount++
    ...
  }

  fun clear() {
    modCount++
    ...
  }
}

class ArrayListIterator<E> {
  
  ...

  fun next(): E {
    /*
    modCount берется из оригинального ArrayList'а
    
    expectModCount инициализируется при создании итератора значением modCount из оригинального ArrayList'a
    */
    if (modCount != expectModCount) {
      throw ConcurrentModificationException()
    }
    ...
  }
}

class Node(
  val value: Int, 
  var next: Node? = null
)

// всегда ссылается на первый элемент
val root = Node(1)

// добавляем в список значения
root.next = Node(2)
root.next.next = Node(3)
root.next.next.next = Node(4)

// у последнего next равен null
root.next.next.next.next // null

// root - ссылка на первый элемент
val node: Node? = root
// цикл для прохода по всем значениям списка
while (node != null) {
  // выводим значение элемента
  println(node.value)
  // идем к следующему
  node = node.next
}

// реализация стэка на динамическом массиве
val stack1 = ArrayList<String>()
// добавляем значение в конец стэка
stack1.add(10)
stack1.add(20)
// извлекаем значение с конца стэка
stack1.removeLast()

// реализация стэка на связанном списке
val stack2 = LinkedList<String>()
stack2.add(10)
stack2.add(20)
stack2.removeLast()

// реализация очереди на динамическом массиве
val queue1 = ArrayList<String>()
// добавляем значение в конец очереди
queue1.add(10)
queue1.add(20)
// извлекаем значение с начала очереди
queue1.removeFirst()

// реализация очереди на связанном списке
val queue2 = LinkedList<String>()
queue2.add(10)
queue2.add(20)
queue2.removeFirst()

// храним картинки в кэше, в качестве ключа используется адрес
val imageCache = mutableMapOf<Uri, Bitmap>()

// храним файлы в кэше, в качестве ключа также используется адрес
val downloadCache = mutableMapOf<Uri, File>()

val images = Array(10) { "" }

val url = "https://images.com/image0"
val image = downloadImage(url)
// за счет практически мгновенного вычисления индекса в хэш-таблице время добавления и изменения значений в среднем составляет O(1)
val index = hash(url)
images[index] = image

fun downloadImage(url: String) { ... }

// простая хэш-функция
fun hash(url: String): Int {
  return url.last().digitToInt()
}

// что-то типо модульного деления, ограничивает индекс до размера массива - 1
int index = hash(key) & (size - 1);

// боевая версия хэш-функции
static final int hash(Object key) {
    if (key == null) return 0;

    // о переопределении этого метода уже наверно книги есть, короче если он плохо написан индексы будут одинаковые, а это коллизия и ее надо как-то решать
    int h = key.hashCode();
    // смешивает младшие биты со старшими
    return h ^ (h >>> 16);
}

val index = hash(key)
// хэш таблица под капотом является обычным массивом
hashMap[index] = value

// хэш-функция вычисляет индекс практически моментально
fun hash(...) { ... }

// i это номер попытки, к примеру вычислили индекс для ключа3, а там уже есть ключ1, попробовали прибавить некоторое значение, а там ключ2 и так пока не найдется свободное место
val i = 1,2,3

// алгоритм линейного пробирования, просто прибавляем номер попытки (увеличиваем индекс на единицу) пока не найдется свободное место 
val nexIndex = index + i

// алгоритм квадратичного пробирования, прибавляем помимо номера попытки еще и степень этой попытки, это увеличивает интервал между коллизиями и лучше распределяет значения по таблице
val newIndex = index + i + i*i

type Validator struct {
  ...  
}

// на что-то похоже...
func (vl *Validator) Validate(token string) bool {
  return vl.GoogleValidator.Validate(token)
}

var validator = Validator { ... }
validator.Validate("google666")

package games

// доступен только в текущем файле 
type request struct {
  ...
}

// тоже доступен только в текущем файле
func writeResponse(...) { ... }

// можно получить в любом месте
func GamesEndpoint(...) { ... }

func Open(driver, source string) (*DB, error) { ... }

// знак равенства вместе с двоеточием := означает что одновременно объявляем переменную и кладем в нее значение
db, err := sql.Open(...)
if err != nil {
  return
}

// объявление переменной
var result sql.Result
// без двоеточия : так как тут только запись значений в переменные
result, err = db.Exec("DROP TABLE games")

// проинициализируется нулем
var number1 int

// будет nil
var number2 *int

type Config struct { ... }

// все поля структуры проинициализируются дефолтными значениями
var config1 Config

// будет nil
var config *Config

var numbers = []int{ 1, 2, 3 }

// вместо функции map нужно писать цикл
for i, num := range numbers {
  numbers[i] = num * 2
}

var filtered = []int {}
// вместо функции filter также надо писать цикл
for _, num := range numbers {
  if num > 2 {
    filtered = append(filtered, num)
  }
}

// функция contains имеет похожий аналог
slices.Contains(1, numbers)

func games(
  w http.ResponseWriter, 
  _ *http.Request
) {
  w.Write([]byte("OK!"))
}

router := mux.NewRouter()

router.HandleFunc(
  "/games", 
  games
).Methods("GET")

http.ListenAndServe(
  ":8080",
  router
)