🤔 Что нужно сделать в Android-проекте чтобы начать рисовать UI на экране?

Чтобы начать рисовать пользовательский интерфейс (UI) на экране в Android-проекте, необходимо выполнить несколько шагов, которые включают настройку проекта, создание макета и взаимодействие с основными компонентами Android.

1⃣Создание Android-проекта
Первый шаг — создание Android-проекта в Android Studio. Это можно сделать, выбрав шаблон «Empty Activity», который предоставляет минимальный набор для разработки приложения.
Укажите имя проекта.
Выберите язык программирования (Java или Kotlin).
Убедитесь, что минимальная версия SDK подходит для вашей целевой аудитории.

2⃣Настройка макета (XML-файл)
Android UI в основном создаётся с использованием XML-файлов, которые определяют структуру интерфейса.
По умолчанию файл макета находится в каталоге:

res/layout/activity_main.xml

#### Пример простого макета:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="https://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:gravity="center">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Привет, мир!"
        android:textSize="24sp"
        android:padding="16dp"/>

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Нажми меня"/>
</LinearLayout>

🟠Подключение макета к активности
Макет нужно связать с логикой приложения в Java или Kotlin. Это делается с помощью метода setContentView() в Activity.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Указываем, какой XML-файл использовать для интерфейса
        setContentView(R.layout.activity_main)

        // Найдём элементы интерфейса и добавим логику
        val textView = findViewById<TextView>(R.id.textView)
        val button = findViewById<Button>(R.id.button)

        button.setOnClickListener {
            textView.text = "Кнопка нажата!"
        }
    }
}

🟠Добавление кастомного рисования (по необходимости)
Если нужно нарисовать что-то вручную (например, графику, линии, или кастомные фигуры), можно создать свой собственный класс, унаследованный от View, и переопределить метод onDraw().

class CustomView(context: Context) : View(context) {
    private val paint = Paint().apply {
        color = Color.RED
        strokeWidth = 10f
    }

    override fun onDraw(canvas: Canvas?) {
        super.onDraw(canvas)

        // Рисуем линию
        canvas?.drawLine(100f, 100f, 400f, 400f, paint)
    }
}

Чтобы использовать этот класс, можно добавить его в макет или программно

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Устанавливаем кастомный View вместо макета
        setContentView(CustomView(this))
    }
}

🟠Запуск приложения
Теперь можно запустить приложение на эмуляторе или реальном устройстве:
Нажмите Run в Android Studio.
Убедитесь, что устройство подключено или выбран эмулятор.
После запуска вы увидите созданный интерфейс.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Из каких частей состоит проект и какая часть за что отвечает?

– src/ — исходный код,
– res/ — ресурсы (строки, изображения, макеты),
– manifest — описание компонентов, разрешений, запуска,
– build.gradle — настройки сборки, зависимости,
– libs/ — внешние библиотеки,
– assets/ — файлы, доступные в рантайме.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Зачем нужны Data Class и Sealed Classes?

Data Class и Sealed Class решают разные задачи и обеспечивают улучшения в организации кода, управлении состоянием и безопасности типов. Они вносят значительные упрощения и повышают читаемость кода в Kotlin-проектах.

🚩Зачем они нужны

Data Class предназначены для хранения данных и автоматически предоставляют ряд полезных методов, что упрощает разработку и уменьшает объем шаблонного кода. Основные причины использования Data Class:

🟠Сокращение кода
Автоматически генерирует методы equals(), hashCode(), и toString(), а также copy() и компонентные функции для объектов данных. Это избавляет от необходимости ручной реализации этих методов, что уменьшает количество кода и возможность ошибок.

🟠Упрощение передачи данных
Идеально подходят для передачи данных между различными частями приложения, например, между слоями в архитектуре MVVM или при передаче данных между активностями и фрагментами.

🟠Поддержка неизменяемости
С помощью них легко создавать неизменяемые объекты, что способствует безопасной работе с данными, особенно в многопоточной среде.

🚩Зачем они нужны

Sealed Class используются для определения закрытых иерархий классов, где все потомки известны и ограничены. Они полезны по следующим причинам:

🟠Полное покрытие случаев в `when`
Гарантируют, что все возможные подтипы обработаны в выражениях when, что предотвращает ошибки во время выполнения из-за пропущенных случаев. Это упрощает управление состояниями и делает код более безопасным и предсказуемым.

🟠Ограниченное наследование
Ограничивают возможность создания подклассов за пределами файла, в котором они объявлены. Это предотвращает неожиданное наследование и сохраняет иерархию классов контролируемой и понятной.

