Как добавить элемент в массив java

Учитывая массив размера n, задача состоит в том, чтобы добавить элемент x в этот массив в Java.

Размер массива нельзя динамически изменять в Java, как это делается в C / C ++. Следовательно, чтобы добавить элемент в массив, можно сделать один из следующих методов:

  1. Создав новый массив:
    • Создайте новый массив размером n + 1, где n — размер исходного массива.
    • Добавьте n элементов исходного массива в этот массив.
    • Добавьте новый элемент в позицию n + 1.
    • Распечатать новый массив.

Массив (англ. array) представляет собой мощный инструмент, позволяющий работать с большим количеством данных. Очевидно, что если вам в процессе работы вашего кода где-то нужно сохранить, к примеру, 100 значений, то делать для этого такое же количество переменных как минимум неразумно. Массив позволяет хранить большое количество значений под одним именем и обращаться к ним по соответствующему индексу. Понятие массивов является краеугольным камнем в изучении курса Java для начинающих. Ведь они являются основой для многих структур данных.

Поскольку Java это, прежде всего, ООП, по сравнению с массивами в других языках программирования java array имеет одну отличительную особенность – они представляются в виде объектов. Помимо прочих преимуществ, это избавляет от нужды следить за очисткой памяти, поскольку она освобождается автоматически.

Создание и манипуляции одномерными массивами

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

Вначале объявляется тип Java array, который определяет тип значений, хранящихся в нем. Это может быть любой допустимый в Java тип данных. Далее идут имя массива и квадратные скобки, сообщающие компилятору, что данная переменная является массивом. Обратите внимание на важный факт. Квадратные скобки можно ставить как после базового типа массива, так и после имени массива. После знака равенства указывается оператор new, инициирующий выделение памяти под массив (так же, как и в случае с объектами), тип элементов, которые будут храниться в нем (должен быть совместим с базовым типом, объявленным ранее), и, наконец, их количество, указанное в квадратных скобках.

Нумерация элементов в Java array начинается с 0. Так, индекс первого элемента в данном массиве будет равен 0, а шестого – 5. Чтобы обратиться к конкретному элементу массива, например, пятому, достаточно указать имя массива и индекс элемента в квадратных скобках рядом с именем. Таким образом можно как присваивать значение элементу, так и извлекать его. Однако следует быть внимательным, поскольку если передать индекс, по которому не существует элемента, то возникнет ошибка.

Многомерные массивы в Java

Многомерные массивы представляют собой ряды одномерных, на которые ссылаются элементы других массивов. Иными словами, это массивы массивов. Наиболее простыми среди них являются двумерные. На их примере мы и попытаемся разобраться с понятием. Для наглядности на рисунке ниже приведены синтаксис и схема, описывающая структуру двумерного массива.

Как видим, синтаксис не особо отличается от одномерных массивов. Давайте разберем структуру. В первых скобках мы выделили место под 5 элементов. Эти элементы являются ничем иным как ссылками на отдельные массивы. При этом размер каждого из них определен числом во вторых скобках. По сути, аналогом двумерных массивов в математике являются матрицы. Обратите внимание, что помимо элементов, в памяти выделяется отдельное место, где хранится значение длины массива (length). Как правило, работа с многомерными массивами осуществляется посредством вложенных циклов for.

Нерегулярные массивы

Двумерный массив является массивом массивов. Это мы уже выяснили. Но могут ли массивы, содержащиеся в нем, иметь разную длину? Ответ – да, могут. Для этого в Java предусмотрена возможность объявлять двумерный массив специальным образом. К примеру, мы хотим создать двумерный массив, который хранил бы в себе три одномерных массива длиной 2, 3 и 4 соответственно. Объявляется он следующим образом:

Обратите внимание, что мы не указали число во вторых скобках. Определение размера массивов в arr делается так:

