How to flatten 2D array to 1D array?

How can I flatten the 2 dimensions array int originalArra开发者_如何学JAVAy[][] to 1 dimension array?

    int a [] = {1,2,6,7,2};
    int b [] = {2,44,55,2};
    int c [] = {2,44,511,33};

    int originalArray [][] = new int[][]{a,b,c};

With Guava, you can use either

int[] all = Ints.concat(originalArray);

or

int[] all = Ints.concat(a, b, c);

With Java 8 you can "flatMap" the inner arrays:

int[] flatArray = Arrays.stream(originalArray)
        .flatMapToInt(Arrays::stream)
        .toArray();

or:

int[] flatArray = Stream.of(a, b, c)
        .flatMapToInt(Arrays::stream)
        .toArray();

A simple for loop will do, it is not difficult, but will depend on the order in which you want to copy the values. For instance (based on the fact that in your example the arrays all have the same length):

int[] newArray = new int[3 * a.length];
int index = 0;
for (int n = 0; n < a.length; n++) {
    newArray[index++] = a[n];
    newArray[index++] = b[n];
    newArray[index++] = c[n];
}

or (different order, a, b, c can be of different lengths):

int[] newArray = new int[a.length + b.length + c.length];
System.arraycopy(a, 0, newArray, 0, a.length);
System.arraycopy(b, 0, newArray, a.length, b.length);
System.arraycopy(c, 0, newArray, a.length + b.length, c.length);

There will be 2 steps:

1) find out total number of elements to create a new vector (1d array)

2) iterate through your 2d array in predefined order and copy its elements to the created vector

int elementsNumber = 0;

for (int i = 0; i < originalArray.length; i++) {
   elementsNumber += originalArray[i].length;
}

int[] newArray = new int[elementsNumber];
int j = 0;
for (int i = 0; i < originalArray.length; i++) {
   System.arrayCopy (originalArray[i], 0, newArray, j, originalArray[i].length);
   j += originalArray[i].length;
}

int[] oneDArray = new int[arr.length*arr.length];
    //Flatten 2D array to 1D array...
    int s = 0;
    for(int i = 0; i < arr.length; i ++) 
          for(int j = 0; j < arr.length; j ++){                           
              oneDArray[s] = arr[i][j];
              s++;
          } 

Since arrays can't be extended (i.e. you have to declare the size of an error upon initialization), you have to traverse the arrays twice:

int size = 0;
for (int[] ar : originalArray) size += ar.length;
int[] result = new int[size];
int pos = 0;
for (int[] ar : originalArray) {
    System.arraycopy(ar, 0, result, pos, ar.length);
    pos += ar.length;
}

one-liner with IntStream

IntStream.concat(
    IntStream.concat( IntStream.of(originalArray[0]), IntStream.of(originalArray[1]) ),
        IntStream.of(originalArray[2]) ).toArray();

gets: [1, 2, 6, 7, 2, 2, 44, 55, 2, 2, 44, 511, 33]

below code can merge varied 2D arrays (diff sizes of internal array) into a one dimensional array:

 public static Integer[] merge2DArrays(int[][] twoDArray){
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < twoDArray.length; i++) {
            for (int j = 0; j < twoDArray[i].length; j++) {
                list.add(twoDArray[i][j]);
            }
        }
    return list.toArray(new Integer[list.size()]);
    }

Count the total number of elements in originalArray. Create new array of that length. Copy elements one by one into the new array.

I am unfamiliar with any library function to do so.