Большая часть методов работы с массивами определена в специальном классе  Arrays пакета java.util. Ряд методов определены в классах java.lang.Object и java.lang.System.

На практике наиболее часто в основном используются  методы  класса java.util.Arrays, а также несколько методов классов java.lang.Object  и java.lang.System. Указанные методы представлены ниже.

Методы перегружены для всех примитивных типов

[]b=Arrays.copyOf([]a, int newLength)	копирование массива, []a – исходный массив []b – новый массив newLength – длина нового массива
[]b=Arrays.copyOfRange ([]a, int index1, int index2)	копирование части массива, []a – исходный массив []b – новый массив index1, index2– начальный и конечный индексы копирования
java.lang.System.arraycopy([] a, indexA , []b, indexB, count)	копирование массива, []a – исходный массив []b – новый массив indexA-начальный  индекс копирования исходного массива indexB-начальный  индекс  нового массива count- количество элементов копирования
[]b= a.java.lang.Object.clone()	копирование массива []a – исходный массив []b – новый массив
Arrays.sort([]a)	Сортировка. Упорядочивание всего массива в порядке возрастания
Arrays.sort([]a,index1,index2)	Сортировка части массива в порядке возрастания
Arrays.sort([]a, Collections.reverseOrder());	Сортировка. Упорядочивание всего массива в порядке убывания
Boolean f=Arrays.equals([]a,[]b)	сравнение массивов
String str=Arrays.toString([]a);	Вывод одномерных массивов. Все элементы представлены в виде одной строки
int index=Arrays.binarySearch([]a,элемент a)	поиск элемента методом бинарного поиска
Arrays.fill([]a, элемент заполнения)	заполнение массива переданным значением
Boolean f=Arrays.deepEquals([]a, []b)	сравнение двумерных массивов
List<T> Arrays.asList(<T> []a);	Перевод массива в коллекцию

   

  Для работы с классом  необходимо подключить библиотеку  java.util.Arrays.

 

Методы работы с массивами

Копирование массивов

Метод  java.util.Arrays.copyOf()

Arrays.copyOf возвращает массив-копию новой длины. Если новая длина меньше исходной, то массив усекается до этой длины, а если больше, то дополняется значениями по умолчанию  соответствующего типа.

Формат метода

 []b=Arrays.copyOf([]a, int newLength),

[]a – исходный массив

[]b – новый массив

newLength – длина нового массива

 Пример 1.

      double a[] = { 0, 1, 2, 3, 4, 5 };
      double b[]= new double [a.length];
      System.out.println("длина массива a: "+a.length);
      System.out.println("длина массива b: "+b.length);
      System.out.println("массив  a");
      for(int i=0; i<a.length; i++) System.out.print(a[i]+"  ");
      System.out.println("");
 //копирование,новый массив будет состоять из 3 элементов
      b= Arrays.copyOf(a, 3); //0, 1, 2
      System.out.println("новая длина массива b: "+b.length);
      System.out.println("массив  b");
      for(int i=0; i<b.length; i++) System.out.print(b[i]+"  ");
      System.out.println("");

Будет выведено:

длина массива a:6
длина массива b: 6
массив  a
0.0  1.0  2.0  3.0  4.0  5.0
новая длина массива b: 3
массив  b
0.0  1.0  2.0

Пример 2.

 

   boolean [] flag1 = {true,true,true};
  boolean [] flag2 = new boolean [5];
       
  System.out.println("массив  flag1");
  for(int i=0; i<flag1.length; i++) System.out.print(flag1[i]+"  ");
  System.out.println("");
     
  System.out.println("массив  flag2");
  for(int i=0; i<flag2.length; i++) System.out.print(flag2[i]+"  ");
  System.out.println("");
//копирование, массив   flag2 будет состоять
  //из 3 элементов   flag1 и двух, имеющих 
  //значения по умолчанию - для boolean это false 
  flag2= Arrays.copyOf(flag1, 5);
  //длина массива   flag2
  System.out.println("длина массива flag2: "+flag2.length);
  System.out.println("массив  flag2");
  for(int i=0; i<flag2.length; i++) System.out.print(flag2[i]+"  ");
  System.out.println();

