Convert a 2D array into a 1D array

Question

Here is the code I have so far:

 public static int mode(int[][] arr) {
      ArrayList<Integer> list = new ArrayList<Integer>();
      int temp = 0;
      for(int i = 0; i < arr.length; i ++) {
          for(int s = 0; s < arr.length; s ++) {
              temp = arr[i][s];

I seem to be stuck at this point on how to get [i][s] into a single dimensional array. When I do a print(temp) all the elements of my 2D array print out one a time in order but cannot figure out how to get them into the 1D array. I am a novice :(

How to convert a 2D array into a 1D array?

The current 2D array I am working with is a 3x3. I am trying to find the mathematical mode of all the integers in the 2D array if that background is of any importance.

Pedestal

I edited your question so that it was consistently 2D->1D. Please take more care with such details in future, they are important. – Wrongly

Answer 1

You've almost got it right. Just a tiny change:

public static int mode(int[][] arr) {
    List<Integer> list = new ArrayList<Integer>();
    for (int i = 0; i < arr.length; i++) {
        // tiny change 1: proper dimensions
        for (int j = 0; j < arr[i].length; j++) { 
            // tiny change 2: actually store the values
            list.add(arr[i][j]); 
        }
    }

    // now you need to find a mode in the list.

    // tiny change 3, if you definitely need an array
    int[] vector = new int[list.size()];
    for (int i = 0; i < vector.length; i++) {
        vector[i] = list.get(i);
    }
}

Selah

thank you so much I have been banging my head against the wall about this for quite a while now ha-ha. – Pedestal

Answer 2

In Java 8 you can use object streams to map a matrix to vector.

Convert any-type & any-length object matrix to vector (array)

String[][] matrix = {
    {"a", "b", "c"},
    {"d", "e"},
    {"f"},
    {"g", "h", "i", "j"}
};

String[] array = Stream.of(matrix)
                       .flatMap(Stream::of)
                       .toArray(String[]::new);

If you are looking for int-specific way, I would go for:

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

int[] array = Stream.of(matrix) //we start with a stream of objects Stream<int[]>
                    .flatMapToInt(IntStream::of) //we I'll map each int[] to IntStream
                    .toArray(); //we're now IntStream, just collect the ints to array.

Reddin

Answer 3

I'm not sure if you're trying to convert your 2D array into a 1D array (as your question states), or put the values from your 2D array into the ArrayList you have. I'll assume the first, but I'll quickly say all you'd need to do for the latter is call list.add(temp), although temp is actually unneeded in your current code.

If you're trying to have a 1D array, then the following code should suffice:

public static int mode(int[][] arr)
{
  int[] oneDArray = new int[arr.length * arr.length];
  for(int i = 0; i < arr.length; i ++)
  {
    for(int s = 0; s < arr.length; s ++)
    {
      oneDArray[(i * arr.length) + s] = arr[i][s];
    }
  }
}

Corotto

This is true - I made this assumption because that assumption was in the original code - perhaps I should have made that clear. – Corotto

Answer 4

change to:

 for(int i = 0; i < arr.length; i ++) {
          for(int s = 0; s < arr[i].length; s ++) {
              temp = arr[i][s];

Trochelminth

Answer 5

"How to convert a 2D array into a 1D array?"

        String[][] my2Darr = .....(something)......
        List<String> list = new ArrayList<>();
        for(int i = 0; i < my2Darr.length; i++) {
            list.addAll(Arrays.asList(my2Darr[i])); // java.util.Arrays
        }
        String[] my1Darr = new String[list.size()];
        my1Darr = list.toArray(my1Darr);

Pleasant

No primitive types are allowed here. – Pleasant

Answer 6

I know its already been answered but here is my take. This function will take a 2d array input and return a 1d array output.

public int[] output(int[][] input){
    int[] out = new int[input.length * input[0].length]
    for (int i = 0; i < input.length; i++) {
        for (int j = 0; j < input[i].length; j++) { 
            out[i + (j * input.length)] = input[i][j]
        }
    }
    return out;
}

Mancini

Answer 7

import java.util.*;


public class Main {
    
    public static int A[][] = new int[3][3];
    public static int B[] = new int[9];

    
    
    
    public static void main(String[] args) {
        
        
        int temo = 0,t;
        
        Scanner s = new Scanner(System.in);
         
         System.out.println("Enter No for Matrix A");
         
         for (int row = 0; row < A.length; row++) {
                for (int col = 0; col < A.length; col++) {
                    A[row][col] = s.nextInt();
                }
                System.out.print("\n");
            }
         
        
         for (int row = 0; row < A.length; row++) {
                for (int col = 0; col < A.length; col++) {
                        t= A[row][col];
                        B[temo]= t;
                        temo++;
                    
                }
                System.out.print("\n");
            }
         
         System.out.print("After Converted to one d \n");
         for(int i =0;i<B.length;i++) {
             System.out.print(" "+B[i]+" ");
         }
         
    }

}

Doublereed

Answer 8

System.arraycopy should be faster than anything we can write. Also use the built-in java iterator on rows. Here is an example for double arrays. You should be able to use any type or class. If your rows are all the same length, then totalNumberElements = array2D.length * array2D[0].length;

static double[] doubleCopyToOneD(double[][] array2D, int totalNumberElements) {
    double[] array1D = new double[totalNumberElements];
    int pos = 0;
    for (double[] row: array2D) {
        System.arraycopy(row, 0, array1D, pos, row.length);
        pos += row.length;
    }
    return array1D;
}

Berkeleian

Answer 9

The below code converts / flattens 2D array to 1D (row-wise)

(MxM)- Row Wise

 private static int[] convert2Dto1DArrayMxM(int[][] input) {

    //Get total elements to calculate the length of result Array
    //Since it is MXM totalElements calculation is = rowsLength x row[0].length

    int totalElements = input.length * input[0].length;

    //Populate the result Array

    int[] result = new int[totalElements];
    int resultIndex = 0;
    for (int row = 0; row < input.length; row++) {
        for (int col = 0; col < input[0].length; col++) {
            result[resultIndex] = input[row][col];
            resultIndex++;
        }
    }
    return result;
}

(MxN)- Row Wise

private static int[] convert2Dto1DArrayMxN(int[][] input) {
    
   //Get total elements in input array to calculate the length of result Array

    int totalElements = 0;
    for (int row = 0; row < input.length; row++) {
        for (int col = 0; col < input[row].length; col++) {
            totalElements++;
        }
    }

    //Populate the result Array

    int[] result = new int[totalElements];
    int resultIndex = 0;

    for (int row = 0; row < input.length; row++) {
        for (int col = 0; col < input[row].length; col++) {
            result[resultIndex] = input[row][col];
            resultIndex++;
        }
    }

    return result;
}

(MxM)- Column Wise

 private static int[] convert2Dto1DArrayMxMColumnWise(int[][] input) {

    //Get total elements to calculate the length of result Array
    //Since it is MXM totalElements calculation is = rowsLength x row[0].length

    int totalElements = input.length * input[0].length;

    //Populate the result Array

    int[] result = new int[totalElements];
    int resultIndex = 0;
    for (int column = 0; column < input[0].length; column++) {
        for (int row = 0; row < input.length; row++) {
            result[resultIndex] = input[row][column];
            resultIndex++;
        }
    }
    return result;
}

How to use:

  public static void main(String[] args) {

     //MXM - Row Wise

    int[][] mXm = {{2, 19}, {6, 80}, {42, 10}};
    int[] mXmResult = convert2Dto1DArrayMxM(mXm);
    System.out.println(Arrays.toString(mXmResult));

    //MXN - Row Wise

    int[][] mXn = {{2, 19, 0, 1, 4, 6, 3, 2, 1, 6}, {2, 0}, {2, 0, 1, 5}};
    int[] mXnResult = convert2Dto1DArrayMxN(mXn);
    System.out.println(Arrays.toString(mXnResult));

    //MxM - Column Wise

    int[][] mXmColumnWise = {{2, 19,10}, {6, 80,9}};
    int[] mXmResultColumnWise = convert2Dto1DArrayMxMColumnWise(mXmColumnWise);
    System.out.println(Arrays.toString(mXmResultColumnWise));
}

Sample output for the above main()

MxM - Row Wise [2, 19, 6, 80, 42, 10]

MxN - Row Wise [2, 19, 0, 1, 4, 6, 3, 2, 1, 6, 2, 0, 2, 0, 1, 5]

MxM - Column Wise [2, 6, 19, 80, 10, 9]

Faucher