Обращаясь к элементу под индексом 0, указывающему на первый массив, мы объявляем его с размерностью 2. Под элементом с индексом 1 будет храниться массив размерностью 3, и так далее. Все довольно просто.

Альтернативный синтаксис объявления java array

Инициализировать массивы можно и непосредственно при их создании. Это довольно просто.

Обратите внимание на объявление массивов jerseyNumber и playerName.

В случае с двумерными массивами данное объявление выглядит так:

Для этого вместо оператора new открываются фигурные скобки, в которых через запятую идет перечисление всех элементов. Java в этом случае автоматически выделяет память под них и индексирует их соответствующим образом.

Вспомогательный класс Arrays

Для работы с такими сущностями, как массивы в Java, в пакете java.util имеется специальный класс Arrays, который предоставляет множество статических методов, значительно облегчающих операции с ними. Перечень основных методов представлен на рисунке ниже.

Разберем некоторые самые полезные Java array методы:

— copyOf (массив, длина) – возвращает копию переданного массива соответствующей длины. Если переданная длина больше оригинального массива, то все «лишние» элементы заполняются значением по умолчанию (0, если простой тип, и null , если ссылочный).

— copyOfRange (массив, первый индекс, последний индекс) – не указанный на рисунке, но полезный метод. Он копирует часть переданного массива, определенную соответствующими индексами, начиная с первого и заканчивая последним.

— sort (массив) – сортирует элементы массива по возрастанию.

— fill (массив, значение) – заполняет переданный массив соответствующим значением.

— binarySearch (массив, значение) – возвращает индекс, под которым элемент с соответствующим значением находится в переданном отсортированном массиве. Если же такой элемент отсутствует, то возвращается отрицательное число.

Поскольку методы статические, то для их вызова не требуется создавать экземпляр класса Arrays. Они вызываются напрямую из него: Arrays.sort(arr).

Заключение

Мы рассмотрели наиболее важные аспекты относительно массивов, и для тех, кто только приступает к изучению Java для начинающих, этого хватит для базового понимания такой сущности, как массив, и основных приемов работы с ним. Конечно, практика даст больше понимания работы данного инструмента. Поэтом не поленитесь сделать несколько упражнений, манипулируя массивами различными способами.

Вспомогательный класс Array Java используется уже в «боевых» условиях, поэтому для начала рекомендуется учиться производить все основные операции с массивами вручную.

Мне нужно добавить элементы в ArrayList очередь что угодно, но когда я вызываю функцию, чтобы добавить элемент, я хочу, чтобы он добавил элемент в начале массива (так что он имеет самый низкий индекс), и если массив имеет 10 элементов, добавляющих новые результаты в удалении самого старого элемента (тот, у которого самый высокий индекс).

есть ли у кого-нибудь предложения?

12 ответов:

List имеет способ add(int, E) , так что вы можете использовать:

после этого вы можете удалить последний элемент, с:

тем не менее, вы можете пересмотреть свои требования или использовать другую структуру данных, например Queue

EDIT

может быть, взгляните на Apache CircularFifoQueue :

CircularFifoQueue -это в первую очередь с фиксированный размер, который заменяет его самый старый элемент, если он заполнен.

просто инициализировать его с вами максимальный размер:

Использование Конкретных Структур

существуют различные структуры данных, которые оптимизированы для добавления элементов в первого индекса. Однако имейте в виду, что если вы преобразуете свою коллекцию в одну из них, разговор, вероятно, потребует временной и пространственной сложности O(n)

Deque

JDK включает в себя Deque структура, которая предлагает такие методы, как addFirst(e) и offerFirst(e)

анализ

пространственно-временная сложность вставки с LinkedList константа ( O(1) ). Смотрите Big-O cheatsheet.

реверсирование списка

очень простой, но неэффективный метод заключается в использовании обратного:

если вы используете потоки Java 8, этот ответ может вас заинтересовать.

анализ

  • Сложность : O(n)
  • Космос Сложность: O(1)

