val arrayList = ArrayList<Int>()
arrayList.add(1) // Быстрая вставка в конец

arrayList.add(0, 2) // Медленная вставка в начало
arrayList.add(1, 3) // Медленная вставка в середину

val linkedList = LinkedList<Int>()
linkedList.addFirst(1) // Быстрая вставка в начало

linkedList.addLast(2) // Быстрая вставка в конец, если есть ссылка на последний узел

linkedList.add(1, 3) // Медленная вставка в середину

override fun onTouchEvent(event: MotionEvent): Boolean {
    when (event.action) {
        MotionEvent.ACTION_DOWN -> {
            Log.d("TouchEvent", "Палец коснулся экрана")
            return true
        }
        MotionEvent.ACTION_UP -> {
            Log.d("TouchEvent", "Палец отпущен")
        }
    }
    return super.onTouchEvent(event)
}

view.setOnTouchListener { _, event ->
    if (event.action == MotionEvent.ACTION_DOWN) {
        Log.d("TouchEvent", "Нажатие зафиксировано")
        true
    } else {
        false
    }
}

class User(val name: String, val age: Int)

class User(val name: String, val age: Int) {
    init {
        println("Создан пользователь: $name, возраст: $age")
    }
}

class User {
    var name: String
    var age: Int

    constructor(name: String) {  
        this.name = name
        this.age = 18  // Значение по умолчанию
    }

    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
    }
}

val user1 = User("Алекс")   // возраст будет 18  
val user2 = User("Иван", 25)  

class User(val name: String, val age: Int) {
    constructor(name: String) : this(name, 18)  
}

class User(val name: String, val age: Int) {
    init {
        println("Создан пользователь: $name, возраст: $age")
    }

    constructor(name: String) : this(name, 18) {
        println("Вызван вторичный конструктор")
    }
}

val inflater = LayoutInflater.from(context)
val view = inflater.inflate(R.layout.custom_layout, parent, false)

class MainActivity : AppCompatActivity() {
    private lateinit var scrollView: ScrollView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        scrollView = findViewById(R.id.scrollView)

        // Восстанавливаем позицию скролла
        savedInstanceState?.let {
            val scrollY = it.getInt("scroll_position", 0)
            scrollView.post { scrollView.scrollTo(0, scrollY) }
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putInt("scroll_position", scrollView.scrollY)
    }
}

class MainActivity : AppCompatActivity() {
    private lateinit var recyclerView: RecyclerView
    private lateinit var layoutManager: LinearLayoutManager

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        layoutManager = LinearLayoutManager(this)
        recyclerView = findViewById(R.id.recyclerView)
        recyclerView.layoutManager = layoutManager
        recyclerView.adapter = MyAdapter()

        // Восстанавливаем позицию скролла
        savedInstanceState?.let {
            val scrollPosition = it.getInt("recycler_position", 0)
            recyclerView.post { layoutManager.scrollToPosition(scrollPosition) }
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putInt("recycler_position", layoutManager.findFirstVisibleItemPosition())
    }
}

<EditText
    android:id="@+id/editText"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:freezesText="true"/>

val users = mapOf(1 to "Alice", 2 to "Bob", 3 to "Charlie")
println(users[1])  // Выведет: Alice

val users = mutableMapOf(1 to "Alice", 2 to "Bob")
users[3] = "Charlie"  // Добавляем элемент
users[1] = "Alex"  // Изменяем значение по ключу
users.remove(2)  // Удаляем элемент
println(users)  // {1=Alex, 3=Charlie}

val users = mapOf(1 to "Alice", 2 to "Bob")
println(users[1])  // Alice
println(users.getOrDefault(3, "Unknown"))  // Unknown

println(users.containsKey(2))  // true
println(users.containsValue("Charlie"))  // false

for ((key, value) in users) {
    println("ID: $key, Name: $value")
}

val filtered = users.filter { (key, value) -> key % 2 == 0 }
println(filtered)  // {2=Bob}

val sortedUsers = sortedMapOf(3 to "Charlie", 1 to "Alice", 2 to "Bob")
println(sortedUsers)  // {1=Alice, 2=Bob, 3=Charlie}

import java.util.concurrent.atomic.AtomicInteger

val counter = AtomicInteger(0)

fun increment() {
    counter.incrementAndGet()  // Увеличиваем значение безопасно
}

val lock = Any()
var count = 0

fun increment() {
    synchronized(lock) {
        count++  // Только один поток может изменять `count` одновременно
    }
}

val list = listOf("A", "B", "C")

println(list[1])  // "B"
println(list.getOrNull(5))  // null

println(list.first())  // "A"
println(list.last())   // "C"

println(emptyList<String>().firstOrNull())  // null

val numbers = listOf(10, 20, 30, 40)

println(numbers.find { it > 15 })   // 20
println(numbers.findLast { it > 15 })  // 40
println(numbers.find { it > 50 })   // null

val oneElementList = listOf(42)
println(oneElementList.single())  // 42
println(oneElementList.singleOrNull())  // 42

val emptyList = emptyList<Int>()
println(emptyList.singleOrNull())  // null

val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 }
println(evenNumbers)  // [2, 4]

val items = listOf("a", "b", "c", "d", "e")

println(items.take(3))  // [a, b, c]
println(items.takeLast(2))  // [d, e]

val sliced = items.slice(listOf(0, 2, 4))
println(sliced)  // [a, c, e]

val squared = numbers.map { it * it }
println(squared)  // [1, 4, 9, 16, 25]

class User(val name: String, val age: Int) {
    override fun equals(other: Any?): Boolean {
        if (this === other) return true  // Проверка на ссылочное равенство
        if (other !is User) return false  // Проверка типа

        return name == other.name && age == other.age  // Сравнение полей
    }
}

val user1 = User("Alice", 25)
val user2 = User("Alice", 25)
println(user1 == user2)  // true (потому что переопределён equals)

class User(val name: String, val age: Int) {
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is User) return false
        return name == other.name && age == other.age
    }

    override fun hashCode(): Int {
        return name.hashCode() * 31 + age  // 31 - стандартный коэффициент
    }
}

val userSet = HashSet<User>()
userSet.add(User("Alice", 25))
println(userSet.contains(User("Alice", 25)))  // true

data class User(val name: String, val age: Int)

val user1 = User("Alice", 25)
val user2 = User("Alice", 25)
println(user1 == user2)  // true (equals)
println(user1.hashCode() == user2.hashCode())  // true

(parameters) -> expression

(parameters) -> { statements; }

{ parameters -> code body }

{ println("Hello, World!") }  

{ a: Int -> a * a }   

{ a: Int, b: Int -> a + b }   

      { s: String ->
       println(s)
       s.length
   }