Рубрики

Массивы в Java

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

  • В Java все массивы распределяются динамически (см. Ниже)
  • Поскольку массивы являются объектами в Java, мы можем найти их длину, используя длину элемента. Это отличается от C / C ++, где мы находим длину, используя sizeof.
  • Переменная массива Java также может быть объявлена как другие переменные с [] после типа данных.
  • Переменные в массиве упорядочены, и у каждой есть индекс, начинающийся с 0.
  • Массив Java также можно использовать в качестве статического поля, локальной переменной или параметра метода.
  • Размер массива должен быть задан значением int, а не long или short.
  • Прямой суперкласс типа массива — Object .
  • Каждый тип массива реализует интерфейсы Cloneable и java.io.Serializable .

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

Создание, инициализация и доступ к массиву

Одномерные массивы:
Общая форма объявления одномерного массива

type var-name[];
OR
type[] var-name;

Объявление массива имеет два компонента: тип и имя. Тип объявляет тип элемента массива. Тип элемента определяет тип данных каждого элемента, который составляет массив. Как и массив типа int, мы также можем создать массив других примитивных типов данных, таких как char, float, double..etc или определенный пользователем тип данных (объекты класса). Таким образом, тип элемента для массива определяет, какой тип данные массив будет содержать.
Пример:

// both are valid declarations
int intArray[]; 
or int[] intArray; 

byte byteArray[];
short shortsArray[];
boolean booleanArray[];
long longArray[];
float floatArray[];
double doubleArray[];
char charArray[];

// an array of references to objects of
// the class MyClass (a class created by
// user)
MyClass myClassArray[]; 

Object[]  ao,        // array of Object
Collection[] ca;  // array of Collection
                     // of unknown type

Хотя вышеупомянутое первое объявление устанавливает тот факт, что intArray является переменной массива, фактически никакого массива не существует . Он просто сообщает компилятору, что эта переменная (intArray) будет содержать массив целочисленного типа. Чтобы связать intArray с фактическим, физическим массивом целых чисел, вы должны выделить один, используя new, и назначить его intArray.

Создание массива в Java

Когда массив объявлен, создается только ссылка на массив. Чтобы фактически создать или выделить память для массива, вы создаете массив следующим образом: Общая форма new применительно к одномерным массивам выглядит следующим образом:

var-name = new type [size];

Здесь тип указывает тип данных, которые должны быть выделены, размер определяет количество элементов в массиве, а var-name — это имя переменной массива, которая связана с массивом. То есть, чтобы использовать new для выделения массива, вы должны указать тип и количество элементов для выделения.

Пример:

int intArray[];    //declaring array
intArray = new int[20];  // allocating memory to array

ИЛИ

int[] intArray = new int[20]; // combining both statements in one