вы можете взглянуть на добавить (индекс int, элемент E):

вставляет указанный элемент в указанную позицию в этом списке. Смещает элемент в настоящее время в этом положении (если есть) и все последующие элементы справа (добавляет один к их индексам).

после добавления вы можете проверить размер ArrayList и удалить те, в конце.

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

то, что вы описываете, является подходящей ситуацией для использования Queue .

так как вы хотите add новый элемент, а remove старый. Вы можете добавить в конце, и удалить с самого начала. Это не будет иметь большого значения.

очередь имеет методы add(e) и remove() который добавляет в конце новый элемент, и удаляет из начала старый элемент, соответственно.

Итак, каждый раз, когда вы добавить элемент для queue вы можете создать резервную копию с remove вызов метода.

обновление: —

и если вы хотите чтобы исправить размер Queue , то вы можете взглянуть на: — ApacheCommons#CircularFifoBuffer

С documentation : —

CircularFifoBuffer является первым в первом из буфера с фиксированным размером это заменяет его самый старый элемент, если полный.

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

Я думаю, что реализация должна быть простой, но учитывая эффективность, Вы должны использовать LinkedList, но не ArrayList в качестве контейнера. Вы можете обратиться к следующему коду:

Java LinkedList предоставляет как метод addFirst(E e), так и метод push (E e), который добавляет элемент в начало списка.

https://docs.oracle.com/javase/7/docs/api/java/util/LinkedList.html#addFirst(E)

вы можете использовать этот код

можно использовать

изменить E с вашим типом данных

Если удаление самого старого элемента необходимо, то вы можете добавить:

перед оператором возврата. В противном случае список добавит ваш объект в начале, а также сохранит самый старый элемент.

это приведет к удалению последнего элемента в списке.

вы можете использовать методы списка, удалить и добавить

У меня была аналогичная проблема, пытаясь добавить элемент в начале существующего массива, сдвинуть существующие элементы вправо и отбросить самый старый (array[length-1]). Мое решение может быть не очень эффективным, но оно работает для моих целей.

удачи

Регистрация на форуме тут, о проблемах пишите сюда — [email protected], проверяйте папку спам! Обязательно пройдите восстановить пароль

Поиск по форуму
Расширенный поиск
К странице.

Всем привет, подскажите , пожалуйста, почему при добавлении в массив нового элемента на определенную позицию последующие исчезают или обнуляются? Я создаю свой вектор, который имеет все методы обычного вектора, но нужно их реализовать через массив.

Массивы | Collections | Scala Documentation

Info: JavaScript is currently disabled, code tabs will still work, but preferences will not be remembered.

Массивы особый вид коллекций в Scala. С одной стороны, Scala массивы соответствуют массивам из Java. Например, Scala массив Array[Int] реализован в виде Java int[], а Array[Double] как Java double[] и Array[String] как Java String[] С другой стороны, Scala массивы дают намного больше чем их Java аналоги. Во-первых Scala массивы могут быть обобщены (generic). То есть вы можете описать массив как Array[T], где T дополнительный параметр-тип массива или же абстрактный тип. Во-вторых, Scala массивы совместимы со списками (Seq

) Scala — вы можете передавать Array[T] на вход туда, где требуется Seq[T]. Ну и наконец, Scala массивы также поддерживают все операции, которые есть у списков. Вот пример:

scala> val a1 = Array(1, 2, 3)
a1: Array[Int] = Array(1, 2, 3)
scala> val a2 = a1 map (_ * 3)
a2: Array[Int] = Array(3, 6, 9)
scala> val a3 = a2 filter (_ % 2 != 0)
a3: Array[Int] = Array(3, 9)
scala> a3.reverse
res0: Array[Int] = Array(9, 3)

Учитывая то что Scala массивы соответствуют массивам из Java, каким же образом реализованы остальные дополнительные возможности массивов в Scala? Реализация массивов в Scala постоянно использует неявные преобразования. В Scala массив не пытается притворяться