Будет выведено:

массив  flag1
true  true  true
массив  flag2
false  false  false  false  false
длина массива flag2: 5
массив  flag2
true  true  true  false  false 

Метод  java.util. Arrays.copyOf()

Arrays.copyOfRange возвращает массив-копию новой длины, при этом копируется часть оригинального массива от начального индекса до конечного –1.

Формат метода

[]b=Arrays.copyOfRange ([]a, int index1, int index2),

[]a – исходный массив

[]b – новый массив

index1, index2– начальный и конечный индексы копирования

Пример.

 String[] day= {"Понедельник","Вторник","Среда","Четверг","Пятница","Суббота","Воскресенье"}
String[] workingDay = new String [5];
System.out.println("Дни недели:");
for(int i=0; i<day.length; i++) System.out.print(day[i]+"  ");
System.out.println();
System.out.println("Рабочие дни");
workingDay=Arrays.copyOfRange(day,0,5);
for(int i=0; i<workingDay.length; i++) System.out.print(workingDay[i]+"  ");
System.out.println();
 

 Будет выведено:

Дни недели:
Понедельник  Вторник  Среда  Четверг  Пятница  Суббота  Воскресенье
Рабочие дни
Понедельник  Вторник  Среда  Четверг  Пятница

Метод  arraycopy()  из класса System

Быстродействие метода System.arraycopy() выше по сравнению с использованием цикла for для выполнения копирования. Метод System.arraycopy( ) перегружен для обработки всех типов.

 Формат метода

java.lang.System.arraycopy([] a, indexA , []b, indexB, count),

[]a – исходный массив

[]b – новый массив

indexA-начальный  индекс копирования исходного массива

indexB-начальный  индекс  нового массива

count- количество элементов копирования

 Пример.

int a1[] = { 0, 1, 2, 3, 4, 5 };
int a2[] = { 0, 10, 20, 30, 40, 50 };
int b[]= new int [a1.length];
//копируем все элемента массива a1 в массив b
System.arraycopy(a1, 0, b, 0, a1.length); // 1  2  3  4  5
for(int i=0; i<b.length; i++) System.out.print(b[i]+"  ");
System.out.println();
//копируем первые три элемента массива a1 в массив a2 с индекса 0
System.arraycopy(a1, 0, a2, 0, 3); // 0  1  2  30  40  50
for(int i=0; i<a2.length; i++) System.out.print(a2[i]+"  ");
System.out.println();
//копируем первые три элемента массива a1 в массив a2 с индекса 3
System.arraycopy(a1, 0, a2, 3, 3); // 0  1  2  0  1  2 
for(int i=0; i<a2.length; i++) System.out.print(a2[i]+"  ");
System.out.println();

 

Пример.

String [] month = {"январь","февраль","март","апрель","май","июнь","июль","август","сентябрь","октябрь","ноябрь","декабрь"};
String [] winter = new String [3];
String [] spring = {"","","","","","",""};
System.arraycopy(month, 2, spring, 0, 3); //март  апрель  май 
 for(int i=0; i<spring.length; i++)
System.out.print(spring[i]+"  ");        
System.out.println();
System.out.println();
 System.arraycopy(month, 0, winter, 1, 2); //  null  январь  февраль
for(int i=0; i<winter.length; i++)
System.out.print(winter[i]+"  ");
System.out.println();
winter[0]=month[11];
for(int i=0; i<winter.length; i++)
System.out.print(winter[i]+"  "); // декабрь  январь  февраль
System.out.println();

Метод  clone() из класса Object

 Формат метода

[]b= a.java.lang.Object.clone();

[]a – исходный массив

[]b – новый массив

Пример.

int a[]= {1,2,3,4,5};
int b[];
b=a.clone();
for(int i=0; i<b.length; i++)
System.out.print(b[i]+"  "); //1  2  3  4  5
System.out.println();
 

 

 

Сортировка массивов

 Метод  Arrays.sort([]a)

Метод sort() из класса Arrays использует усовершенствованный алгоритм Быстрой сортировки (Quicksort), который эффективен  для большинства  набора данных.  Метод упорядочивает весь массив в порядке возрастания значений элементов.