Замечания :

    1. Элементы в массиве, выделенном new, будут автоматически инициализированы в ноль (для числовых типов), false (для логических значений ) или null (для ссылочных типов). Ссылка Значения массива по умолчанию в Java
    2. Получение массива является двухэтапным процессом. Во-первых, вы должны объявить переменную нужного типа массива. Во-вторых, вы должны выделить память для хранения массива, используя new, и назначить ее переменной массива. Таким образом, в Java все массивы распределяются динамически.

    Array Literal

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

     int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 }; 
     // Declaring array literal
    • Длина этого массива определяет длину создаваемого массива.
    • Нет необходимости писать новую часть int [] в последних версиях Java

    Доступ к элементам массива Java с использованием цикла

    Доступ к каждому элементу в массиве осуществляется через его индекс. Индекс начинается с 0 и заканчивается (общий размер массива) -1. Все элементы массива могут быть доступны с помощью Java for Loop.

     
    // accessing the elements of the specified array
    for (int i = 0; i < arr.length; i++)
      System.out.println("Element at index " + i + 
                                    " : "+ arr[i]);
    

    Реализация:

    // Java-программа для иллюстрации создания массива
    // целых чисел, помещает некоторые значения в массив,
    // и выводит каждое значение на стандартный вывод.

      

    class GFG 

    {

        public static void main (String[] args) 

        {         

          // объявляет массив целых чисел.

          int[] arr;

              

          // выделяем память на 5 целых чисел.

          arr = new int[5];

              

          // инициализируем первые элементы массива

          arr[0] = 10;

              

          // инициализируем вторые элементы массива

          arr[1] = 20;

              

          //скоро...

          arr[2] = 30;

          arr[3] = 40;

          arr[4] = 50;

              

          // доступ к элементам указанного массива

          for (int i = 0; i < arr.length; i++)

             System.out.println("Element at index " + i + 

                                          " : "+ arr[i]);          

        }

    }

    Выход:

    Element at index 0 : 10
    Element at index 1 : 20
    Element at index 2 : 30
    Element at index 3 : 40
    Element at index 4 : 50
    

    Вы также можете получить доступ к массивам Java с помощью циклов foreach.

    Массивы объектов

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

     Student[] arr = new Student[7]; //student is a user-defined class

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

    Student[] arr = new Student[5];

    // Java-программа для иллюстрации создания массива
    // объекты

      

    class Student

    {

        public int roll_no;

        public String name;

        Student(int roll_no, String name)

        {

            this.roll_no = roll_no;

            this.name = name;

        }

    }

      
    // Элементы массива являются объектами класса Student.

    public class GFG

    {

        public static void main (String[] args)

        {

            // объявляет массив целых чисел.

            Student[] arr;

      

            // выделяем память для 5 объектов типа Student.

            arr = new Student[5];

      

            // инициализируем первые элементы массива

            arr[0] = new Student(1,"aman");

      

            // инициализируем вторые элементы массива

            arr[1] = new Student(2,"vaibhav");

      

            // скоро...

            arr[2] = new Student(3,"shikar");

            arr[3] = new Student(4,"dharmesh");

            arr[4] = new Student(5,"mohit");

      

            // доступ к элементам указанного массива

            for (int i = 0; i < arr.length; i++)

                System.out.println("Element at " + i + " : " +

                            arr[i].roll_no +" "+ arr[i].name);

        }

    }

    Выход:

    Element at 0 : 1 aman
    Element at 1 : 2 vaibhav
    Element at 2 : 3 shikar
    Element at 3 : 4 dharmesh
    Element at 4 : 5 mohit
    

    Что произойдет, если мы попытаемся получить доступ к элементу вне размера массива?

    JVM генерирует ArrayIndexOutOfBoundsException, чтобы указать, что к массиву был получен доступ с недопустимым индексом. Индекс либо отрицательный, либо больше или равен размеру массива.

    class GFG

    {

        public static void main (String[] args)

        {

            int[] arr = new int[2];

            arr[0] = 10;

            arr[1] = 20;

      

            for (int i = 0; i <= arr.length; i++)

                System.out.println(arr[i]);

        }

    }

    Ошибка выполнения

    Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
        at GFG.main(File.java:12)
    

    Выход:

    10
    20
    

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

    Многомерные массивы — это массивы массивов, где каждый элемент массива содержит ссылку на другой массив. Они также известны как рваные массивы . Многомерный массив создается путем добавления одного набора квадратных скобок ([]) к измерению. Примеры:

    int[][] intArray = new int[10][20]; //a 2D array or matrix
    int[][][] intArray = new int[10][20][10]; //a 3D array
    

    class multiDimensional

    {

        public static void main(String args[])

        {

            // объявляем и инициализируем 2D массив

            int arr[][] = { {2,7,9},{3,6,1},{7,4,2} };

      

            // печать 2D массива

            for (int i=0; i< 3 ; i++)

            {

                for (int j=0; j < 3 ; j++)

                    System.out.print(arr[i][j] + " ");

      

                System.out.println();

            }

        }

    }

    Выход:

    2 7 9 
    3 6 1 
    7 4 2 
    

    Передача массивов в методы

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

    // Java-программа для демонстрации
    // передача массива в метод

      

    class Test

    {    

        // Метод драйвера

        public static void main(String args[]) 

        {

            int arr[] = {3, 1, 2, 5, 4};

              

            // передача массива в метод m1

            sum(arr);

          

        }

      

        public static void sum(int[] arr) 

        {

            // получаем сумму значений массива

            int sum = 0;

              

            for (int i = 0; i < arr.length; i++)

                sum+=arr[i];

              

            System.out.println("sum of array values : " + sum);

        }

    }

    Выход :

    sum of array values : 15
    

    Возвращение массивов из методов

    Как обычно, метод также может возвращать массив. Например, нижеприведенная программа возвращает массив из метода m1 .

    // Java-программа для демонстрации
    // возврат массива из метода

      

    class Test

    {    

        // Метод драйвера

        public static void main(String args[]) 

        {

            int arr[] = m1();

              

            for (int i = 0; i < arr.length; i++)

                System.out.print(arr[i]+" ");

          

        }

      

        public static int[] m1() 

        {

            // возвращаем массив

            return new int[]{1,2,3};

        }

    }

    Выход:

    1 2 3
    

    Объекты класса для массивов

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

    // Java-программа для демонстрации
    // Объекты класса для массивов

      

    class Test

        public static void main(String args[]) 

        {

            int intArray[] = new int[3];

            byte byteArray[] = new byte[3];

            short shortsArray[] = new short[3];

              

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

            String[] strArray = new String[3];

              

            System.out.println(intArray.getClass());

            System.out.println(intArray.getClass().getSuperclass());

            System.out.println(byteArray.getClass());

            System.out.println(shortsArray.getClass());

            System.out.println(strArray.getClass());

        }

    }

    Выход:

    class [I
    class java.lang.Object
    class [B
    class [S
    class [Ljava.lang.String;
    

    Пояснение:

    1. Строка «[I» является сигнатурой типа времени выполнения для объекта класса «массив с типом компонента int ».
    2. Единственный прямой суперкласс любого типа массива — это java.lang.Object .
    3. Строка «[B» является сигнатурой типа времени выполнения для объекта класса «массив с байтом типа компонента».
    4. Строка «[S» является сигнатурой типа времени выполнения для объекта класса «массив с коротким типом компонента».
    5. Строка «[L» является сигнатурой типа времени выполнения для объекта класса «массив с типом компонента класса». Имя класса затем следует.

    Члены массива

    Теперь, когда вы знаете, что массивы являются объектами класса, а прямой суперкласс массивов — это класс Object . Членами типа массива являются следующие:

    • Общая длина конечного поля, которая содержит количество компонентов массива. длина может быть положительной или нулевой.
    • Все члены унаследованы от класса Object; единственный метод Object, который не наследуется, это его метод клонирования .
    • Открытый метод clone () , который переопределяет метод clone в классе Object и не выдает никаких проверенных исключений .

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

    • Когда вы клонируете одномерный массив, такой как Object [], выполняется «глубокая копия» с новым массивом, содержащим копии элементов исходного массива, а не ссылки.

      // Java-программа для демонстрации
      // клонирование одномерных массивов

        

      class Test

      {    

          public static void main(String args[]) 

          {

              int intArray[] = {1,2,3};

                

              int cloneArray[] = intArray.clone();

                

              // напечатает false при создании глубокой копии

              // для одномерного массива

              System.out.println(intArray == cloneArray);

                

              for (int i = 0; i < cloneArray.length; i++) {

                  System.out.print(cloneArray[i]+" ");

              }

          }

      }

      Выход:

      false
      1 2 3
      

    • Однако клон многомерного массива (например, Object [] []) является «мелкой копией», то есть он создает только один новый массив, в котором каждый массив элементов ссылается на исходный массив элементов, но подмассивы являются общими.

      // Java-программа для демонстрации
      // клонирование многомерных массивов

        

      class Test

      {    

          public static void main(String args[]) 

          {

              int intArray[][] = {{1,2,3},{4,5}};

                

              int cloneArray[][] = intArray.clone();

                

              // выведет false

              System.out.println(intArray == cloneArray);

                

              // будет печатать true при создании мелкой копии

              // т.е. подмассивы являются общими

              System.out.println(intArray[0] == cloneArray[0]);

              System.out.println(intArray[1] == cloneArray[1]);

                

          }

      }

      Выход:

      false
      true
      true
      

    Связанная статья:
    Jagged Array в Java
    Для каждого цикла в Java
    Класс массивов в Java

    Ссылка : Массивы от Oracle

    Эта статья предоставлена Ницдхирендрой и Гауравом Миглани . Если вы как GeeksforGeeks и хотели бы внести свой вклад, вы также можете написать статью с помощью contribute.geeksforgeeks.org или по почте статьи contribute@geeksforgeeks.org. Смотрите свою статью, появляющуюся на главной странице GeeksforGeeks, и помогите другим вундеркиндам.

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

    Рекомендуемые посты:

    Массивы в Java

    0.00 (0%) 0 votes