последовательностью. Он и не может, потому что тип данных лежащий в основе массива не является подтипом Seq. Вместо этого, используя “упаковывание”, происходит неявное преобразование между массивами и экземплярами класса scala. collection.mutable.ArraySeq, который является подклассом Seq. Вот как это работает:

scala> val seq: collection.Seq[Int] = a1
seq: scala.collection.Seq[Int] = ArraySeq(1, 2, 3)
scala> val a4: Array[Int] = seq.toArray
a4: Array[Int] = Array(1, 2, 3)
scala> a1 eq a4
res1: Boolean = false

Пример выше показывает, что массивы совместимы с последовательностями, потому как происходит неявное преобразование из массивов в

ArraySeqы. Чтобы перейти обратно от ArraySeq к Array, можно использовать метод toArray, описанный в Iterable. Последняя строка в консоле показывает, что упаковка и затем распаковка с помощью toArray создает копию исходного массива.

Существует еще одно неявное преобразование, которое применяется к массивам. Такое преобразование просто “добавляет” все методы последовательностей (Seq) к массивам, но не превращает сам массив в последовательность.

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

Разница между двумя неявными преобразованиями на массивах показана в следующем примере:

scala> val seq: collection.Seq[Int] = a1
seq: scala.collection.Seq[Int] = ArraySeq(1, 2, 3)
scala> seq.reverse
res2: scala.collection.Seq[Int] = ArraySeq(3, 2, 1)
scala> val ops: collection.ArrayOps[Int] = a1
ops: scala.collection.ArrayOps[Int] = scala.collection.ArrayOps@2d7df55
scala> ops.reverse
res3: Array[Int] = Array(3, 2, 1)

Вы видите, что вызов reverse на seq, который является ArraySeq, даст снова ArraySeq. Это логично, потому что массивы — это Seqs, и вызов reverse на любом Seq даст снова Seq. С другой стороны, вызов reverse на экземпляре класса ArrayOps даст значение Array, а не Seq.

Пример ArrayOps, приведенный выше искусственный и используется лишь, чтоб показать разницу с

ArraySeq. Обычно, вы никогда не создаете экземпляры класса ArrayOps. Вы просто вызываете методы Seq на массиве:

scala> a1.reverse
res4: Array[Int] = Array(3, 2, 1)

Объект ArrayOps автоматически вставляется через неявное преобразование. Так что строка выше эквивалентна

scala> intArrayOps(a1).reverse
res5: Array[Int] = Array(3, 2, 1)

где intArrayOps — неявное преобразование, которое было вставлено ранее. В связи с этим возникает вопрос, как компилятор выбрал intArrayOps вместо другого неявного преобразования в ArraySeq в строке выше. В конце концов, оба преобразования преобразуют массив в тип, поддерживающий метод reverse.

Ответ на этот вопрос заключается в том, что два неявных преобразования имеют приоритет. Преобразование ArrayOps имеет больший приоритет, чем преобразование ArraySeq. Первый определяется в объекте Predef, а второй — в классе scala.LowPriorityImplicits, который Predef наследует. Неявные преобразования в дочерних классах и дочерних объектах имеют более высокий приоритет над преобразованиями в базовых классах. Таким образом, если оба преобразования применимы, выбирается вариант в
Predef. Очень похожая схема используется для строк.

Итак, теперь вы знаете, как массивы могут быть совместимы с последовательностями и как они могут поддерживать все операции последовательностей. А как же обобщения? В Java нельзя написать T[], где T является параметром типа. Как же представлен Scala Array[T]? На самом деле обобщенный массив типа Array[T] может быть любым из восьми примитивных типов массивов Java byte[], short[], char[], int[] , long[] , float[], double или может быть массивом объектов.

