Введение в использование массивов JAVA

Автор：Eve Cole Время обновления：2024-11-19 16:12:02

Между массивами JAVA и классами-контейнерами есть три основных различия: эффективность, тип и возможность сохранять базовые типы . В JAVA массивы — наиболее эффективный способ хранения и случайного доступа к последовательности ссылок на объекты. Массив представляет собой простую линейную последовательность, которая обеспечивает очень быстрый доступ к элементам. Но цена за это — то, что размер массива фиксирован и не может быть изменен в течение его жизни.

Благодаря дженерикам и механизмам автоматической упаковки контейнеры теперь можно использовать с примитивными типами почти так же легко, как с массивами. И массивы, и контейнеры могут в определенной степени помешать вам злоупотреблять ими. Если они выйдут за пределы, вы получите исключение RuntimeException. Единственное остающееся преимущество массивов — это эффективность. Однако если вы хотите решать более общие задачи, массивы могут оказаться слишком ограничительными, поэтому в этом случае большинство людей все равно выберут контейнеры.

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

【инициализация】
В JAVA действуют очень строгие правила инициализации массивов, что позволяет эффективно предотвратить злоупотребление массивами. Если возникла ошибка инициализации, вы получите CompileException вместо RuntimeException напрямую. Ничего нельзя сделать с этой ссылкой на массив, пока массив не будет правильно инициализирован.
Определения массива включают int[] array и int array[]. Обычно первый стиль используется для отделения типа от имени переменной.
Существует два способа инициализации массива: статическая инициализация и динамическая инициализация. Длина должна быть указана во время инициализации. Должна быть указана длина первого измерения многомерного массива, и она должна быть определена от старшего к младшему. Действие инициализации может находиться в любом месте кода, но метод {} может появляться только там, где создается массив. См. программу для конкретных методов инициализации:

Скопируйте код кода следующим образом:

общественный класс javaArrayInit {
public static void main(String args[]){
int[] arrayA; //не инициализировано
int[] arrayB = new int[5] //статическая инициализация;
//System.out.println(arrayA.length); //CompileException
System.out.println("arrayB length: " + arrayB.length); //Невозможно получить фактическое количество сохраненных элементов.

arrayA = new int[10] //Динамическая инициализация
System.out.println("Длина массиваA: " + arrayA.length);

int[] arrayC = новый int[]{1,2,3,4};
System.out.println("длина массиваC: " + arrayC.length);

//int[] arrayD = new int[1]{1} //Неправильная инициализация, размеры и значения инициализации не могут быть определены одновременно

int[][] arrayE = новый int[1][];
System.out.println("длина массиваE: " + arrayE.length);

//int[][] arrayF = new int[][2] //Сначала необходимо указать длину верхнего измерения

int[][] arrayG = новый int[][]{{1,2,3,4},{5,6,7},{7,24,23,24}};
System.out.println("длина массиваG: " + arrayG.length);

int[][][] arrayH = новый int[][][]{{{1,2,3},{4,5,6},{7,8,9},{10,11,12} }};
System.out.println("длина массиваH: " + arrayH.length);

dummyArray[] arrayI = {new dummyArray(),new dummyArray()} //Пользовательский тип массива
System.out.println("Длина массива: " + arrayI.length);
System.out.println("arrayI[1]: " + arrayI[1].getValue());

dummyArray[] arrayK = новый dummyArray[5];
System.out.println("arrayK[0]: " + arrayK[0]);
for(int я = 0; я <arrayK.length; я++){
arrayK[i] = новый dummyArray();
}
System.out.println("arrayK[0]: " + arrayK[0].getValue()); //2
}
}
класс dummyArray{
частная статическая температура int;
частный окончательный int arrayValue = temp++;
общественный ИНТ getValue () {
вернуть значение массива;
}
}

Выход:

Длина массиваB: 5
Длина массиваA: 10
Длина массиваC: 4
Длина массиваE: 1
Длина массиваG: 3
Длина массиваH: 1
Длина массива: 2
массивI[1]: 1
массивК[0]: ноль
массивК[0]: 2