🟠Инкапсуляция
Поскольку все расширения таких классов должны быть объявлены в том же файле, это способствует лучшей инкапсуляции и организации кода.

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

Пример Sealed Class

sealed class Result {
    data class Success(val data: String) : Result()
    data class Failure(val error: Throwable) : Result()
}

fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("Success with data: ${result.data}")
        is Result.Failure -> println("Failure with error: ${result.error.message}")
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как изменить поток, в котором будут выполняться операции над излучёнными данными и в котором будут излучаться данные?

В RxJava управление потоками осуществляется через subscribeOn и observeOn. Первый определяет поток, в котором будет происходить генерация данных (источник), второй — поток, в котором обрабатываются все дальнейшие операторы и подписка.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какое событие вызывается при нажатии юзера по экрану?

В Android при нажатии пользователя на экран вызывается событие ACTION_DOWN.

🚩Разбор работы событий касания

Android использует систему обработки касаний через MotionEvent. Когда пользователь касается экрана, система генерирует разные типы событий:
ACTION_DOWN – вызывается в момент первого касания.
ACTION_MOVE – вызывается, когда пользователь двигает палец по экрану.
ACTION_UP – вызывается, когда пользователь убирает палец с экрана.
ACTION_CANCEL – вызывается, если система прерывает касание (например, из-за входящего звонка).

🚩Как обрабатывать нажатие

Для обработки событий касания нужно переопределить метод onTouchEvent() в View или использовать setOnTouchListener().

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
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как будут вести себя LinkedList и ArrayList, если вставить в них элемент?

В LinkedList вставка в начало или середину имеет сложность O(1), так как требуется только обновление ссылок, но доступ к элементу занимает O(n). В ArrayList вставка занимает O(n) из-за необходимости сдвига элементов, но доступ по индексу — O(1).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какой класс можно использовать что бы ловить разные жесты?

Чтобы обрабатывать жесты в Android, используйте класс GestureDetector. Он помогает отслеживать стандартные жесты: одиночные нажатия, свайпы, долгие нажатия, двойные касания и т.д.

🚩Как использовать GestureDetector?

Создайте экземпляр GestureDetector, передав Context и слушателя (GestureDetector.OnGestureListener).
Передавайте события касания в gestureDetector.onTouchEvent(event) из метода onTouchEvent().

class GestureActivity : AppCompatActivity(), GestureDetector.OnGestureListener {
    private lateinit var gestureDetector: GestureDetector

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        gestureDetector = GestureDetector(this, this)
    }

    override fun onTouchEvent(event: MotionEvent): Boolean {
        return gestureDetector.onTouchEvent(event) || super.onTouchEvent(event)
    }

    override fun onFling(e1: MotionEvent?, e2: MotionEvent?, velocityX: Float, velocityY: Float): Boolean {
        val deltaX = e2!!.x - e1!!.x
        if (deltaX > 0) Log.d("Gesture", "Swipe Right") else Log.d("Gesture", "Swipe Left")
        return true
    }

    override fun onDown(e: MotionEvent?) = true
    override fun onShowPress(e: MotionEvent?) {}
    override fun onSingleTapUp(e: MotionEvent?) = false
    override fun onScroll(e1: MotionEvent?, e2: MotionEvent?, distanceX: Float, distanceY: Float) = false
    override fun onLongPress(e: MotionEvent?) {}
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как получить результат от следующей Activity?

1. Используйте метод startActivityForResult:
- Передайте Intent, а затем обработайте результат в методе onActivityResult.
2. В современных API используйте ActivityResultLauncher для управления результатами.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как решить проблему утечек памяти в RxJava?

RxJava может вызывать утечки памяти, если подписки (Disposable) не очищаются правильно.
Утечки памяти происходят, когда RxJava-события продолжают выполняться после уничтожения Activity/Fragment, удерживая ссылки на View или Context.

🚩Используем `CompositeDisposable`

CompositeDisposable собирает все подписки и очищает их при onDestroy().

class MainActivity : AppCompatActivity() {
    private val disposables = CompositeDisposable() // Собираем подписки

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val disposable = Observable.interval(1, TimeUnit.SECONDS)
            .subscribe { println("Tick: $it") }

        disposables.add(disposable) // Добавляем подписку
    }

    override fun onDestroy() {
        super.onDestroy()
        disposables.clear() // ✅ Очищаем подписки, предотвращая утечку памяти
    }
}

🚩Используем `autoDispose` (для Jetpack Lifecycle)

Если используем Jetpack ViewModel или LifecycleOwner, можно автоматически отвязывать подписки.