Единственным общим типом, включающим все эти типы, является AnyRef (или, равнозначно java.lang.Object), так что это тот тип в который компилятор Scala отобразит Array[T]. Во время исполнения, при обращении к элементу массива типа Array[T], происходит последовательность проверок типов, которые определяют тип массива, за которыми следует подходящая операция на Java-массиве. Эти проверки типов замедляют работу массивов. Можно ожидать падения скорости доступа к обобщенным массивам в три-четыре раза, по сравнению с обычными массивами или массивами объектов. Это означает, что если вам нужна максимальная производительность, вам следует выбирать конкретные массивы, вместо обобщенных. Отображать обобщенный массив еще пол беды, нам нужен еще способ создания обобщенных массивов. Это куда более сложная задача, которая требует, от вас, небольшой помощи. Чтобы проиллюстрировать проблему, рассмотрим следующую попытку написания обобщенного метода, который создает массив.

// это неправильно!
def evenElems[T](xs: Vector[T]): Array[T] = {
  val arr = new Array[T]((xs.length + 1) / 2)
  for (i <- 0 until xs.length by 2)
    arr(i / 2) = xs(i)
  arr
}

Метод

evenElems возвращает новый массив, состоящий из всех элементов аргумента вектора xs, находящихся в четных позициях вектора. В первой строке тела evenElems создается результирующий массив, который имеет тот же тип элемента, что и аргумент. Так что в зависимости от фактического типа параметра для T, это может быть Array[Int], или Array[Boolean], или массив некоторых других примитивных типов Java, или массив какого-нибудь ссылочного типа. Но эти типы имеют разные представления при исполнении программы, и как же Scala подберет правильное представление? В действительности, Scala не может сделать этого, основываясь на предоставленной информации, так как при выполнении стирается фактический тип, соответствующий параметру типа
T.

Тут нужно немного помочь компилятору, указав какой в действительности тип параметра evenElems. Это указание во время исполнения принимает форму манифеста класса типа scala.view.ClassTag. Манифест класса — это объект дескриптор типа, который описывает, какой тип у класса верхнего уровня. В качестве альтернативы манифестам классов существуют также полные манифесты типа scala.Refect.Manifest, которые описывают все аспекты типа. Впрочем для создания массива требуются только

манифесты класса.

Компилятор Scala автоматически создаст манифесты классов, если вы проинструктируете его на это. “Инструктирование” означает, что вы требуете манифест класса в качестве неявного параметра, как в примере:

def evenElems[T](xs: Vector[T])(implicit m: ClassTag[T]): Array[T] = ...

Используя альтернативный и более короткий синтаксис, вы также можете потребовать, чтобы тип приходил с манифестом класса, используя контекстное связывание (context bound). Это означает установить связь с типом ClassTag идущим после двоеточия в описании типа, как в примере:

import scala.reflect.ClassTag
// так будет работать
def evenElems[T: ClassTag](xs: Vector[T]): Array[T] = {
  val arr = new Array[T]((xs.length + 1) / 2)
  for (i <- 0 until xs.length by 2)
    arr(i / 2) = xs(i)
  arr
}

Обе показанные версии evenElems означают одно и то же. Что бы не случилось, когда построен Array[T], компилятор будет искать манифест класса для параметра типа T, то есть искать неявное значение (implicit value) типа ClassTag[T]. Если такое значение найдено, то этот манифест будет использоваться для построения требуемого типа массива. В противном случае вы увидите сообщение об ошибке, такое же как мы показывали выше.

Вот некоторые примеры из консоли, использующие метод evenElems.

