Как найти размер двумерного массива java

I need to get the length of a 2D array for both the row and column. I’ve successfully done this, using the following code:

public class MyClass {

 public static void main(String args[])
    {
  int[][] test; 
  test = new int[5][10];

  int row = test.length;
  int col = test[0].length;

  System.out.println(row);
  System.out.println(col);
    }
}

This prints out 5, 10 as expected.

Now take a look at this line:

  int col = test[0].length;

Notice that I actually have to reference a particular row, in order to get the column length. To me, this seems incredibly ugly. Additionally, if the array was defined as:

test = new int[0][10];

Then the code would fail when trying to get the length. Is there a different (more intelligent) way to do this?

robert_x44

9,1841 gold badge32 silver badges37 bronze badges

asked Oct 22, 2010 at 19:15

Consider

public static void main(String[] args) {

    int[][] foo = new int[][] {
        new int[] { 1, 2, 3 },
        new int[] { 1, 2, 3, 4},
    };

    System.out.println(foo.length); //2
    System.out.println(foo[0].length); //3
    System.out.println(foo[1].length); //4
}

Column lengths differ per row. If you’re backing some data by a fixed size 2D array, then provide getters to the fixed values in a wrapper class.

answered Oct 22, 2010 at 19:21

NG.NG.

22.5k5 gold badges55 silver badges61 bronze badges

A 2D array is not a rectangular grid. Or maybe better, there is no such thing as a 2D array in Java.

import java.util.Arrays;

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

    int[][] test; 
    test = new int[5][];//'2D array'
    for (int i=0;i<test.length;i++)
      test[i] = new int[i];

    System.out.println(Arrays.deepToString(test));

    Object[] test2; 
    test2 = new Object[5];//array of objects
    for (int i=0;i<test2.length;i++)
      test2[i] = new int[i];//array is a object too

    System.out.println(Arrays.deepToString(test2));
  }
}

Outputs

[[], [0], [0, 0], [0, 0, 0], [0, 0, 0, 0]]
[[], [0], [0, 0], [0, 0, 0], [0, 0, 0, 0]]

The arrays test and test2 are (more or less) the same.

answered Oct 22, 2010 at 19:35

IshtarIshtar

11.5k1 gold badge24 silver badges31 bronze badges

It was really hard to remember that

    int numberOfColumns = arr.length;
    int numberOfRows = arr[0].length;

Let’s understand why this is so and how we can figure this out when we’re given an array problem. From the below code we can see that rows = 4 and columns = 3:

    int[][] arr = { {1, 1, 1, 1}, 

                    {2, 2, 2, 2}, 

                    {3, 3, 3, 3} };

arr has multiple arrays in it, and these arrays can be arranged in a vertical manner to get the number of columns. To get the number of rows, we need to access the first array and consider its length. In this case, we access [1, 1, 1, 1] and thus, the number of rows = 4. When you’re given a problem where you can’t see the array, you can visualize the array as a rectangle with n X m dimensions and conclude that we can get the number of rows by accessing the first array then its length. The other one (arr.length) is for the columns.

answered Jan 23, 2019 at 16:00

gocodegocode

3553 silver badges9 bronze badges

Java allows you to create «ragged arrays» where each «row» has different lengths. If you know you have a square array, you can use your code modified to protect against an empty array like this:

if (row > 0) col = test[0].length;

answered Oct 22, 2010 at 19:21

robert_x44robert_x44

9,1841 gold badge32 silver badges37 bronze badges

If you have this array:

String [][] example = {{{"Please!", "Thanks"}, {"Hello!", "Hey", "Hi!"}},
                       {{"Why?", "Where?", "When?", "Who?"}, {"Yes!"}}};

You can do this:

example.length;

= 2

example[0].length;

= 2

example[1].length;

= 2

example[0][1].length;

= 3

example[1][0].length;

= 4

answered Oct 3, 2017 at 15:15

There’s not a cleaner way at the language level because not all multidimensional arrays are rectangular. Sometimes jagged (differing column lengths) arrays are necessary.

You could easy create your own class to abstract the functionality you need.

