Массивы в руководстве по Java: как объявлять и инициализировать массивы Java

Массивы в руководстве по Java Программирование и разработка

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

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

Сегодня мы узнаем, в чем уникальность массивов в синтаксисе Java, и узнаем, как объявлять, инициализировать и работать с элементами массива.

Что такое массивы в Java?

Переменная — это место в нашей программе с именем и значением. Это значение может быть любым типом данных, например int. Массив другая переменная типа или объект — контейнер с фиксированным количеством значений, которые все из одного типа. Другими словами, набор схожих типов данных. При создании массива этот размер (или длина) также фиксируется.

Упрощенно: представьте массив Java как коробку с множеством отсеков, внутри каждого отсека находится одно значение.

Массив из 5 элементов с индексом начиная с 0

Массив из 5 элементов с индексом начиная с 0

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

INDICES => index ->index 1->index 2->index 3->...index n

ELEMENTS => element 1->element 2->element 3->element 4->....element n+1

У каждого отсека есть числовой индекс, который мы используем для доступа к значению. Индекс массива всегда начинается с 0. Допустим, у нас есть 10 отсеков в коробке контейнера массива. Будет 10 индексов, но они начинаются с 0 и заканчиваются 9, потому что индекс 0 указывает на первый элемент 1.

Будет 10 индексов, но они начинаются с 0 и заканчиваются 9

Что уникального в массивах в Java?

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

  • Массивы распределяются динамически
  • Массивы — это объекты в Java
  • Переменная массива Java объявляется так же, как и другие переменные.
  • Переменные упорядочены, индекс начинается с 0.
  • Суперкласс типа массива — это Object
  • Размер массива указывается с помощью int value

Типы массивов в Java

В Java есть несколько различных типов массивов, с которыми мы можем работать.

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

int[] myArray = {10, 20, 30, 40}

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

// Two dimmensional array
int[][] a = new int[3][4];
// Three dimmensional array
String[][][] data = new String[3][4][2];

Массив объектов создаются так же, как массив примитивных типов данных.

Student[] arr = new Student[4];
//This is a user-defined class

ArrayList класс класс, который является изменяемым массивом. В то время как встроенные массивы имеют фиксированный размер, ArrayLists может динамически изменять их размер, поэтому элементы массива можно добавлять и удалять с помощью методов, как векторы в C ++.

Примечание: это в java.utilупаковке.

import java.util.ArrayList; //import the ArrayList class
class MyClass {
    public static void main( String args[] ) {
    ArrayList<String> shapes = new ArrayList<String>(); // Create an ArrayList object with a string data type
    }
}

Объявление массива в Java

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

dataType[] arrayName;
  • dataType: это может быть любой объект Java или примитивный тип данных (например, int, byte, char, boolean и т. д.)
  • arrayName: это идентификатор, поэтому вы можете получить доступ к массиву
Читайте также:  Интересные проекты Python для начинающих

Давайте создадим простой массив на Java, чтобы понять синтаксис. Сначала объявите тип переменной, используя квадратные скобки [].

String[] dogs;

Теперь у нас есть переменная, содержащая массив строк. Мы можем вставлять значения, используя литерал массива. Мы помещаем наши значения в список, разделенный запятыми, который заключен в фигурные скобки {}.

String[] dogs = {"Pitbull", "Poodle", "Lab", "Pug"};

Немного иначе выглядит создание массива целых чисел.

int[] myNum = {5, 10, 15, 20};

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

// declaring an array 
double[] data; 

// allocating memory 
data = new Double[5];

Выше в массиве может храниться 5 элементов, что означает, что длина массива равна 5. В качестве другого примера предположим, что мы хотим сохранить имена 50 человек. Создаем массив строкового типа. В приведенном ниже массиве может храниться не более 50 элементов.

String[] array = new String[50];

Есть и другие способы объявить массив в Java. Вот три варианта:

  • int[] myNumberCollection = new int[5];
  • int[] myNumberCollection; myNumberCollection = new int[5];
  • int[] myNumberCollection = {1, 2, 56, 57, 23};

В первых двух случаях мы добавляем элементы в контейнер массива вручную. В третьем случае мы добавили элементы при объявлении массива.

// initializing first element

    myNumberCollection[] = 1;

// initializing second element

    myNumberCollection[1] = 2;

Примечание. В официальной документации Java рекомендуется объявлять массив, используя:

public static void main(String[] args){}.

Инициализация массива в Java

В Java мы можем инициализировать массивы во время объявления. В Java инициализация происходит, когда вы присваиваете данные переменной. Объявление — это просто когда вы создаете переменную. Итак, когда вы впервые создаете переменную, вы ее объявляете, но еще не обязательно инициализируете.

Вот как мы можем инициализировать наши значения в Java:

//declare and initialize an array

int[] age = {25, 50, 23, 21};

Выше мы создали массив с именем ageи инициализировали его значениями, которые мы хотели добавить. Здесь мы не объявляли размер массива, потому что компилятор Java автоматически считает размер.

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

// declare an array 

int[] age = new int[5]; 

// initialize array 

age[] = 25; 

age[1] = 50; 

...

Доступ и изменение элементов массива

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

Ниже приведен синтаксис доступа к элементам массива:

// access array elements
array[index]

Продолжим наш предыдущий dogsпример. Ниже мы хотим получить доступ к первому значению и распечатать результат.

class Main {
 public static void main(String[] args) {
   // create an array
   String[] dogs = {«Pitbull», «Poodle», «Lab», «Pug»};
   // access first element
   System.out.println(«First Element: » + dogs[0]);
 }
}

Примечание. В Java вы можете использовать System.out.printlnдля печати значения.

Мы также можем изменить значение элемента, используя его порядковый номер. Используя наш пример выше, скажем, мы хотим перейти Pitbullна Terrier.

class Main {
 public static void main(String[] args) {
    String[] dogs = {«Pitbull», «Poodle», «Lab», «Pug»};
    System.out.println(«Before update» + dogs[0]); // print old value
    dogs[0] = «Terrier»; // changing value
    System.out.println(«After update» + dogs[0]); // print new value
    }
}

Цикл по элементам массива

Мы также можем перебрать каждый элемент массива. В Java существует несколько способов перебора массива, например цикл for, расширенный цикл for, цикл while или цикл do-while.

Читайте также:  Основы программирования HTML

Традиционный цикл позволяет выполнять итерацию, пока не дойдете до последнего элемента. Усовершенствованные циклы for позволяют выполнять итерацию, не имея дело со счетчиками.

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

Давайте посмотрим на пример цикла for, чтобы увидеть, как он работает в Java. Ниже мы используем Java for Loop для перебора каждого элемента массива. Мы используем свойство length, чтобы получить размер нашего массива.

class Main {
 public static void main(String[] args) {
   // create an array
   int[] age = {3, 2, 7, 8};
   // loop through the array with for Loop
   System.out.println(«Using for Loop:»);
   for(int i = 0; i < age.length; i++) {
     System.out.println(age[i]);
   }
 }
}

Примечание. Циклы For в Java идентичны C и Javascript.

Общие операции с массивами Java

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

Получите первый и последний элемент

Это одна из наиболее распространенных задач, которые мы можем выполнять с массивами Java из-за их организации на основе индексов. Сначала мы объявляем и инициализируем массив int.

Затем мы используем значение индекса 0 и атрибут длины для получения определенных элементов.

class Main {
 public static void main(String[] args) {
     int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
     int firstItem = array[0];
int lastItem = array[array.length — 1];
 }
}

Добавить новый элемент в массив

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

int[] newArray = Arrays.copyOf(array, array.length + 1);

newArray[newArray.length - 1] = newItem;

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

Есть два варианта этого метода:

1. toArray(): Этот метод возвращает массив типа Object[], элементы которого находятся в той же последовательности, что и в списке. Приведение используется для указания типа каждого элемента при выполнении некоторых операций.

import java.util.ArrayList;
public class ListToArray {
    public static void main(String[] args) {
        // A list of size 4 which is to be converted:
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        // ArrayList converted to Object[] array:
        Object[] objArr = list.toArray();
        for(Object obj: objArr){
      // Using casting before performing addition:
      System.out.println((Integer)obj + 1);
    }
  }
}
}

2. toArray(T[] arr): Этот вариант принимает в качестве параметра уже определенный массив. Когда размер массива больше или равен размеру списка, то массив заполняется элементами списка. Поскольку тип возвращаемого массива определяется типом параметра, преобразование не требуется.

import java.util.ArrayList;
public class ListToArray {
  public static void main(String[] args) {
    // A list of size 4 to be converted:
    ArrayList<Integer> list = new ArrayList<>();
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    // Declaring an array of size 4:
    Integer[] arr = new Integer[4];
    // Passing the declared array as the parameter:
    list.toArray(arr);
    // Printing all elements of the array:
    System.out.println(«Printing ‘arr’:»);
    for(Integer i: arr)
      System.out.println(i);
    // Declaring another array of insufficient size:
    Integer[] arr2 = new Integer[3];
    // Passing the array as the parameter:
    Integer[] arr3 = list.toArray(arr2);
    // Printing the passed array:
    System.out.println(«\n’arr2′ isn’t filled because it is small in size:»);
    for(Integer i: arr2)
      System.out.println(i);
    // Printing the newly allocated array:
    System.out.println(«\n’arr3′ references the newly allocated array:»);
    for(Integer i: arr3)
      System.out.println(i);
  }
}

Получить случайное значение

Мы можем использовать объект java.util.Random, мы можем получить доступ к случайному значению.

int anyValue = array[new Random().nextInt(array.length)];

Вставить значение между двумя другими значениями

Вставить элемент в массив между двумя другими довольно сложно. Класс ArrayUtilsбыл создан, чтобы это стало возможным. Здесь мы указываем индекс, в который хотим вставить значение. Наш вывод — это новый массив с большим количеством элементов.

int[] largerArray = ArrayUtils.insert(2, array, 77);

Проверьте, пуст ли массив

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

boolean isEmpty = array == null || array.length == ;

ArrayUtilsВспомогательный класс также предлагает метод нуль-безопасна для этого процесса, но эта функция зависит от длины структуры данных.

boolean isEmpty = ArrayUtils.isEmpty(array);

Оцените статью
bestprogrammer.ru
Добавить комментарий