scala> evenElems(Vector(1, 2, 3, 4, 5))
res6: Array[Int] = Array(1, 3, 5)
scala> evenElems(Vector("this", "is", "a", "test", "run"))
res7: Array[java.  В данном случае `evenElems` требует наличия класса манифеста для параметра типа `U`, однако ни одного не найдено. Чтоб решить такую проблему, конечно, необходимо запросить манифест от неявного класса `U`. Поэтому следующее будет работать:
scala> def wrap[U: ClassTag](xs: Vector[U]) = evenElems(xs)
wrap: [U](xs: Vector[U])(implicit evidence$1: scala.reflect.ClassTag[U])Array[U]

Этот пример также показывает, что контекстное связывание с U, является лишь сокращением для неявного параметра, названного здесь evidence$1 типа ClassTag[U].

Подводя итог, можно сказать, что для создания обобщенных массивов требуются манифесты классов. Поэтому при создании массива параметризированного типом T, вам также необходимо предоставить неявный класс манифест для T. Самый простой способ сделать это — объявить параметр типа ClassTag с контекстной привязкой, как [T: ClassTag].

404: Страница не найдена

Страница, которую вы пытались открыть по этому адресу, похоже, не существует. Обычно это результат плохой или устаревшей ссылки. Мы извиняемся за любые неудобства.

Что я могу сделать сейчас?

Если вы впервые посещаете TechTarget, добро пожаловать! Извините за обстоятельства, при которых мы встречаемся. Вот куда вы можете пойти отсюда:

Поиск
  • Узнайте последние новости.
  • Наша домашняя страница содержит самую свежую информацию о Java-разработке.
  • Наша страница «О нас» содержит дополнительную информацию о сайте, на котором вы находитесь, TheServerSide.com.
  • Если вам нужно, свяжитесь с нами, мы будем рады услышать от вас.

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

Архитектура приложения

  • Необработанный, но растущий потенциал банковского обслуживания без ядра

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

  • Основы достижения высокой сплоченности и низкой связанности

    Легко сказать «высокая сплоченность, низкая связанность», но так ли легко это реализовать на практике? Мы рассмотрим некоторые основы…

  • Как обнаружить и контролировать распространение теневых API

    Теперь, когда проникновение через API стало излюбленным методом хакеров, ИТ-специалистам необходимо предпринять дополнительные шаги для защиты этих…

Качество ПО

  • Тестовые фреймворки и примеры для модульного тестирования кода Python

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

  • Атрибуты эффективной стратегии тестирования базы данных

    Команды должны внедрить правильную стратегию тестирования базы данных для оптимизации результатов. Изучите эффективные атрибуты тестирования базы данных…

  • Обновления Java 20 Project Loom готовят почву для Java LTS

    Java 20 повторно инкубирует две функции масштабируемости Project Loom, что делает их главными кандидатами на то, чтобы стать стандартом в сентябрьском выпуске Java …

Облачные вычисления

  • Подходит ли вам облачная стратегия?

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

  • Как использовать сценарии запуска в Google Cloud

    Google Cloud позволяет использовать сценарии запуска при загрузке виртуальных машин для повышения безопасности и надежности. Выполните следующие действия, чтобы создать свой…

  • Когда использовать AWS Compute Optimizer и Cost Explorer

    AWS Compute Optimizer и Cost Explorer отслеживают, анализируют и оптимизируют затраты на облако. Сравните два инструмента, чтобы выбрать, какой из них …

Безопасность

  • Microsoft запускает Security Copilot на базе искусственного интеллекта

    Microsoft Security Copilot — это помощник на основе искусственного интеллекта для специалистов по информационной безопасности, который сочетает в себе технологию OpenAI GPT-4 с программным…

  • Публично раскрытые атаки программ-вымогателей в США в 2023 году

    База данных программ-вымогателей TechTarget Editorial собирает общедоступные раскрытия информации, уведомления и подтвержденные отчеты об атаках на …

  • Сравните моделирование взлома и атаки с тестированием на проникновение

    Подробное изучение нарушений и имитации атак по сравнению с тестированием на проникновение показывает, что оба инструмента предотвращают нарушения периметра и данных. Найти …

ПоискAWS

  • AWS Control Tower стремится упростить управление несколькими учетными записями

    Многие организации изо всех сил пытаются управлять своей огромной коллекцией учетных записей AWS, но Control Tower может помочь. Услуга автоматизирует…

  • Разбираем модель ценообразования Amazon EKS

    В модели ценообразования Amazon EKS есть несколько важных переменных. Покопайтесь в цифрах, чтобы убедиться, что вы развернули службу…

  • Сравните EKS и самоуправляемый Kubernetes на AWS Пользователи

    AWS сталкиваются с выбором при развертывании Kubernetes: запустить его самостоятельно на EC2 или позволить Amazon выполнить тяжелую работу с помощью EKS. См…

Как добавить элементы в список в Scala (List, ListBuffer)

Scala List FAQ: Как добавить элементы в список Scala ?

На самом деле вопрос с подвохом, потому что вы не может добавлять элементы в список Scala; это неизменяемая структура данных, такая как Java String .

Добавление элементов в списки Scala

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

scala>  val p1 = Список("Ким") 
p1: Список[Строка] = Список(Ким)

scala>  val p2 = "Юлия" :: p1 
p2: Список[Строка] = Список(Юлия, Ким)

scala>  val p3 = "Юди" :: p2 
p3: Список[Строка] = Список(Джуди, Джулия, Ким)

В этих примерах показано, как создать серию списков. Первоначальный список с именем p1 содержит одну строку, затем p2 содержит две строки и, наконец, p3 содержит три строки. Предварительное добавление элементов — это именно то, как Scala Список класса предназначен для использования.

Хотя этот подход выглядит громоздким в небольшом примере, он имеет смысл в более крупном реальном коде. Вы можете увидеть больше/лучшие примеры этого подхода в моем руководстве, Примеры классов Scala List.

Используйте ListBuffer, когда вам нужен «список», который вы можете изменить

Если вы хотите использовать последовательность Scala, которая имеет многие характеристики списка , а также является изменяемой — т. е. вы можете добавлять и удалять элементы в это — правильный подход состоит в том, чтобы вместо этого использовать класс Scala ListBuffer, например:

импортировать scala.collection.mutable.ListBuffer

var fruit = новый ListBuffer[String]()
фрукты += "яблоко"
фрукты += "Банан"
фрукты += "Апельсин"

Затем преобразуйте его в список , если/когда вам нужно:

val FruitList = фрукты.toList

Пример Scala REPL

Вот как выглядит этот пример List и ListBuffer с использованием командной строки Scala (REPL):

скала >  импорт scala.collection.mutable.ListBuffer 
импортировать scala.collection.mutable.ListBuffer

scala>  var fruit = новый ListBuffer[String]() 
фрукты: scala.collection.mutable.ListBuffer[String] = ListBuffer()

scala>  фрукты += "Яблоко" 
res0: scala.collection.mutable.ListBuffer[String] = ListBuffer(Apple)

scala>  фрукты += "Банан" 
res1: scala. collection.mutable.ListBuffer[String] = ListBuffer(Apple, Banana)

скала >  фрукты += "Апельсин" 
res2: scala.collection.mutable.ListBuffer[String] = ListBuffer(Apple, Banana, Orange)

scala>  val FruitList = Fruit.toList 
FruitList: Список[Строка] = Список(Яблоко, Банан, Апельсин)

Примечание. В зависимости от ваших потребностей может быть лучше использовать ArrayBuffer , а не ListBuffer . Дополнительную информацию см. в моей кулинарной книге Scala. Сделайте ArrayBuffer вашим изменяемым индексированным последовательностью по умолчанию.

Более функциональные способы работы со списками Scala

В зависимости от ваших потребностей существуют другие, «более функциональные» способы работы со списками Scala, и я рассматриваю некоторые из них в своих примерах Scala List. Но для моих сегодняшних нужд я просто хотел работать со списком Scala так же, как я работал бы со списком Java ( ArrayList , LinkedList ), и этот подход меня устраивает.

No related posts.