If you aren’t limited to arrays, then perhaps some of the various collection classes would work as well, like a Multimap.

answered Oct 22, 2010 at 19:23

kaliatechkaliatech

17.5k4 gold badges68 silver badges83 bronze badges

.length = number of rows / column length

[0].length = number of columns / row length

answered May 16, 2019 at 15:18

Example Array 1:

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

Example Array 2:

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

Below function will work for any Symmetric and Asymmetric Array Matrix


 row_Count = arr.length
 column_Count = arr[0].length

Viral

2673 silver badges11 bronze badges

answered Jun 7, 2021 at 7:16

Try this following program for 2d array in java:

public class ArrayTwo2 {
    public static void main(String[] args) throws  IOException,NumberFormatException{
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        int[][] a;
        int sum=0;
        a=new int[3][2];
        System.out.println("Enter array with 5 elements");
        for(int i=0;i<a.length;i++)
        {
            for(int j=0;j<a[0].length;j++)
            {
            a[i][j]=Integer.parseInt(br.readLine());
            }
        }
        for(int i=0;i<a.length;i++)
        {
            for(int j=0;j<a[0].length;j++)
            {
            System.out.print(a[i][j]+"  ");
            sum=sum+a[i][j];
            }
        System.out.println();   
        //System.out.println("Array Sum: "+sum);
        sum=0;
        }
    }
}

abpatil

91616 silver badges20 bronze badges

answered Jan 11, 2017 at 5:20

import java.util.Arrays;

public class Main {

    public static void main(String[] args) 
    {

        double[][] test = { {100}, {200}, {300}, {400}, {500}, {600}, {700}, {800}, {900}, {1000}};

        int [][] removeRow = { {0}, {1}, {3}, {4}, };

        double[][] newTest = new double[test.length - removeRow.length][test[0].length];

        for (int i = 0, j = 0, k = 0; i < test.length; i++) {
            if (j < removeRow.length) {
                if (i == removeRow[j][0]) {
                    j++;
                    continue;
                }
            }
            newTest[k][0] = test[i][0];
            k++;
        }

        System.out.println(Arrays.deepToString(newTest));   
    }
}

Feedforward

4,4714 gold badges22 silver badges34 bronze badges

answered Nov 11, 2018 at 16:54

With Java 8, allow you doing something more elegant like this:

int[][] foo = new int[][] {
        new int[] { 1, 2, 3 },
        new int[] { 1, 2, 3, 4},
    };

int length = Arrays.stream(array).max(Comparator.comparingInt(ArrayUtils::getLength)).get().length

answered May 8, 2020 at 15:06

logbasexlogbasex

1,5521 gold badge15 silver badges21 bronze badges

int rows=arr.length; //For knowing No of rows

int cols=arr[0].length; //For Knowing No of columns

Run This code… and Understand…

public class Store2darrays {   

    public static void main(String args[]) {
      int[]arr={1,2,3,4};
      System.out.println(arr.length);
      int[][] arr2d={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
      System.out.println(arr2d.length);
      System.out.println(arr2d);
      System.out.println(arr2d[0]);
      System.out.println(arr2d[1]);
      System.out.println(arr2d.length);
      System.out.println(arr2d[0].length); }
}

Rohit Gupta

4,01219 gold badges31 silver badges41 bronze badges

answered Nov 6, 2022 at 18:05

public class Array_2D {
int arr[][];
public Array_2D() {
    Random r=new Random(10);
     arr = new int[5][10];
     for(int i=0;i<5;i++)
     {
         for(int j=0;j<10;j++)
         {
             arr[i][j]=(int)r.nextInt(10);
         }
     }
 }
  public void display()
  {
         for(int i=0;i<5;i++)

         {
             for(int j=0;j<10;j++)
             {
                 System.out.print(arr[i][j]+" "); 
             }
             System.out.println("");
         }
   }
     public static void main(String[] args) {
     Array_2D s=new Array_2D();
     s.display();
   }  
  }

answered Apr 20, 2017 at 13:00

Источник

//initializing few values
int[][] tab = new int[][]{
    {1,0,1,0,1,0,1,0},
    {0,1,0,1,0,1,0,1},
    {1,0,1,0,1,0,1,0},
    {0,1,0,1,0,1,0,1},
    {1,0,1,0,1,0,1,0},
    {0,1,0,1,0,1,0,1},
    {1,0,1,0,1,0,1,0},
    {0,1,0,1,0,1,0,1}
};

//tab.length in first loop
for (int row = 0; row < tab.length; row++)
{
    //tab[0].length in second loop
    for (int column = 0; column < tab[0].length; column++)
    {
        //printing one value from array with space
        System.out.print(tab[row][column]+ "   ");
    }
    System.out.println(); // new row = new enter
}

Источник

Ответы

С помощью length :

