Java — arrays

How to Initialize Arrays in Java?

In Java, we can initialize arrays during declaration. For example,

Here, we have created an array named age and initialized it with the values inside the curly brackets.

Note that we have not provided the size of the array. In this case, the Java compiler automatically specifies the size by counting the number of elements in the array (i.e. 5).

In the Java array, each memory location is associated with a number. The number is known as an array index. We can also initialize arrays in Java, using the index number. For example,

Java Arrays initialization

Note:

• Array indices always start from 0. That is, the first element of an array is at index 0.
• If the size of an array is n, then the last element of the array will be at index n-1.

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

Приведенные выше примеры — все созданные массивы с одним измерением, то есть элементы с индексами, начиная с 0 и выше. Однако возможно создать массивы, в которых каждый элемент имеет два или более индексов. Они идентифицируют (размещают) его в массиве.

Вы создаете многомерный массив в Java, добавляя один набор квадратных скобок ([]) к измерению, которое хотите добавить. Вот пример, который создает двумерный массив:

int[][] intArray = new int;

В этом примере создается двумерный массив элементов int. Он содержит 10 элементов в первом измерении и 20 во втором. Другими словами, массив массивов имеет пространство для 10 массивов int, а каждый массив int имеет пространство для 20 элементов int.

Для получения доступа к элементам в многомерном массиве с одним индексом на измерение нужно использовать два индекса. Вот пример:

int[][] intArray = new int;

intArray = 129;

int oneInt = intArray;

Переменная с именем oneInt будет содержать значение 129 после выполнения последней строки кода Java.

Processing Arrays

When processing array elements, we often use either for loop or foreach loop because all of the elements in an array are of the same type and the size of the array is known.

Example

Here is a complete example showing how to create, initialize, and process arrays −

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList + " ");
      }
     
      // Summing all elements
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList;
      }
      System.out.println("Total is " + total);
      
      // Finding the largest element
      double max = myList;
      for (int i = 1; i < myList.length; i++) {
         if (myList > max) max = myList;
      }
      System.out.println("Max is " + max);  
   }
}

This will produce the following result −

Создание Многомерного Массива

Давайте начнем с рассмотрения способов создания многомерного массива:

2.1. Стенографическая форма

Простым способом определения многомерного массива было бы:

int[][] multiDimensionalArr = {{1, 2}, {3, 4, 5}, {6, 7, 8, 9}};

Здесь мы объявили и инициализировали многомерный Arr за один шаг.

2.2. Объявление и последующая Инициализация

Мы начнем с объявления многомерного массива третьего размера:

int[][] multiDimensionalArr = new int[];

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

Далее, давайте пойдем дальше, объявив и инициализировав соответствующие элементы в многомерном Arr :

multiDimensionalArr = new int[] {1, 2};
multiDimensionalArr = new int[] {3, 4, 5};
multiDimensionalArr = new int[] {6, 7, 8, 9};

Мы также можем просто объявить его элементы, не инициализируя их:

multiDimensionalArr = new int;
multiDimensionalArr = new int;
multiDimensionalArr = new int;

Затем они могут быть инициализированы, например, с помощью пользовательских вводов.

Мы также можем использовать java.util.Массивы.fill метод инициализации элементов массива:

void initialize2DArray(int[][] multiDimensionalArray) {
    for (int[] array : multiDimensionalArray) {
        Arrays.fill(array, 7);
    }
}

Все элементы в массивах инициализируются одним и тем же значением.

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

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

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

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

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

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

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

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

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

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

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

Объекты класса

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

// Java program to demonstrate
// Class Objects for Arrays

class Test
{
public static void main(String args[])
{
int intArray[] = new int;
byte byteArray[] = new byte;
short shortsArray[] = new short;

// array of Strings
String[] strArray = new String;

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());
}
}

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

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

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

При клонировании одномерного массива, например Object[], выполняется копия с новым массивом, содержащим копии элементов исходного, а не ссылки.

// Java program to demonstrate
// cloning of one-dimensional arrays

class Test
{
public static void main(String args[])
{
int intArray[] = {1,2,3};

int cloneArray[] = intArray.clone();

// will print false as deep copy is created
// for one-dimensional array
System.out.println(intArray == cloneArray);

for (int i = 0; i < cloneArray.length; i++) {
System.out.print(cloneArray+" ");
}
}
}

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

// Java program to demonstrate
// cloning of multi-dimensional arrays

class Test
{
public static void main(String args[])
{
int intArray[][] = {{1,2,3},{4,5}};

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

// will print false
System.out.println(intArray == cloneArray);

// will print true as shallow copy is created
// i.e. sub-arrays are shared
System.out.println(intArray == cloneArray);
System.out.println(intArray == cloneArray);

}
}

Оцени статью

Оценить

Средняя оценка / 5. Количество голосов:

Видим, что вы не нашли ответ на свой вопрос.

Помогите улучшить статью.

Спасибо за ваши отзыв!

Инициализация

Теперь есть два способа инициализировать двумерный массив в Java:

1. используя литерал массива во время создания.
2. используя вложенный цикл for.

В следующем примере мы узнаем, как выполнить цикл через двумерный массив, инициализировать каждый элемент и вывести (напечатать).

// initializing two dimensional array as literal 
String[][] names = { 
 {"Sam", "Smith"},
 {"Robert", "Delgro"},
 {"James", "Gosling"},
};
 int[][] board = new int;
 for (int i = 0; i < board.length; i++) {
 for (int j = 0; j < board.length; j++) {
 board = i + j;
 }
                   }

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

Как вывести

Если вы хотите получить доступ к каждому элементу, то вам нужно выполнить итерацию по двумерному массиву, используя два цикла for. Почему? Потому что вам нужно два индекса для доступа к отдельному элементу.

Вы можете использовать расширенный для каждого цикла или классический для цикла со счетчиком. Для того, чтобы напечатать(сделать вывод) содержимое 2D массива, вы можете использовать либо этот метод, либо Arrays.deepToString(), который возвращает строку всех элементов.

import java.util.Arrays;

/**
* Java Program to initialize and print two dimensional array in Java.
*/
class Basics {

public static void main(String args[]) {

// initializing two dimensional array as literal
String[][] names = {
{"John", "Smith"},
{"Javin", "Paul"},
{"James", "Gosling"},
};

// how to initialize two dimensional array in Java
// using for loop
int[][] board = new int;

for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board.length; j++) {
board = i + j;
}
}

// now let's print a two dimensional array in Java
for (int[] a : board) {
for (int i : a) {
System.out.print(i + "\t");
}
System.out.println("\n");
}

// printing 2D array using Arrays.deepToString() method
System.out.println("another way to print 2D arrays");
System.out.println(Arrays.deepToString(board));

}

}
Output:
0 1 2

1 2 3

2 3 4

another way to print 2D arrays
, , ]

Java Arrays Syntax

A Java array is created using the following format:

In the first part of that code, you saw int[]. This is how you create an array of integers. It looks almost like creating a regular int variable, but notice how there are square brackets next to it. That means that we want to create an int array, and not a single variable.

Numbers is what we’re calling this integer array. That part is the same as a regular variable.

The part after the equals sign is sort of new, but it’s actually something you’ve seen before. Do you remember this:

If you do not remember this statement, then I recommend reading the Java input tutorial. Even if you know other ways of getting input in Java, it’s useful to know what a Scanner does in case you ever see it again.

We are creating a new array the same way a new Scanner is created. Arrays are not created from classes, but they are a little more advanced than the basic types.

You’ll note that there’s a number inside the other set of square brackets. This number is the size of the array. In other words, it’s the number of integer variables you want to have. I chose 5 for the example, meaning I want to create 5 integer variables.

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

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

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

Arrays.fill([]a, value);

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

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

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

value- значение

Пример.

int[] a = new int ;
double[] b = new double ;
boolean [] bool = new boolean ;
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: 

До заполнения b: 

До заполнения bool: 

После заполнения a:

После заполнения b:

После заполнения: bool 

Алгоритмы

3.1. Рекурсивный алгоритм

Первый алгоритм, который мы рассмотрим, это Алгоритм кучи . Это рекурсивный алгоритм, который производит все перестановки путем замены одного элемента на итерацию.

Входной массив будет изменен. Если мы этого не хотим, нам нужно создать копию массива перед вызовом метода:

public static  void printAllRecursive(
  int n, T[] elements, char delimiter) {

    if(n == 1) {
        printArray(elements, delimiter);
    } else {
        for(int i = 0; i < n-1; i++) {
            printAllRecursive(n - 1, elements, delimiter);
            if(n % 2 == 0) {
                swap(elements, i, n-1);
            } else {
                swap(elements, 0, n-1);
            }
        }
        printAllRecursive(n - 1, elements, delimiter);
    }
}

Метод использует два вспомогательных метода:

private void swap(T[] input, int a, int b) {
    T tmp = input;
    input = input;
    input = tmp;
}

private void printArray(T[] input) {
    System.out.print('\n');
    for(int i = 0; i < input.length; i++) {
        System.out.print(input);
    }
}

Здесь мы записываем результат в System.out , однако вместо этого мы можем легко сохранить результат в массиве или в списке.

3.2. Итерационный алгоритм

Алгоритм кучи также может быть реализован с помощью итераций:

int[] indexes = new int;
int[] indexes = new int;
for (int i = 0; i < n; i++) {
    indexes = 0;
}

printArray(elements, delimiter);