Формат метода

Arrays.sort([]a),

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

Пример.

//исходный массив
double a[] = { 41.5, 11.4, 11.2, 3.1, 4.3, 5.5 };
//сортировка
Arrays.sort(a);
//результат сортировки
for(int i=0; i<a.length; i++)
System.out.print(a[i]+"  ");  //3.1  4.3  5.5  11.2  11.4  41.5 
System.out.println();

 Метод  Arrays.sort([]a,index1,index2)

выполняет сортировку части массива по возрастанию массива от index1 до index2 минус единица

 Формат метода

Arrays.sort([]a,index1,index2),

 []a – исходный массив

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

Пример.

//исходный массив
int b[] ={2,1,0,50,30,20,10};
//сортировка  от 0 элемента до 3, сам третий элемент не входит
Arrays.sort(b,0,3);
//результат сортировки
for(int i=0; i<b.length; i++)
System.out.print(b[i]+"  ");  // 0  1  2  50  30  20  10
System.out.println();
 
//сортировка  элементов от 3 до конца массива bb.length
Arrays.sort(b,3,b.length);
for(int i=0; i<b.length; i++)
System.out.print(b[i]+"  "); //0  1  2  10  20  30  50
System.out.println();

 Сортировка  массива по убыванию

Формат метода

 Arrays.sort([]a, Collections.reverseOrder());

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

Пример.

//// сортировrка по убыванию
//вместо примитивного типа double
//используем объектный тип   Double
   Double a[] = new Double[10];
   //заполняем массив случаными числами
   for(int i = 0; i <  a.length; i++) {
     a[i] =  (double)(Math.random() * 20);
      System.out.format("%.2f   ", a[i]);
         }
System.out.println();  
System.out.println("Массив,отсотированный по убыванию");
//Сортируем массив
    Arrays.sort(a, Collections.reverseOrder());
//Выводим отсортированный массив на консоль.
for(int i = 0; i <  a.length; i++) {
     System.out.format("%.2f   ", a[i]);
     }
System.out.println();  

Результат

15,39   1,54   17,47   15,50   3,83   16,43   18,87   15,54   8,23   12,97  

Массив,отсотированный по убыванию

18,87   17,47   16,43   15,54   15,50   15,39   12,97   8,23   3,83   1,54   

Сравнение  массивов

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

Класс Object  имеет метод equals, который наследуется массивами и не является перегруженным и сравнение идет по адресам объектов, а не по содержимому. Метод  equals перегружен только в классе Arrays. Отсюда вытекает правило сравнения массивов:

• a == b сравниваются адреса массивов
• a.equals(b) сравниваются адреса массивов
• Arrays.equals(a, b) сравнивается содержимое массивов
• Arrays.deepEquals(a, b) сравнивается содержимое многомерных массивов

Формат метода

Boolean f=Arrays.equals([]a,[]b);

Метод вернет true, если содержимое массивов равно, в противном случае false.

Пример.

int ar1[] = {0,2,3,4,5,1};
int ar2[] = {0,2,3,4,5,1};
//это сравнение ссылок      
System.out.println(ar1.equals(ar2));  //вернет fasle
//это сравнение содержимового
System.out.println(Arrays.equals(ar1,ar2)); // вернет true
System.out.println("");
    ar1[0]=6;
System.out.println(Arrays.equals(ar1,ar2)); // вернет false
System.out.println("");

Вывод одномерных массивов