        int rows = 10;
        int columns = 5;
        int[][] arr = new int[rows][columns];

        System.out.println("Строк : " + arr.length);   // => Строк : 10
        System.out.println("Колонок : " + arr[0].length);   // => Колонок : 5

0

0

Добавьте ваш ответ

Задача

Как узнать размер двумерного массива в Java?

Решение

Следующий пример помогает определить размер двумерного массива с использованием arrayname.length.

public class Main {
   public static void main(String args[]) {
      String[][] data = new String[2][5];
      System.out.println("Измерение 1: " + data.length);
      System.out.println("Измерение 2: " + data[0].length);
   }
}

Результат

Вышеприведенный пример кода даст следующий результат:

Измерение 1: 2
Измерение 2: 5

Источник: Java Examples — Dimension of Array.

Источник

#База знаний

20 фев 2021
17

Учимся работать с массивами в Java. Всё разбираем на примерах.

vlada_maestro / shutterstock

Java-разработчик, преподаёт в Skillbox, осваивает машинное обучение.

Массив в Java (Java Array) — это структура данных, которая хранит набор пронумерованных значений одного типа (элементы массива).

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


int mark1 = 4;
int mark2 = 3;
int mark3 = 5;
int mark4 = 3;
int mark5 = 2;
int mark6 = 4;
int mark7 = 4;
int mark8 = 3;
int mark9 = 4;
int mark10 = 2;

А если в нашем классе будет не десяток учеников, а в десять раз больше, не заводить же нам 100 переменных! На выручку приходят массивы.

В Java массив объявляется с помощью квадратных скобок и специального слова new.

Такой вот синтаксис пришёл из языка C:


тип_массива название_переменной[] = new тип_массива[размер_массива];

Но в Java предпочтительнее делать так:


тип_массива[] название_переменной = new тип_массива[размер_массива];

Тип массива может быть любым (int, Integer, String, Date, byte, char, Long и так далее).

Объявим массив типа int из 10 элементов:


int[] marks = new int[10];

При подобной инициализации все элементы массива будут иметь значение по умолчанию. Для int это 0; для float и double — 0.0; для char — ; для boolean — false, а для String и любого другого класса это null.

В Java размер массива (длина, протяжённость) определяется при объявлении, а изменить его можно только пересоздав массив.

Начнём с одномерного массива. Каждый элемент в нём хранится под своим индексом.

Важно помнить, что в Java нумерация элементов массива начинается с 0. Поэтому индекс первого элемента равен 0, а у последнего определяется размером массива минус один.

Для доступа к элементу массива указывают имя массива и номер ячейки в квадратных скобках. Например, обратимся к первому элементу массива и выведем его значение:


int[] marks = new int[10];
System.out.println(marks[0]);

--OUTPUT> 0

В консоли мы получим число 0. Почему ноль — читайте выше, в пункте про инициализацию по умолчанию.

Заполним элементы массива. Для этого обратимся к каждому по индексу и присвоим значения с помощью оператора «=»:


int[] marks = new int[10];
marks[0] = 5;
marks[1] = 3;
marks[2] = 5;
marks[3] = 3;
marks[4] = 4;
marks[5] = 4;
marks[6] = 3;
marks[7] = 2;
marks[8] = 5;
marks[9] = 4;

Теперь у нас есть массив, куда мы записали оценки десяти учеников. С этим уже удобнее работать, чем объявлять 10 переменных, но можно записать ещё короче:


int[] marks = new int[] {5, 3, 5, 3, 4, 4, 3, 2, 5, 4};

Мы опустили размер массива, поставили фигурные скобки после квадратных и перечислили все значения через запятую. Размер массива теперь определяется числом элементов в фигурных скобках (в нашем случае их тоже 10).

Но нет предела совершенству:


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

После знака «=» остались только фигурные скобки с перечислением значений через запятую.

У массива в Java есть специальное поле length. Значение в нём нельзя изменить. Оно возвращает число элементов массива:


int[] marks = {5, 3, 5, 3, 4, 4, 3, 2, 5, 4};
System.out.println("Всего оценок: " + marks.length);

--OUTPUT> Всего оценок: 10

А раз мы знаем длину массива и что все его ячейки упорядочены, то остаётся обратиться к ним по очереди — в цикле:


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

for (int i = 0; i < marks.length; i++) {
   System.out.printf("Ученик №%d: оценка %d%n", (i + 1), marks[i]);
}

--OUTPUT> Ученик №1: оценка 5
--OUTPUT> Ученик №2: оценка 3
--OUTPUT> Ученик №3: оценка 5
--OUTPUT> Ученик №4: оценка 3
--OUTPUT> Ученик №5: оценка 4
--OUTPUT> Ученик №6: оценка 4
--OUTPUT> Ученик №7: оценка 3
--OUTPUT> Ученик №8: оценка 2
--OUTPUT> Ученик №9: оценка 5
--OUTPUT> Ученик №10: оценка 4

С помощью счётчика в цикле for мы получаем индекс каждого элемента.

Напомним! Счётчик должен стартовать с 0, так как нумерация в массиве тоже начинается с 0.

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

Вот ещё пример:


int[] marks = {5, 3, 4};
String[] names = {"Вася", "Петя", "Маша"};

for (int i = 0; i < marks.length; i++) {
   System.out.printf("%s получает оценку %d%n", names[i], marks[i]);
}

--OUTPUT> Вася получает оценку 5
--OUTPUT> Петя получает оценку 3
--OUTPUT> Маша получает оценку 5

Массив можно обойти и в цикле foreach (подробнее о циклах):


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

for (int mark : marks) {
   System.out.printf("Оценка %d%n", mark);
}
--OUTPUT> Оценка 5
--OUTPUT> Оценка 3
--OUTPUT> Оценка 5
--OUTPUT> Оценка 3
--OUTPUT> Оценка 4
--OUTPUT> Оценка 4
--OUTPUT> Оценка 3
--OUTPUT> Оценка 2
--OUTPUT> Оценка 5
--OUTPUT> Оценка 4

И в обратном порядке:


int[] marks = {5, 3, 5, 3, 4, 4, 3, 2, 5, 4};
for (int i = marks.length - 1; i >= 0; i--) {
   System.out.printf("Ученик №%d: оценка %d%n", (i + 1), marks[i]);
}

Здесь счётчик стартует со значения на один меньше размера массива, и цикл продолжается «пока счётчик не меньше 0».

Можем пройтись и только по элементам с чётными индексами:


int[] marks = {5, 3, 5, 3, 4, 4, 3, 2, 5, 4};
for (int i = 0; i < marks.length; i += 2) {
   System.out.printf("Ученик №%d: оценка %d%n", (i + 1), marks[i]);
}

А вот как заполнить массив случайными значениями:


int[] marks = new int[10];
Random random = new Random();
for (int i = 0; i < marks.length; i ++) {
   marks[i] = 2 + random.nextInt(4);
}

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

Массивы бывают одномерными (векторы), двумерными (матрицы), трёхмерными и так далее. То есть можно создавать не просто массивы, но и массивы массивов, а также массивы массивов массивов и так далее.

Рассмотрим вариант с двумерным массивом. Остальные многомерные массивы создаются похоже.

Чтобы создать двумерный массив в Java, укажем его размеры в квадратных скобках:


int[][] mas = new int[3][4];

Доступ к элементу подобного массива выглядит так:


int[][] mas = new int[3][4];
mas[0][1] = 2;

Мы присвоили значение 2 элементу с индексами [0,1].

Для простоты представим двумерный массив в виде таблицы. Вот как выглядит наш массив (столбцы — это первый индекс в квадратных скобках, а строки — второй):

[0,0] = 0	[1,0] = 0	[2,0] = 0
[0,1] = 2	[1,1] = 0	[2,1] = 0
[0,2] = 0	[1,2] = 0	[2,2] = 0
[0,3] = 0	[1,3] = 0	[2,3] = 0

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

Массивы внутри массива в Java могут быть разной длины. Зададим двумерный массив, где размер третьего массива (по индексу второго) равен двум элементам, а размер всех остальных — трём:


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

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

Если мы объявляем двумерный массив так:


int[][] mas = new int[3][4];

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

А теперь заменим массив под индексом 1 (длиной в четыре элемента) массивом из двух элементов:


int[][] mas = new int[3][4];
mas[1] = new int[2];

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

Проверим, что размер массива под индексом 1 теперь равен двум элементам. Для этого используем цикл с выводом в консоль:


for (int i = 0; i < mas.length; i++) {
   System.out.printf("Индекс массива в двумерном массиве: %d; длина массива: %d%n", i, mas[i].length);
}

--OUTPUT> Индекс массива в двумерном массиве: 0; длина массива: 4
--OUTPUT> Индекс массива в двумерном массиве: 1; длина массива: 2
--OUTPUT> Индекс массива в двумерном массиве: 2; длина массива: 4

Для обхода элементов двумерного массива применяем уже два цикла:


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

Если длины измерений (строк и столбцов) двумерного массива равны, то он называется квадратной матрицей.

Пример создания квадратной матрицы:


int[][] mas = new int[3][3];

Поворот квадратной матрицы на 90 градусов по часовой стрелке:


int[][] mas = {
       {1, 2, 3},
       {4, 5, 6},
       {7, 8, 9}};
for (int i = 0; i < mas.length / 2; i++) {
   int n = mas.length - 1;
   for (int j = i; j < mas.length - i - 1; j++) {
       int temp = mas[i][j];
       mas[i][j] = mas[n - j][i];
       mas[n - j][i] = mas[n - i][n - j];
       mas[n - i][n - j] = mas[j][n - i];
       mas[j][n - i] = temp;
   }
}

И против часовой:


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

for (int i = 0; i < mas.length / 2; i++) {
   int n = mas.length - 1;
   for (int j = i; j < mas.length - i - 1; j++) {
       int temp = mas[i][j];
       mas[i][j] = mas[j][n - i];
       mas[j][n - i] = mas[n - i][n - j];
       mas[n - i][n - j] = mas[n - j][i];
       mas[n - j][i] = temp;
   }
}

Пример создания трёхмерного массива (кубический массив):


int[][][] mas = {{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, {{10, 11, 12}, {13, 14, 15}, {16, 17, 18}}, {{19, 20, 21}, {22, 23, 24}, {25, 26, 27}}};

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

Например, вывести массив в консоль помогает метод Arrays.toString:


int[] mas = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(mas));

А можно сделать из массива stream и работать со stream api:


int[] mas = {1, 2, 3, 4, 5, 6};
Arrays.stream(mas);

Чтобы скопировать один массив в другой, есть метод System.arraycopy. Заменим кусок одного массива частью другого:


int[] mas = {1, 2, 3, 4, 5, 6};
int[] mas2 = new int[2];

System.arraycopy(mas, 3, mas2, 0, 2);

System.out.println(Arrays.toString(mas2));

Из массива mas мы копируем элементы в массив mas2, начиная с индекса под номером 3. Копируем два элемента, поэтому в массиве mas2 окажутся числа 4 и 5.

У массива есть имя, тип [элементов] и размер.
Размер задаётся целочисленным значением, изменить его нельзя.
Доступ к элементам происходит по их индексам.
Нумерация в массиве начинается с 0.
При создании массива с помощью new его ячейки заполняются значением по умолчанию.

Научитесь: Профессия Java-developer PRO
Узнать больше

Источник

If you have this array:

You can do this:

Рекомендуемые курсы

Похожие вопросы

Задача

Решение

Результат