int i = 0;
while (i < n) {
    if (indexes < i) {
        swap(elements, i % 2 == 0 ?  0: indexes, i);
        printArray(elements, delimiter);
        indexes++;
        i = 0;
    }
    else {
        indexes = 0;
        i++;
    }
}

3.3. Перестановки в лексикографическом порядке

Если элементы сопоставимы, мы можем генерировать перестановки, отсортированные по естественному порядку элементов:

public static > void printAllOrdered(
  T[] elements, char delimiter) {

    Arrays.sort(elements);
    boolean hasNext = true;

    while(hasNext) {
        printArray(elements, delimiter);
        int k = 0, l = 0;
        hasNext = false;
        for (int i = elements.length - 1; i > 0; i--) {
            if (elements.compareTo(elements) > 0) {
                k = i - 1;
                hasNext = true;
                break;
            }
        }

        for (int i = elements.length - 1; i > k; i--) {
            if (elements.compareTo(elements) > 0) {
                l = i;
                break;
            }
        }

        swap(elements, k, l);
        Collections.reverse(Arrays.asList(elements).subList(k + 1, elements.length));
    }
}

Этот алгоритм имеет обратную операцию на каждой итерации, и поэтому он менее эффективен для массивов, чем алгоритм Кучи.

3.4. Рандомизированный алгоритм

Если n велико, мы можем сгенерировать случайную перестановку путем перетасовки массива:

Collections.shuffle(Arrays.asList(elements));

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

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

Объявление, создание, инициализация

Перед тем как массив использовать, его нужно:

1. Объявить;
2. Создать;
3. Инициализировать.

Запомните это порядок действий и никогда не нарушайте его.При объявлении нужно сначала указать какой тип данных будет там храниться.

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

Например такой код работать не будет: String a = 1;

Именно поэтому при объявлении массива сначала указывают тип данных который он будет принимать. Дальше идут [] (квадратные скобки) и имя переменной. Или имя переменной, квадратные скобки. Разницы не будет:

char nameOfArray[], int anotherName [], char [] nameOfArr, String [] p — это все правильные варианты для объявления массивов.

После того, как array был объявлен, его нужно создать. Дело в том, что в массив это объект. Объекты в java хранятся в памяти отдельно от переменных и примитивных типов. Для каждого объекта выделяется память в программе. В которой он будет находиться до того момента пока будет нужен. Чтобы указать программе что мы резервируем место для объекта нужно воспользоваться ключевым словом new.

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

Выше Вы можете видеть пример создания и инициализации массива. Сразу после знака равно (=) идет создание array с именем a. В квадратных скобках указана размерность (количество элементов).

Сразу после создания, в объект будут записаны значения по умолчанию. Для численного массива это ноль (0), для объекта — null, для boolean — false.

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

Если Вы хотите поменять эти данные — сделать это довольно просто: нужно обратиться по индексу массива к его элементу и присвоить ему значение. Например:

В квадратных скобках на примере выше указан индекс, а после знака равно — новое значение элемента по данному индексу.

Есть еще один способ инициализации:

Таким образом мы объединяем объявление, создание, инициализацию в одну строку. При таком подходе можно даже опустить new char[]:

Как инициализировать двумерный массив Java?

Ниже приводится пример инициализации двумерного массива Java:

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

Каждый компонент массива также представляет собой массив, и длина каждого ряда отличается:

Давайте напишем программу, чтобы это доказать:

class MultidimensionalArray {
   public static void main(String[] args) {

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

      System.out.println("Длина ряда 1: " + a.length);
      System.out.println("Длина ряда 2: " + a.length);
      System.out.println("Длина ряда 3: " + a.length);
   }
}

При запуске этой программы мы получим:

Длина ряда 1: 3 Длина ряда 2: 4 Длина ряда 3: 1

Поскольку многомерный массив состоит из отдельных массивов (a, a and a), можно использовать метод length для определения длины каждого ряда длины двумерного массива Java.

Пример: вывод на экран всех элементов двумерного массива с помощью циклов:

class MultidimensionalArray {
   public static void main(String[] args) {

      int[][] a = {
            {1, -2, 3}, 
            {-4, -5, 6, 9}, 
            {7}, 
      };

     for (int i = 0; i < a.length; ++i) {
        for(int j = 0; j < a.length; ++j) {
           System.out.println(a);
        }
     }
   }
}

Всегда лучше использовать цикл for…each, когда нужно пройти по элементам массива. Пример сортировки двумерного массива Java можно записать с помощью цикла for…each следующим образом:

class MultidimensionalArray {
   public static void main(String[] args) {

      int[][] a = {
            {1, -2, 3}, 
            {-4, -5, 6, 9}, 
            {7}, 
      };

     for (int[] innerArray: a) {
        for(int data: innerArray) {
           System.out.println(data);
        }
     }
   }
}