Имеется достаточно удобный метод вывода данных одномерного массива - Arrays.toString([]a, который возвращает строковое представление массива со строковым представлением элементов, заключенных в квадратные скобки.

Формат метода:

String str=Arrays.toString([]a);

Пример.

//Вывод одномерных массивов с помощью метода toString()
String[] str = {"Красный",  "Синий",  "Зеленый"};
                               
System.out.println("Это адрес: " +str);
System.out.println("Это значения: " + Arrays.toString(str));
System.out.println();
//выполним печать массива до и после сортировки
int[] a = {7, 2, 9, 1, 0, 3, 4, 8, 5, 6};
System.out.println("До сортировки: "+Arrays.toString(a));
Arrays.sort(a);
System.out.println("После сортировки: "+ Arrays.toString(a));

Будет выведено:

Это адрес: [Ljava.lang.String;@1db9742

Это значения: [Красный, Синий, Зеленый]

До сортировки: [7, 2, 9, 1, 0, 3, 4, 8, 5, 6]

После сортировки: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]              

 

Вывод многомерных массивов

 Для вывода многомерных массивов метод Arrays.deepToString.

Формат метода

String str= Arrays.deepToString([][]a);

Пример.

int aa[][]= {{1,2,3},{4,5,6}, {7,8,9}};
char[][] ch = new char[][]
{
{'а','б','в'},
{'г','д','е'},
{'ё','ж','з'}
};
System.out.println("массив a: "+Arrays.deepToString(aa));
System.out.println("массив  ch: "+Arrays.deepToString(ch));
System.out.println();

Будет выведено:

массив a: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

массив  ch: [[а, б, в], [г, д, е], [ё, ж, з]]

 

Бинарный поиск элемента в одномерном массиве

 

Бинарный поиск – алгоритм поиска элемента в отсортированном массиве. Алгоритм основывается на принципе последовательного деления массива пополам.

Формат метода

int index=Arrays.binarySearch([]a,элемент x),

х  - искомое значение

Метод возвращает:

index – индекс  элемента в массиве, если поиск успешный,

отрицательное число – если в массиве элемент не найден

 Примечание.

Массив должен быть отсортирован! В противном случае результат будет неопределенным.

Пример.

int[] a = {7, 2, 9, 1, 0, 3, 4, 8, 5, 6};
int x=5;
//сортируем массив
Arrays.sort(a);
int index = Arrays.binarySearch(a, x);
System.out.println("Массив= " + Arrays.toString(a));
System.out.println("искомое значение = " + x);
System.out.println("индекс = " + index);

Будет выведено:

Массив= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

искомое значение = 5

индекс = 5

Пример.

String [] month = {"январь","февраль","март",
"апрель","май","июнь",
"июль","август","сентябрь",
"октябрь","ноябрь","декабрь"};
       String strSearch="март";
       Arrays.sort(month);
       int index = Arrays.binarySearch(month,strSearch );
          System.out.println("Массив= " + Arrays.toString(month));
          System.out.println("искомое значение = " + strSearch);
          System.out.println("индекс = " + index);

Будет выведено:

Массив= [август, апрель, декабрь, июль, июнь, май, март, ноябрь, октябрь, сентябрь, февраль, январь]

искомое значение = март

индекс = 6

Заполнение массива

 

Метод Arrays.fill() позволяет  заполнить массив одинаковыми данными.

Имеется два метода

Arrays.fill([]a, value);

Arrays.fill(a[], int index1, int index2, value),

[]a – заполняемый массив,

index1, index2- индексы диапазона заполнения,

value- значение

 

Пример.

int[] a = new int [10];
double[] b = new double [10];
boolean [] bool = new boolean [10];
System.out.println("До заполнения a:  "+Arrays.toString(a));
System.out.println("До заполнения b:  "+Arrays.toString(b));
System.out.println("До заполнения bool:  "+Arrays.toString(bool));
 //весь массив заполняем цифрой 9
Arrays.fill(a, 9 );
System.out.println("После заполнения a: "+Arrays.toString(a));
 //диапазон от 5  до 10 элемента заполняем значением 2.0
 Arrays.fill(b, 5,10, 2.0 );
  System.out.println("После заполнения b: "+Arrays.toString(b));
  //диапазон от 0 включая 5 элемента заполняем значением  true
   Arrays.fill(bool, 0,5, true );
   System.out.println("После заполнения: bool"+Arrays.toString(bool));
 

Будет выведено:

 До заполнения a:  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

До заполнения b:  [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

До заполнения bool:  [false, false, false, false, false, false, false, false, false, false]

После заполнения a: [9, 9, 9, 9, 9, 9, 9, 9, 9, 9]

После заполнения b: [0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 2.0, 2.0]

После заполнения: bool[true, true, true, true, true, false, false, false, false, false]