【длина】
Длина члена, доступного только для чтения, является частью объекта массива (хотя эта переменная фактически не объявлена в API и динамически генерируется во время выполнения). Это единственное поле или метод, к которому можно получить доступ. Синтаксис [] — единственный способ доступа к объектам массива, а доступ к контейнерам осуществляется через метод get(). Вы можете использовать Array.length для получения размера массива. Обратите внимание, что он отличается от String.length() типа String. Array использует переменные-члены, а String использует методы-члены. В то же время Array.length может получить только размер массива, но не то, сколько элементов в массиве на самом деле имеется. Длина многомерного массива рассчитывает только длину первого измерения.

Скопируйте код кода следующим образом:

общественный класс javaArrayLength {
public static void main(String args[]){
int[] arrayA = новый int[15];
массивА[1] = 1;
массивА[2] = 2;
массивА[3] = 3;
System.out.println("Длина массиваA: " + arrayA.length);

int[][] arrayB = новый int[10][];
System.out.println("длина массиваB: " + arrayB.length);

int[][] arrayC = новый int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} ,};//Обратите внимание на запятую после
System.out.println("длина массиваC: " + arrayC.length);

int[][] arrayD = новый int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} , {}};
System.out.println("длина массиваD: " + arrayD.length);
}
}
Выход:

Длина массиваA: 15
Длина массиваB: 10
Длина массиваC: 3
Длина массиваD: 4

【Массивы.заполнить】
Arrays.fill — очень ограниченный метод, поскольку он может заполнять каждую позицию только одним и тем же значением (или, в случае объекта, копировать одну и ту же ссылку для заполнения). Использование Arrays.fill может заполнить весь массив или определенную область массива, но поскольку Arrays.fill можно вызвать только с одним значением, это не очень полезно.

[Назначение и ссылка]
Когда массив JAVA инициализируется, он имеет только ссылку на массив, и для него не выделяется пространство для хранения. Следовательно, копирование между массивами не может просто использовать присваивание "=", поскольку используется один и тот же объект. Следующая процедура:

Скопируйте код кода следующим образом:

общественный класс javaArrayQuote {
public static void main(String args[]){
Строка testA = «testA»;
Строка testB = «testB»;
String[] arrayA = новая String[]{"arrayA"};
String[] arrayB = новая String[]{"arrayB"};
тестБ = тестА;
testB = "Изменение testB";
System.out.println("Я testA, у меня ничего не изменилось: " + testA);
массивБ = массивА;
arrayB[0] = "массивB изменился";
System.out.println("Я arrayA, у меня ничего не изменилось: " + arrayA[0]);

}
}
Выход:

Я testA, у меня ничего не изменилось: testA
Я arrayA, у меня ничего не изменилось: arrayB изменился

Видно, что когда мы меняем значение arrayB[0], мы изменяем массив, на который ссылаемся, поэтому мы выводим arrayA[0], который на самом деле совпадает с arrayB[0].

[Копия массива]
Как скопировать массив в JAVA:

1. Используйте цикл FOR для копирования всех или указанных элементов, что менее эффективно.
2. Используйте метод клонирования, чтобы получить значение массива вместо ссылки. Однако клон не может копировать указанные элементы и имеет низкую гибкость.
3. Используйте метод System.arraycopy(src, srcPos, dest, destPos, length). Стандартная библиотека классов Java предоставляет статический метод System.arraycopy(). Его использование для копирования массива происходит намного быстрее, чем системный цикл. .arraycopy() предназначен для всех типов. Как массивы базовых типов, так и массивы объектов можно копировать с помощью System.arraycopy(), но массивы объектов копируют только ссылки, и двух копий объектов не будет. Это называется поверхностным копированием.
src: исходный массив;
srcPos: начальная позиция копируемого исходного массива;
dest: массив назначения;
destPos: начальная позиция, в которой размещается целевой массив;
длина: длина копии.
Примечание. System.arraycopy() не выполняет автоматическую упаковку и автоматическую распаковку, поэтому два массива должны быть одного типа или могут быть преобразованы в массивы того же типа. В то же время этот метод можно использовать и для копирования самого массива.
int[] тест = {0,1,2,3,4,5,6};
System.arraycopy(тест,0,тест,3,3);
Результат: {0,1,2,0,1,2,6};
Процедура испытания следующая:

Скопируйте код кода следующим образом:

общественный класс javaArrayCopy {
public static void main(String args[]){
int[] массив = {1,2,3,4,5,6,7,8,9};
//для метода цикла
int[] arrayA = новый int[9];
for(int я = 0; я <arrayA.length; я++){
массивА[я] = массив[я];
System.out.print(arrayA[i] + ",");
}
//тест
System.out.println("");
массивА[1] = 19;
for(int я = 0; я <arrayA.length; я++){
System.out.print(arrayA[i] + ",");
}
System.out.println("");
for(int я = 0; я <array.length; я++){
System.out.print(array[i] + ",");
}
System.out.println("");

//клонируем метод
int[] arrayB = новый int[9];
массивB = массив.клон();
//тест
массивБ[1] = 19;
for(int я = 0; я <arrayB.length; я++){
System.out.print(arrayB[i] + ",");
}
System.out.println("");
for(int я = 0; я <array.length; я++){
System.out.print(array[i] + ",");
}
System.out.println("");

//Метод System.arrayCopy
int[] arrayC = новый int[9];
System.arraycopy(массив, 0, arrayC, 0, arrayC.length);
//тест
массивC[1] = 19;
for(int я = 0; я <arrayC.length; я++){
System.out.print(arrayC[i] + ",");
}
System.out.println("");
for(int я = 0; я <array.length; я++){
System.out.print(array[i] + ",");
}
}
}

[Сравнение массивов]
Arrays предоставляет перегруженный методquals(), который перегружается для всех типов и типов объектов для сравнения всего массива. Условием равенства массива является то, что количество элементов должно быть одинаково, а также элементы в соответствующих позициях также должны быть равны. Метод deepEquals() используется для сравнения многомерных массивов. Два массива, сравниваемые методом Array.equals(), должны быть массивами одного типа.

Скопируйте код кода следующим образом:

импортировать java.util.Arrays;
общественный класс javaArrayEquals {
public static void main(String args[]){
int[] arrayA = {1,2,3};
int[] arrayB = {1,2,3,};
int[] arrayC = новый int[4]; //если int[] arrayC = новый int[3],возвращаем true
массивC[0] = 1;
массивC[1] = 2;
массивC[2] = 3;
System.out.println(Arrays.equals(arrayA, arrayB));
System.out.println(Arrays.equals(arrayA, arrayC));

String[][] arrayD = {{"a","b"},{"c","d"}};
String[][] arrayE = {{"a","b"},{"c","d"}};
System.out.println(Arrays.deepEquals(arrayD, arrayE));
}
}

[Сортировка и поиск массива]
Массивы предоставляют встроенный метод сортировки sort(), который может сортировать массив любого базового типа или массив объектов (объект должен реализовывать интерфейс Comparable или иметь связанный компаратор). JAVA предоставляет разные методы сортировки для разных типов — быстрая сортировка, предназначенная для базовых типов, и «стабильная сортировка слиянием», предназначенная для объектов, поэтому нет необходимости беспокоиться об эффективности сортировки массивов.
ДвоичныйПоиск() используется для быстрого поиска элементов в отсортированном массиве. Если двоичныйПоиск() используется в несортированном массиве, результаты будут непредсказуемыми.

[возвращаемый массив]
C и C++ не могут возвращать массив, а только указатель на массив, поскольку возврат массива затрудняет управление жизненным циклом массива и может легко вызвать утечки памяти. Java позволяет возвращать массив напрямую, и он может быть переработан механизмом сборки мусора.

[Преобразование массива и контейнера] [Невозможно преобразовать массив базового типа]

