Java-массивы. динамические массивы в java
Содержание:
- 10 ответов
- типы массивов в Java
- Динамический массив в Java
- Методы по работе с массивами в языке Java
- Java Array example
- Как сравнить два массива в Java?
- Параллельные операции над массивами
- The Arrays Class
- Ассоциативные массивы в Java
- Java irregular arrays
- Методы Java ArrayList
10 ответов
из того, что я вижу, вы просто пытаетесь увидеть, равны ли они, если это правда, просто идите с чем-то вроде этого:
Это стандартный способ сделать это.
Ops, он швы, что массивы также должны быть отсортированы, чтобы считаться равными, из Java doc:
«два массива считаются равными, если оба массива содержат одинаковое количество элементов, и все соответствующие пары элементов в двух массивах одинаковые. Другими словами, два массива равны если они содержат одни и те же элементы в одном и том же порядке»
Извините, что пропустил это.
использовать Arrays.equals(ary1,ary2); // возвращает логическое значение
редактировать вы можете использовать Arrays.deepEquals(ary1,ary2) сравнить 2D массивы а также
также проверить этой ссылке для сравнения сравнение между Arrays.equls(ar1,ar2) и Arrays.deepEquals(ar1,ar2)
Изменить 2 если вы не хотите использовать эти методы библиотеки, вы можете легко реализуйте свой метод следующим образом:
Если вы знаете, что массивы имеют одинаковый размер, это доказуемо быстрее сортировать, а затем сравнить
Если вы не хотите изменять порядок данных в массивах, сделайте System.arraycopy первый.
ни один из существующих ответов не включает использование компаратора и поэтому не может использоваться в двоичных деревьях или для сортировки. Поэтому я просто оставлю это здесь:
вы можете проверить равенство массивов с помощью Apache Commons ArrayUtils#isEquals () метод.
хотя есть что-то легкое типа .equals , Я хотел бы указать на две ошибки, которые вы сделали в коде. Первый: когда вы проходите через массивы, вы говорите b и true или false . Затем вы начинаете снова проверять, из-за for-loop. Но каждый раз вы даете b значение. Итак, что бы ни случилось, значение b получает значение всегда является значением последнего for-loop. В следующий раз, set boolean b = true , if equal = true , ни if equal = false , b=false .
во-вторых, теперь вы проверяете каждое значение в array1 С каждым значением в array2 . Если я правильно понимаю, вам нужно только проверить значения в том же месте в массиве, то есть вы должны были удалить второй for-loop и проверить так: if (array2 == array1) . Тогда ваш код также должен функционировать.
ваш код будет работать примерно так:
но, как сказал другой, проще было бы: Матрицы.равно (ary1, ary2);
основываясь на этом комментарии, у вас уже есть свой алгоритм:
Проверьте, имеют ли оба массива одинаковую длину:
числа должны быть одинаковыми в одном и том же положении:
зная это, вы можете создать свой код следующим образом (это не Java-код, это алгоритм):
Примечание: ваша функция должна возвращать boolean , а не void , затем восстановите возвращаемое значение в другой переменной и используйте его для печати сообщения » true «или»false»:
Источник
типы массивов в Java
В Java есть 2 типа массивов:
- Одномерный массив — он содержит только 1 строку и 1 столбец. Все приведенные выше примеры относятся к одномерному массиву
- Многомерный массив — содержит несколько строк и несколько столбцов. Другими словами, это массив массивов, в котором все строки имеют одинаковое количество столбцов. Например: 2 * 2 матрица
- Неровный массив — каждая строка содержит разное количество столбцов.
Многомерные массивы в java
Многомерные массивы могут иметь несколько строк и столбцов. Индекс в первом [] представляет строки, а второй [] представляет столбцы.
Например: int [] [] a = new int
Это означает, что массив содержит 2 строки и 3 столбца. Ниже приведено схематическое изображение многомерного массива.
Пример создания многомерных массивов строк
В приведенном ниже примере показано, как создавать, объявлять и получать доступ к элементам многомерного массива. Здесь мы напрямую обращаемся к элементам массива, используя индекс строки и столбца.
public class ArrayMulti {
public static void main(String[] args) {
String[][] arrNames = {{"John","Jacob"},{"Thomas","Martin"}};
System.out.println(arrNames + " " + arrNames);
System.out.println(arrNames + " " + arrNames);
}
}
Output: John Jacob Thomas Martin
Пример двумерного массива целых чисел
Здесь мы создаем двумерный массив целых чисел, состоящий из 2 строк и 2 столбцов. Мы присваиваем значения этим элементам массива внутри цикла for. Первый цикл for обозначает строки, а второй цикл for — столбцы.
public class ArrayMulti {
public static void main(String[] args) {
//Declare and create multidimensional array
int[][] arrnum = new int;
for(int i=0;i<2;i++) {
for(int j=0;j<3;j++) {
//Assign values to array elements
arrnum = i+1;
System.out.print(arrnum + " ");
}
System.out.println();
}
}
}
Output: 1 1 1 2 2 2
Зубчатые массивы в Java
Неровный массив — это также двумерный массив, имеющий другое количество столбцов. Другими словами, в каждой строке разное количество столбцов. Инициализация массива с зазубринами отличается от инициализации обычного 2D-массива.
Инициализация массива с зазубринами
При создании массива мы указываем количество строк. В этом примере это 2. В следующих двух операторах для каждого массива строк мы указываем количество столбцов. Здесь в 2-й строке 1 столбца, а во 3-й строке 2 столбца.
int[][] arrnum = new int[]; arrnum = new int; arrnum = new int;
Пример зазубренного массива путем присвоения значений в цикле for
public class JaggedArray {
public static void main(String[] args) {
int[][] arrnum = new int[];
arrnum = new int;
arrnum = new int;
int val=1;
//Assign values
for(int i=0;i<arrnum.length;i++) {
for(int j=0;j<arrnum.length;j++) {
arrnum = val;
}
}
//Print the values
for(int i=0;i<arrnum.length;i++)
{
for(int j=0;j<arrnum.length;j++)
{
System.out.print(arrnum + " ");
}
System.out.println();
}
}
}
Output: 1 1 1 1 1 1 1
Пример зазубренного массива с инициализацией значений во время создания массива
public class JaggedArray {
public static void main(String[] args) {
int[][] arr = {{4,5,6},{1,2},{7,9,8}};
for(int i=0;i<3;i++)
{
for(int j=0;j<arr.length;j++) {
System.out.print(arr + " ");
}
System.out.println();
}
}
}
Output: 4 5 6 1 2 7 9 8
Динамический массив в Java
Минус массива — статичность, то есть необходимость задавать размер заранее. Для этого и придумали динамический массив, который может менять размер в процессе выполнения программы.
Например, статические массивы работают по следующей схеме:
А динамические массивы в Java функционируют несколько иначе:
Так как для копирования массива используется специальная нативная функция, проблем с «переездом» не возникает.
В общем, как вы уже догадались, динамические массивы применяются во время обработки наборов однородных данных, размер которых на момент написания программы нам неизвестен.
Методы по работе с массивами в языке Java
По сути дела, с элементами массивов можно делать все то же самое что и с другими объектами и примитивными типами.
Допустим, если элементы массива — целочисленный тип данных int, то мы можем добавлять, отнимать, умножать и применять любые другие операции которые мы применяем к числам. То же самое касается строк и других объектов которые находятся в нашем объекте.
В массива есть длина (length). Чтобы ее узнать достаточно вызвать переменную length. Вот как это делается:
В результате, после вызова length в переменную arrayLength будет записана длина нашего charArray. Если мы ее выведем в консоль — получим значение 3.
Чтобы не работать с элементами массива «по одному» можно прибегнуть к помощи циклов. Именно управляя индексом цикла можно получать элементы:
В результате запуска примера выше мы увидим такой результат:
Результат выполнения работы программы массив в Java
Очень часто стоит задача вывести все или часть элементов на экран. Для этого я подготовил отдельную статью: Вывод массива java
Еще советую посмотреть материалы по сортировке массива. Данная тема тоже достаточно актуальна и полезная. Особенно для начинающих программистов.
На этом и закончим знакомство с массивами в языке Java. Сейчас, я предлагаю Вам поискать хорошие задачи на массивы и потренироваться. Ведь именно с темы массивов начинается изучение коллекций которые используются почти в каждой программе.
Java Array example
In this Java array program, We will declare an integer array of size ten. Then we will sum those ten array values and displays the output.
In this Java array example Program, We declared 1 One Dimensional Arrays anIntegerArray[] with 10 elements and also declared i to iterate the Array elements,
Below For loop iterate every cell in the anIntegerArray array. The condition inside the for loops (i < anIntegerArray.length) will ensure the Jcompiler not exceed the array limit.
- Sum = Sum + anIntegerArray; statement is used to add each and individual array element present in the anIntegerArray to Sum variable.
- System.out.format statement displays the Sum value after every iteration.
- anIntegerArray.length finds the length of an array.
Java Array First Iteration: The value of i will be 0, and the condition (i < 10) is True. So, it will start executing the statements inside the loop.
Sum = Sum + anIntegerArray
=> Sum + anIntegerArray
Sum = 0 + 10 = 10
The value of i will be incremented by 1
Second Iteration: The value of i is 1, and the condition (1 < 10) is True.
Sum = Sum + anIntegerArraySum = 10 + 20 = 30
Third Iteration: After the increment, the value of i is 2, and the condition (2 < 10) is True.
Sum += anIntegerArray=> 30 + 30 = 60
Fourth Iteration: The value of i is 3, and the condition (3 < 5) is True.
Sum = Sum + anIntegerArraySum = 60 + 40 = 100
Fifth Iteration: The value of i is 4, and the condition (4 < 10) is True.
Sum = Sum +anIntegerArray=> 100 + 50 = 150
Sixth Iteration: The value of i is 5, and the condition (5 < 10) is True.
Sum += anIntegerArraySum = 150 + 60 = 210
Seventh Iteration: After increment, i = 6, and the condition (6 < 10) is True.
Sum = Sum + anIntegerArray => 210 + 70 = 280
Eighth Iteration: The value of i is 7, and the condition (7 < 10) is True.
Sum = Sum + anIntegerArray => 280 + 80 = 360
9th Iteration: i is 8, and the condition (8 < 10) is True.
Sum = Sum + anIntegerArray => 360 + 90 = 450
10th Iteration: i is 9 and the condition (9 < 10) is True.
Sum = Sum + anIntegerArraySum = 450 + 100 = 550
11th Iteration: The value of i is 10, and the condition (10 < 10) is False. So, it will exit from the for loop.
Lastly, we used System.out.format statement to display the Sum
Как сравнить два массива в Java?
Предсказать вывод следующей программы Java.
public static void main (String[] args)
if (arr1 == arr2) // То же, что и arr1.equals (arr2)
System.out.println( «Not same» );
В Java массивы являются объектами первого класса . В приведенной выше программе arr1 и arr2 являются двумя ссылками на два разных объекта. Поэтому, когда мы сравниваем arr1 и arr2, сравниваются две ссылочные переменные, поэтому мы получаем вывод «Not Same» (см. Это для большего количества примеров).
Как сравнить содержимое массива? Простой способ — запустить цикл и сравнить элементы один за другим. Java предоставляет прямой метод Arrays.equals () для сравнения двух массивов. На самом деле, существует список методов equals () в классе Arrays для различных примитивных типов (int, char, ..etc) и один для типа Object (который является основой всех классов в Java).
// нам нужно импортировать java.util.Arrays, чтобы использовать Arrays.equals ().
public static void main (String[] args)
if (Arrays.equals(arr1, arr2))
System.out.println( «Not same» );
Как глубоко сравнить содержимое массива? Как видно выше, Arrays.equals () работает нормально и сравнивает содержимое массивов. Теперь вопросы, а что, если массивы содержат массивы внутри них или некоторые другие ссылки, которые ссылаются на другой объект, но имеют одинаковые значения. Например, см. Следующую программу.
public static void main (String[] args)
// inarr1 и inarr2 имеют одинаковые значения
Object[] arr1 = ; // arr1 содержит только один элемент
Object[] arr2 = ; // arr2 также содержит только один элемент
if (Arrays.equals(arr1, arr2))
System.out.println( «Not same» );
Поэтому Arrays.equals () не может делать глубокое сравнение. Java предоставляет другой метод для этого Arrays.deepEquals (), который выполняет глубокое сравнение.
public static void main (String[] args)
Object[] arr1 = ; // arr1 содержит только один элемент
Object[] arr2 = ; // arr2 также содержит только один элемент
if (Arrays.deepEquals(arr1, arr2))
System.out.println( «Not same» );
Упражнение: предсказать результат следующей программы
public static void main (String[] args)
Object[] arr1 = ; // arr1 содержит только один элемент
Object[] arr2 = ; // arr2 также содержит только один элемент
Object[] outarr1 = ; // outarr1 содержит только один элемент
Object[] outarr2 = ; // outarr2 также содержит только один элемент
if (Arrays.deepEquals(outarr1, outarr2))
System.out.println( «Not same» );
Пожалуйста, напишите комментарии, если вы обнаружите что-то неправильное, или вы хотите поделиться дополнительной информацией по обсуждаемой теме
Источник
Параллельные операции над массивами
Последнее обновление: 30.04.2018
В JDK 8 к классу Arrays было добавлено ряд методов, которые позволяют в параллельном режиме совершать обработку элементов массива.
И хотя данные методы формально не входят в Stream API, но реализуют схожую функциональность, что и параллельные потоки:
-
parallelPrefix(): вычисляет некоторое значение для элементов массива (например, сумму элементов)
-
parallelSetAll(): устанавливает элементы массива с помощью лямбда-выражения
-
parallelSort(): сортирует массив
Используем метод для установки элементов массива:
import java.util.Arrays;
public class Program {
public static void main(String[] args) {
int[] numbers = initializeArray(6);
for(int i: numbers)
System.out.println(i);
}
public static int[] initializeArray(int size) {
int[] values = new int;
Arrays.parallelSetAll(values, i -> i*10);
return values;
}
}
В метод передается два параметра: изменяемый массив и функция, которая устанавливает элементы массива. Эта
функция перебирает все элементы и в качестве параметра получает индекс текущего перебираемого элемента. Выражение означает,
что по каждому индексу в массиве будет хранится число, равное i * 10. В итоге мы получим следующий вывод:
0 10 20 30 40 50
Рассмотрим более сложный пример. Пусть у нас есть следующий класс Phone:
class Phone{
private String name;
private int price;
public Phone(String name, int price){
this.name=name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String val) {
this.name=val;
}
public int getPrice() {
return price;
}
public void setPrice(int val) {
this.price=val;
}
}
Теперь произведем манипуляции с массивом объектов Phone:
Phone[] phones = new Phone[]{new Phone("iPhone 8", 54000),
new Phone("Pixel 2", 45000),
new Phone("Samsung Galaxy S9", 40000),
new Phone("Nokia 9", 32000)};
Arrays.parallelSetAll(phones, i -> {
phones.setPrice(phones.getPrice()-10000);
return phones;
});
for(Phone p: phones)
System.out.printf("%s - %d \n", p.getName(), p.getPrice());
Теперь лямбда-выражение в методе представляет блок кода. И так как лямбда-выражение должно возвращать объект, то нам надо явным образом использовать
оператор return. В этом лямбда-выражении опять же функция получает индексы перебираемых элементов, и по этим индексам мы можем обратиться
к элементам массива и их изменить. Конкретно в данном случае происходит уменьшение цены смартфонов на 10000 единиц. В итоге мы получим следующий
консольный вывод:
iPhone 8 - 44000 Pixel 2 - 35000 Samsung Galaxy S9 - 30000 Nokia 9 - 22000
Сортировка
Отсортируем массив чисел в параллельном режиме:
int[] nums = {30, -4, 5, 29, 7, -8};
Arrays.parallelSort(nums);
for(int i: nums)
System.out.println(i);
Метод в качестве параметра принимает массив и сортирует его по возрастанию:
-8 -4 5 7 29 30
Если же нам надо как-то по-другому отсортировать объекты, например, по модулю числа, или у нас более сложные объекты, то мы можем создать свой компаратор и передать его в качестве второго параметра в
. Например, возьмем выше определенный класс Phone и создадим для него компаратор:
import java.util.Arrays;
import java.util.Comparator;
public class Program {
public static void main(String[] args) {
Phone[] phones = new Phone[]{new Phone("iPhone 8", 54000),
new Phone("Pixel 2", 45000),
new Phone("Samsung Galaxy S9", 40000),
new Phone("Nokia 9", 32000)};
Arrays.parallelSort(phones,new PhoneComparator());
for(Phone p: phones)
System.out.println(p.getName());
}
}
class PhoneComparator implements Comparator<Phone>{
public int compare(Phone a, Phone b){
return a.getName().toUpperCase().compareTo(b.getName().toUpperCase());
}
}
Метод parallelPrefix
Метод походит для тех случаев, когда надо получить элемент массива или объект того же типа, что и элементы массива, который обладает некоторыми признаками.
Например, в массиве чисел это может быть максимальное, минимальное значения и т.д. Например, найдем произведение чисел:
int[] numbers = {1, 2, 3, 4, 5, 6};
Arrays.parallelPrefix(numbers, (x, y) -> x * y);
for(int i: numbers)
System.out.println(i);
Мы получим следующий результат:
1 2 6 24 120 720
То есть, как мы видим из консольного вывода, лямбда-выражение из , которое представляет бинарную функцию, получает два элемента и
выполняет над ними операцию. Результат операции сохраняется и передается в следующий вызов бинарной функции.
НазадВперед
The Arrays Class
The java.util.Arrays class contains various static methods for sorting and searching arrays, comparing arrays, and filling array elements. These methods are overloaded for all primitive types.
| Sr.No. | Method & Description |
|---|---|
| 1 |
public static int binarySearch(Object[] a, Object key) Searches the specified array of Object ( Byte, Int , double, etc.) for the specified value using the binary search algorithm. The array must be sorted prior to making this call. This returns index of the search key, if it is contained in the list; otherwise, it returns ( – (insertion point + 1)). |
| 2 |
public static boolean equals(long[] a, long[] a2) Returns true if the two specified arrays of longs are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. This returns true if the two arrays are equal. Same method could be used by all other primitive data types (Byte, short, Int, etc.) |
| 3 |
public static void fill(int[] a, int val) Assigns the specified int value to each element of the specified array of ints. The same method could be used by all other primitive data types (Byte, short, Int, etc.) |
| 4 |
public static void sort(Object[] a) Sorts the specified array of objects into an ascending order, according to the natural ordering of its elements. The same method could be used by all other primitive data types ( Byte, short, Int, etc.) |
Previous Page
Print Page
Next Page
Ассоциативные массивы в Java
У ассоциативного массива в качестве ключей применяются строки. Мы можем представить его структуру данных в виде совокупности пары «ключ-значение». В таком массиве, как ассоциативный, любое значение связано с конкретным ключом, а доступ к значению производится по имени ключа.
Что касается языка программирования Java, то в нём ассоциативные массивы не поддерживаются. А ведь в некоторых ситуациях, работая с массивами, было бы неплохо обратиться к элементу не по индексу, а по ключу.
Однако есть способ реализовать похожую структуру данных, используя стандартные средства Java SE. В частности, мы можем создать простейший ассоциативный массив, воспользовавшись классом HashMap и установив для его экземпляра строковый тип данных ключа.
Посмотрим, как это работает:
HashMap<String, Integer> fruits = new HashMap();
fruits.put("Число апельсинов", 5);
fruits.put("Число яблок", 10);
fruits.put("Число мандаринов", 7);
System.out.println(fruits.get("Число мандаринов"));
Мы можем создать ассоциативный массив и с более сложной структурой, поместив объекты HashMap друг в друга и получив тем самым «ассоциативные массивы в ассоциативном массиве». Посмотрим, как это выглядит на практике:
HashMap<String, Integer> fruits = new HashMap();
fruits.put("Число апельсинов", 5);
fruits.put("Число яблок", 10);
fruits.put("Число мандаринов", 7);
HashMap<String, Integer> milkProducts = new HashMap();
milkProducts.put("Число пачек творога", 2);
milkProducts.put("Число пакетов молока", 3);
milkProducts.put("Число банок сметаны", 17);
HashMap<String, HashMap<String, Integer> > eat = new HashMap();
eat.put("Фрукты", fruits);
eat.put("Молочные продукты", milkProducts);
System.out.println(eat.get("Молочные продукты").get("Число пакетов молока"));
В результате мы решим проблему отсутствия ассоциативных массивов в Java.
При подготовке статьи использовались следующие материалы:
— Java Multidimensional Arrays;
— «Ассоциативные массивы в Java».
Java irregular arrays
Arrays that have elements of the same size are called rectangular arrays. It is
possible to create irregular arrays where the arrays have a different size. In
C# such arrays are called jagged arrays.
com/zetcode/IrregularArrays.java
package com.zetcode;
public class IrregularArrays {
public static void main(String[] args) {
int[][] ir = new int[][] {
{1, 2},
{1, 2, 3},
{1, 2, 3, 4}
};
for (int[] a : ir) {
for (int e : a) {
System.out.print(e + " ");
}
}
System.out.print('\n');
}
}
This is an example of an irregular array.
int[][] ir = new int[][] {
{1, 2},
{1, 2, 3},
{1, 2, 3, 4}
};
This is a declaration and initialization of an irregular array.
The three inner arrays have 2, 3, and 4 elements.
for (int[] a : ir) {
for (int e : a) {
System.out.print(e + " ");
}
}
The enhanced for loop is used to go through all the
elements of the array.
$ java IrregularArrays.java 1 2 1 2 3 1 2 3 4
This is the output of the example.
Методы Java ArrayList
В дополнение к приведенным ниже методам ArrayList в Java имеет доступ ко всем методам интерфейса List.
| Способ доставки | Описание | Параметр |
|---|---|---|
| Логическое сложение (объект e) | Добавляет указанный элемент в конец списка. | e — добавляемый элемент.Возвращаемое значение — Истина |
| void add (int index, объект e) | Добавляет элемент по указанному индексу. Если индекс уже содержит элемент, он смещается вправо | index — индекс, по которому нужно вставить элементe — элемент, который нужно вставить |
| Логическое addAll (Коллекция c) | Добавляет коллекцию указанных элементов в список. | c — коллекция добавляемых элементовВозвращаемое значение — истина |
| Логическое addAll (индекс int, Коллекция c) | Добавляет коллекцию элементов по указанному индексу. Если индекс уже содержит элемент, он впоследствии сдвигается вправо | index — индекс, по которому нужно добавить элементыc — коллекция добавляемых элементовВозвращаемое значение — Истина |
| пусто ясно () | Очищает все элементы в списке. | |
| Логическое значение содержит (Объект o) | Проверяет, содержит ли список указанный элемент | Возвращаемое значение — истина, если список содержит элемент |
| Логическое значение containsAll (Коллекция c) | Проверяет, содержит ли список все элементы коллекции | Возвращаемое значение — истина, если список содержит все элементы |
| Логическое равно (объект o) | Сравнивает, содержит ли список все указанные элементы в точном порядке | Возвращаемое значение — истина, если элементы объекта совпадают со списком |
| Объект getIndex (индекс int) | Извлекает элемент по указанному индексу | index — индекс, по которому элемент, который необходимо получитьВозвращаемое значение — элемент по указанному индексу. |
| int indexOf (объект o) | Получает индекс первого вхождения указанного элемента | o — Идентифицируемый элементВозвращаемое значение — значение индекса |
| Логическое значение isEmpty () | Проверяет, пуст список или нет | Возвращаемое значение — истина, если список не содержит значений |
| Итератор итератор () | Последовательно извлекает итератор списка | Возвращаемое значение — Итератор |
| int lastIndexOf (Объект o) | Извлекает последнее вхождение указанного объекта | o — Идентифицируемый элементВозвращаемое значение — значение индекса |
| Удаление объекта (индекс int) | Удаляет элемент по указанному индексу | index — позиция индекса, в которой элемент должен быть удаленВозвращаемое значение — удаляемый элемент |
| Логическое удаление (объект o) | Удаляет первое вхождение указанного объекта из списка, если он присутствует | o — элемент, который нужно удалитьВозвращаемое значение — истина, если список содержит элемент |
| Логическое removeAll (Коллекция c) | Удаляет первое вхождение всех элементов в коллекции из списка, если он присутствует. | c — набор элементовВозвращаемое значение — истина, если список содержит коллекцию |
| Логическое значение keepAll (Коллекция c) | Сохраняет в списке все элементы, указанные в коллекции. Остальные элементы будут удалены | c — набор элементов, которые необходимо сохранитьВозвращаемое значение — истина, если список изменился из-за вызванного метода |
| Набор объектов (int index, Object o) | Заменяет элемент по указанному индексу переданным объектом | o — элемент, который нужно заменитьindex — индекс элементаВозвращаемое значение — возвращает элемент, который ранее находился по указанному индексу. |
| размер int () | Получает размер списка | Возвращаемое значение — размер списка |
| Подсписок списка (int fromIndex, int toIndex) | Извлекает часть списка на основе start и endIndex | fromIndex — позиция, из которой нужно извлечь подсписок (включить)toIndex — индекс, до которого подсписок должен быть извлечен (исключен) |
| недействительным гарантироватьCapacity (int mincapacity) | Увеличивает размер Arraylist и гарантирует, что он может удерживать минимальную емкость, как указано | mincapacity — минимальное количество элементов, которое может содержать Arraylist |
| пустая сортировка (Comparator c) | Сортирует элементы в списке на основе аргумента компаратора | c — отсек, который используется для сравнения элементов списка |
| Объект [] toArray () | Возвращает массив элементов в правильной последовательности | Возвращаемое значение — массив всех элементов в списке в правильной последовательности |
| Строка toString () | Возвращает строковое представление коллекции элементов массива | Возвращаемое значение — строка элементов массива, разделенных запятыми и пробелами и заключенных в [] |
| void trimToSize () | Обрезает размер экземпляра ArrayList до текущего размера списка |