При запуске этой программы мы получим следующий результат заполнения двумерного массива Java:

1
-2
3
-4
-5
6
9
7

Как инициализировать многомерный массив Java?

Многомерный или трёхмерный массив инициализируется почти так же, как двухмерный:

// test — трёхмерный массив
int[][][] test = {
              {
               {1, -2, 3}, 
               {2, 3, 4}
              }, 
              { 
               {-4, -5, 6, 9}, 
               {1}, 
               {2, 3}
              } 
};

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

Пример: программа для вывода элементов трёхмерного массива с помощью циклов:

class ThreeArray {
   public static void main(String[] args) {

     // test – трёхмерный массив
     int[][][] test = {
              {
               {1, -2, 3}, 
               {2, 3, 4}
              }, 
              { 
               {-4, -5, 6, 9}, 
               {1}, 
               {2, 3}
              } 
     };

     // цикл for..each проходит по элементам трёхмерного массива
     for (int[][] array2D: test) {
        for (int[] array1D: array2D) {
           for(int item: array1D) {
              System.out.println(item);
           }
        }
     }
  }
}

При запуске программы вывода двумерного массива Java получаем следующий результат:

1
-2
3
2
3
4
-4
-5
6
9
1
2
3

Java массивы

Массив — это структура данных, в которой хранятся величины одинакового типа. Доступ к отдельному элементу массива осуществляется с помощью целого индекса. Например, если а — массив целых чисел, то значение выражения а равно i-му целому числу в массиве.

Массив объявляется следующим образом: сначала указывается тип массива, т.е тип элементов, содержащихся в массиве, за которым ставится пара пустых квадратных скобок, а затем — имя переменной. Например, вот как объявляется массив, состоящий из целых чисел: int[] a;

Однако этот оператор лишь объявляет переменную а, не инициализируя ее настоящим массивом. Чтобы создать массив, нужно применить оператор new.

Этот оператор создает массив, состоящий из 100 целых чисел. Элементы этого массива нумеруются от 0 до 99 (а не от 1 до 100). После создания массив можно заполнять, например, с помощью цикла.

Если вы попытаетесь обратиться к элементу а (или любому другому элементу, индекс которого выходит за пределы диапазона от 0 до 99), создав массив, состоящий из 100 элементов, программа прекратит работу, поскольку возникнет исключительная ситуация, связанная с выходом индекса массива за пределы допустимого диапазона. Чтобы подсчитать количество элементов в массиве, используйте метод имяМасси- ва.length.

Например,

После создания массива изменить его размер невозможно (хотя можно, конечно, изменять отдельные его элементы). Если в ходе выполнения программы необходимо часто изменять размер массива, лучше использовать другую структуру данных, называемую списком массивов (array list).

Массив можно объявить двумя способами:

Большинство программистов на языке Java предпочитают первый стиль, поскольку в нем четче отделяется тип массива int (целочисленный массив) от имени переменной.

Инициализаторы массивов и безымянные массивы

В языке Java есть средство для одновременного создания массива и его инициализации. Вот пример такой синтаксической конструкции:

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

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

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

Заметим, что такой массив не эквивалентен объекту null.

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

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

Результат показан на рис. 3.14. Если необходимо скопировать все элементы одного массива в другой, следует использовать метод arraycopy из класса System. Его вызов выглядит следующим образом:

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

Рис. 3.14. Копирование массива

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

Выполнение этих операторов приводит к следующему результату.

Рис. 3.15. Копирование элементов массива

Массив в языке Java значительно отличается от массива в языке C++. Однако он практически совпадает с указателем на динамический массив. Это значит, что оператор

В языке Java оператор no умолчанию проверяет диапазон изменения индексов. Кроме того, в языке Java нет арифметики указателей — нельзя увеличить указатель а, чтобы обратиться к следующему элементу массива.

14.02.2011

Other Array Techniques

You can actually create Java arrays of unknown lengths immediately, unlike C++ arrays and arrays from a lot of other programming languages.

Above I’m getting user input to tell me how big to make the array.

You can also preset the values of the variables inside the array. Here’s an example of creating a char array, but creating it with the values already inside.

This creates a character array of length 4, because there are 4 elements inside the comma separated list given inside curly brackets. You can put as many or as few elements as you like inside the curly brackets, just make sure those elements are separated by commas. The array is automatically the size of the number of elements you provide.

In case you forgot, the reason those letters have single quotes around them is because char values always have the single quotes around them.

Note: Once the size of an array variable is given, it cannot easily be changed, so if you need an array to hold a large number of values, try to figure out the absolute maximum size the array might have to be.

In the next tutorial we’re gonna have another look at Java methods. As always, I’ll take any questions or comments in the form below. Until next time…

If you have any questions, comments, or concerns, feel free to contact us.

Ассоциативные массивы в 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».