class MyFragment : Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        Observable.interval(1, TimeUnit.SECONDS)
            .autoDispose(viewLifecycleOwner) // ✅ Автоочистка при `onDestroyView()`
            .subscribe { println("Tick: $it") }
    }
}

🚩Используем `Disposable.dispose()` вручную

Если подписка не в CompositeDisposable, её можно очистить вручную.

private var disposable: Disposable? = null

fun startObserving() {
    disposable = Observable.interval(1, TimeUnit.SECONDS)
        .subscribe { println("Tick: $it") }
}

fun stopObserving() {
    disposable?.dispose() // ✅ Очищаем подписку
}

🚩Используем `ViewModel` + `LiveData` вместо RxJava

RxJava может удерживать Activity/Fragment, вызывая утечки памяти.
Лучше использовать ViewModel + LiveData!

class MyViewModel : ViewModel() {
    private val _timer = MutableLiveData<Long>()
    val timer: LiveData<Long> = _timer

    init {
        Observable.interval(1, TimeUnit.SECONDS)
            .subscribe { _timer.postValue(it) }
    }
}

Подписка в Activity (без утечек!)

viewModel.timer.observe(this) { println("Tick: $it") }

Ставь 👍 и забирай 📚 Базу знаний

🤔 Можно ли отправить своё broadcast-сообщение?

Да. Можно использовать:
- sendBroadcast(Intent) — для обычной широковещательной рассылки.
- sendOrderedBroadcast() — для последовательной доставки.
- LocalBroadcastManager (устарел, но можно использовать аналоги).
Это позволяет передавать события между компонентами приложения или уведомлять другие приложения (если экспортировано).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как в Ретрофите добавить возможность возвращать типы Rxjava?

Чтобы Retrofit мог возвращать Observable, Single, Maybe или Flowable из RxJava, нужно добавить RxJava Adapter.

🚩Добавление зависимости

В build.gradle.kts (Kotlin DSL)

dependencies {
    implementation("com.squareup.retrofit2:adapter-rxjava3:2.9.0") // Адаптер для RxJava 3
    implementation("io.reactivex.rxjava3:rxjava:3.1.8") // RxJava 3
}

🚩Подключение `RxJava3CallAdapterFactory`

Добавляем адаптер в Retrofit.Builder

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create()) // Преобразование JSON
    .addCallAdapterFactory(RxJava3CallAdapterFactory.create()) // Поддержка RxJava
    .build()

🚩Использование RxJava в API

Теперь можно возвращать RxJava-объекты вместо Call<>.

interface ApiService {
    @GET("users/{id}")
    fun getUser(@Path("id") userId: Int): Single<User>
}

Пример с Observable<> (несколько данных или обновления)

interface ApiService {
    @GET("users")
    fun getUsers(): Observable<List<User>>
}

Пример с Flowable<> (если нужен Backpressure)

interface ApiService {
    @GET("posts")
    fun getPosts(): Flowable<List<Post>>
}

🚩Подписка и обработка результата

Пример подписки в ViewModel (RxJava 3 + LiveData)

class UserViewModel(private val apiService: ApiService) : ViewModel() {

    private val _userLiveData = MutableLiveData<User>()
    val userLiveData: LiveData<User> = _userLiveData