Преобразовать массив в список:

Скопируйте код кода следующим образом:

импортировать java.util.*;
общественный класс arrayToList {
public static void main(String args[]){
String[] arrayA = {"a","b","c"};
Список listA = java.util.Arrays.asList(arrayA);
System.out.println("listA: " + listA);

int[] arrayB = {1,2,3};
Список listB = java.util.Arrays.asList(arrayB);
System.out.println("listB: " + listB);

Целое число [] arrayC = {1,2,3};
Список listC = java.util.Arrays.asList(arrayC);
System.out.println("listC: " + listC);
}
}
Выход:

списокА: [а, б, в]
listB: [[I@de6ced]
списокC: [1, 2, 3]

Почему выходные данные int и Integer отличаются?

Преобразовать список в массив

Скопируйте код кода следующим образом:

импортировать java.util.*;
список публичного классаToArray {
public static void main(String args[]){
List<String> list = новый ArrayList<String>();
Массив строка[];
list.add("testA");
list.add("testB");
list.add("testC");
System.out.println("список: " + список);

String[] strings = новая String[list.size()];
массив = list.toArray(строки);
for(int i = 0, j = array.length; i <j; i++){
System.out.print(array[i] + ",");
}
}
}
Результат:

список: [testA, testB, testC]
тестA, тестB, тестC

【Удалить повторяющиеся данные】
Преобразование массива и контейнера позволяет легко удалить повторяющиеся данные из массива, но если массив слишком велик, эффективность становится проблемой.

Скопируйте код кода следующим образом:

импортировать java.util.*;
общественный класс javaArrayUnique {
public static void main(String args[]){
String[] array = {"a","b","a","a","c","b"};
arrayUnique (массив);
//тест
for(int i = 0, j = arrayUnique(array).length; i <j; i++){
System.out.print(arrayUnique(array)[i] + ",");
}
}

общественный статический String[] arrayUnique(String[] array){
List<String> list = новый ArrayList<String>();
for(int i = 0, j = array.length; i <j; i++){
если(!list.contains(массив[i])){
list.add(массив[я]);
}
}
String[] strings = новая String[list.size()];
String[] arrayUnique = list.toArray(strings);
вернуть массивUnique;
}
}

Что касается проблемы эффективности, я провел сравнение. Запуск массива из 100 000 данных на моем компьютере занимает около 577 мс, а запуск массива из миллиона данных — около 5663 мс. Это также связано с эксплуатационными возможностями компьютера, но, очевидно, увеличивается с размером массива.

Скопируйте код кода следующим образом:

импортировать java.util.*;
общественный класс javaArrayUnique {
public static void main(String args[]){
Массив Double[] = новый Double[100000];
for(int i = 0, j = array.length; i <j; i++){
массив[i] = Math.ceil(Math.random()*1000);
}

Double[] arrayB = новый Double[1000000];
for(int i = 0, j = arrayB.length; i <j; i++){
arrayB[i] = Math.ceil(Math.random()*1000);
}

System.out.println("старт");
длинный startTime = System.currentTimeMillis();
arrayUnique (массив);
long endTime = System.currentTimeMillis();
System.out.println("уникальное время выполнения массива: " +(endTime - startTime) +"ms");

длинный startTimeB = System.currentTimeMillis();
массивUnique (массивB);
long endTimeB = System.currentTimeMillis();
System.out.println("уникальное время выполнения массиваB: " +(endTimeB - startTimeB) +"ms");
}

public static Double[] arrayUnique(Double[] array){
List<Double> list = новый ArrayList<Double>();
for(int i = 0, j = array.length; i <j; i++){
если(!list.contains(массив[i])){
list.add(массив[я]);
}
}
Double[] doubles = новый Double[list.size()];
Double[] arrayUnique = list.toArray(doubles);
вернуть массивUnique;
}
}
Выход:

начинать
уникальное время выполнения массива: 577 мс
Уникальное время выполнения arrayB: 5663 мс