    fun fetchUser(userId: Int) {
        apiService.getUser(userId)
            .subscribeOn(Schedulers.io())  // Запрос в фоновом потоке
            .observeOn(AndroidSchedulers.mainThread()) // Обновление UI в главном потоке
            .subscribe({ user ->
                _userLiveData.value = user
            }, { error ->
                Log.e("UserViewModel", "Ошибка загрузки", error)
            })
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔Какие сущности описываются в Manifest?

В Android Manifest файле описываются основные компоненты приложения, такие как активности, службы (сервисы), приемники широковещательных сообщений (broadcast receivers) и провайдеры контента. Также в нем указываются разрешения, которые требуются приложению, а также минимальная и целевая версии платформы Android.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как добавить кастомные атрибуты у кастомного view?

Чтобы добавить кастомные атрибуты в Custom View, нужно:
Создать attrs.xml и описать атрибуты.
Добавить их в styleable и получить в Custom View.
Использовать атрибуты в XML или Kotlin.

🟠Создаём `attrs.xml`
Создаём файл res/values/attrs.xml, если его нет:

<resources>
    <declare-styleable name="CustomButton">
        <attr name="customText" format="string"/>
        <attr name="customTextSize" format="dimension"/>
        <attr name="customTextColor" format="color"/>
    </declare-styleable>
</resources>

🟠Создаём `Custom View` и получаем атрибуты
Теперь создаём CustomButton.kt

class CustomButton @JvmOverloads constructor(
    context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
) : AppCompatButton(context, attrs, defStyleAttr) {

    init {
        context.theme.obtainStyledAttributes(attrs, R.styleable.CustomButton, 0, 0).apply {
            try {
                val text = getString(R.styleable.CustomButton_customText) ?: "Default"
                val textSize = getDimension(R.styleable.CustomButton_customTextSize, 16f)
                val textColor = getColor(R.styleable.CustomButton_customTextColor, Color.BLACK)

                setText(text)
                setTextSize(TypedValue.COMPLEX_UNIT_PX, textSize)
                setTextColor(textColor)
            } finally {
                recycle() // Освобождаем ресурсы
            }
        }
    }
}

🟠Используем `Custom View` в XML
Теперь можно использовать CustomButton в activity_main.xml

<com.example.customviews.CustomButton
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:customText="Нажми меня"
    app:customTextSize="20sp"
    app:customTextColor="@android:color/holo_red_dark"/>

🟠Как изменить атрибуты в коде?
Можно обновлять свойства прямо в Kotlin

val button = findViewById<CustomButton>(R.id.customButton)
button.text = "Новый текст"
button.setTextSize(TypedValue.COMPLEX_UNIT_SP, 24f)
button.setTextColor(Color.BLUE)

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что известно про кейс, когда произошёл факап?

Факап — это ситуация, когда задача провалилась из-за недосмотра, неправильных ожиданий или отсутствия проверки. Часто бывает при ошибочной миграции, неправильной работе с API или при недокументированном поведении Android.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как бы реализовал агрегацию на устройстве нескольких rss лент?

Если нужно собирать данные из нескольких RSS-источников, можно реализовать это так:

Загрузить данные из нескольких RSS-лент (через Retrofit, Jsoup, XmlPullParser).
Парсить XML и извлекать статьи.
Объединять данные в общий список (List<Article>).
Сортировать по дате.
Сохранять в БД (Room) для офлайн-доступа.
Показывать в RecyclerView или LazyColumn (Compose).

🚩Добавляем зависимости

В build.gradle.kts

dependencies {
    implementation("com.squareup.retrofit2:retrofit:2.9.0") // HTTP-клиент
    implementation("com.squareup.retrofit2:converter-simplexml:2.9.0") // XML-парсер
    implementation("org.jsoup:jsoup:1.16.1") // Альтернативный XML-парсер
    implementation("androidx.room:room-runtime:2.6.1") // Room для кеша
    kapt("androidx.room:room-compiler:2.6.1")
}

🚩Описываем модель данных (RSS-статья)

RSS-лента содержит заголовок, ссылку, дату и описание

@Root(name = "item", strict = false)
data class RssItem(
    @field:Element(name = "title") var title: String = "",
    @field:Element(name = "link") var link: String = "",
    @field:Element(name = "pubDate", required = false) var pubDate: String = "",
    @field:Element(name = "description", required = false) var description: String = ""
)

Создаём API для загрузки RSS (Retrofit + XML)

interface RssService {
    @GET("rss.xml")
    fun getFeed(): Call<RssFeed>
}

@Root(name = "rss", strict = false)
data class RssFeed(
    @field:Element(name = "channel") var channel: RssChannel = RssChannel()
)

@Root(name = "channel", strict = false)
data class RssChannel(
    @field:ElementList(entry = "item", inline = true) var items: List<RssItem> = listOf()
)

🚩Объединяем несколько RSS-лент

Создадим Repository, который загружает и объединяет данные:

class RssRepository(private val services: List<RssService>) {

    fun fetchAllFeeds(): List<RssItem> {
        val allItems = mutableListOf<RssItem>()

        services.forEach { service ->
            val response = service.getFeed().execute()
            if (response.isSuccessful) {
                response.body()?.channel?.items?.let { allItems.addAll(it) }
            }
        }

        return allItems.sortedByDescending { parseDate(it.pubDate) }
    }

    private fun parseDate(dateString: String): Long {
        return SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss Z", Locale.ENGLISH)
            .parse(dateString)?.time ?: 0
    }
}

🚩Сохраняем в Room для офлайн-доступа

Создаём Entity для БД

@Entity
data class ArticleEntity(
    @PrimaryKey val link: String,
    val title: String,
    val pubDate: Long,
    val description: String
)

Создаём DAO

@Dao
interface RssDao {
    @Query("SELECT * FROM ArticleEntity ORDER BY pubDate DESC")
    fun getArticles(): LiveData<List<ArticleEntity>>

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertArticles(articles: List<ArticleEntity>)
}

Сохраняем в БД после загрузки

class RssRepository(private val dao: RssDao, private val services: List<RssService>) {

    fun fetchAndCacheFeeds() {
        val articles = fetchAllFeeds().map {
            ArticleEntity(it.link, it.title, parseDate(it.pubDate), it.description)
        }
        dao.insertArticles(articles)
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Расскажи про data классы и sealed классы

Data-классы в Kotlin предназначены для хранения данных и автоматически создают полезные методы, такие как `equals()`, `hashCode()`, `toString()`, а также методы для копирования объектов. Они удобны для представления сущностей с полями, которые нужно сравнивать, копировать или выводить, например, записи в базе данных. Sealed-классы (запечатанные классы) ограничивают наследование, позволяя создавать иерархии с фиксированным набором подклассов, что полезно для работы с типами, набор которых известен на этапе компиляции.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Через какой класс вызываются методы get, replace?

Методы get и replace в Kotlin относятся к работе с коллекциями, карты (Map) или к строкам. В зависимости от контекста, они вызываются через разные классы. Давайте разберем каждый случай отдельно.

🟠Методы `get` и `replace` для коллекций (`Map`)
В контексте работы с картами (Map), методы get и replace относятся к получению значений по ключу и замене существующих значений.
Метод get
Метод get используется для извлечения значения из карты по указанному ключу.

val map = mapOf("key1" to "value1", "key2" to "value2")
println(map.get("key1")) // value1
println(map["key2"])     // value2 (альтернатива `get`)

Метод replace используется для обновления значения, связанного с определённым ключом, если он существует. Этот метод доступен только для изменяемых карт (MutableMap).

val mutableMap = mutableMapOf("key1" to "value1", "key2" to "value2")
mutableMap.replace("key1", "newValue1")
println(mutableMap) // {key1=newValue1, key2=value2}

🟠Методы `get` и `replace` для строк
В контексте строк, методы get и replace работают с символами и подстроками.
Метод get используется для доступа к символу строки по индексу. Это альтернатива квадратным скобкам.

val text = "Kotlin"
println(text.get(0))  // K
println(text[1])      // o (альтернатива `get`)

Метод replace заменяет символы или подстроки в строке на заданные.

val text = "Kotlin is awesome"
val newText = text.replace("awesome", "powerful")
println(newText) // Kotlin is powerful

🟠Глобальные методы `get` и `replace` через пользовательские классы
Если вы пишете свои классы, вы можете переопределить оператор get и метод replace, чтобы использовать их для своих нужд.

class CustomList<T>(private val items: List<T>) {
    operator fun get(index: Int): T {
        return items[index]
    }
}

fun main() {
    val customList = CustomList(listOf(1, 2, 3))
    println(customList[0]) // 1
}

Пример с replace

class CustomMap<K, V>(private val map: MutableMap<K, V>) {
    fun replace(key: K, value: V) {
        if (map.containsKey(key)) {
            map[key] = value
        }
    }
}

fun main() {
    val customMap = CustomMap(mutableMapOf("key1" to "value1"))
    customMap.replace("key1", "newValue1")
    println(customMap) // {key1=newValue1}
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чём различия наследования, композиции, агрегации?

Наследование предполагает создание нового класса на основе существующего. Композиция включает один класс в качестве части другого для использования его функциональности. Агрегация — слабая форма композиции, где включённый объект может существовать независимо от владельца.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Вставка значения быстрее в Linked list или в Array list?

🚩Вставка в `ArrayList`

ArrayList реализован на основе массива.

🟠Вставка в конец
Амортизированное O(1). Если массив не заполнен, элемент добавляется в конец списка. В случае, если массив заполнен, требуется выделение нового массива и копирование элементов, что занимает O(n) времени.

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

🟠Вставка в начало или середину
O(n). Необходимо сдвинуть все элементы, начиная с позиции вставки, чтобы освободить место для нового элемента. Это требует времени, пропорционального количеству элементов после позиции вставки.

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

🚩Вставка в LinkedList

LinkedList реализован на основе узлов, где каждый узел содержит ссылку на следующий и/или предыдущий узел (в случае двусвязного списка).

🟠Вставка в начало: O(1). Для добавления элемента в начало достаточно изменить ссылки первого узла и нового узла.

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

🟠Вставка в конец
O(1) (если есть ссылка на последний узел) или O(n) (если необходимо пройти весь список). Если список двусвязный и хранится ссылка на последний элемент, вставка в конец осуществляется за O(1). В противном случае, требуется пройти весь список до конца.

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

🟠Вставка в середину
O(n). Необходимо пройти список до нужной позиции и изменить ссылки узлов.

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

Ставь 👍 и забирай 📚 Базу знаний