how to split a 2d array into multiple 2d arrays of different sized in java

Question

I have a 6*6 2d array called pixels

  int [][] pixels = { {1,2,7,9,4,11},
                    {3,4,6,6,12,12},
                    {4,9,15,14,9,9},
                    {10,10,20,18,8,8},
                    {4,3,17,16,1,4},
                    {4,5,18,18,5,6}
            };

and I want to store its data into 9 2d arrays of size 2*2 like this

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

    int [][] array2 = {{7,9},
            {6,6}
    };

    int [][] array3 = {{4,11},
            {12,12}
    };

and like this, I have another 2d array of size 320 * 320 which I want to store its data in 6400 2d arrays of size 44 and I don't know what is the dynamic to do. my for loops aren't right. Can anyone help? edit: I tried this code and it gives me the right result regrading the first array of the 2d array but I'm not sure about the second one. vectorHeight is 4. the big 2d array size is 320 320 and the smaller ones size is 4 * 4

for(int j=0; j < 320  ; j++){
            for(int i=0; i< 320 ; i++){
                int[][] array = new int[][]{
                        {pixels2[j * vectorHeight][i * vectorHeight], pixels2[j * vectorHeight][(i * vectorHeight) + 1],pixels2[j * vectorHeight][(i * vectorHeight) + 2],pixels2[j * vectorHeight][(i * vectorHeight) + 3]},
                        {pixels2[(j * vectorHeight) + 1][i * vectorHeight], pixels2[(j * vectorHeight) + 1][(i * vectorHeight) + 1],pixels2[(j * vectorHeight) + 2][(i * vectorHeight) + 2],pixels2[(j * vectorHeight) + 3][(i * vectorHeight) + 3]},
                };
                         System.out.println(Arrays.deepToString(array));
                }
            }

edit2: the 320 * 320 2d array is a result of a function that takes an image and return the pixels vector so this is the code for reading an image:

public static int[][] readImage(String filePath) {
        File file = new File(filePath);
        BufferedImage image = null;
        try {
            image = ImageIO.read(file);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
        int width = image.getWidth();
        int height = image.getHeight();
        int[][] pixels = new int[height][width];
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                int p = image.getRGB(x, y);
                int a = (p >> 24) & 0xff;
                int r = (p >> 16) & 0xff;
                int g = (p >> 8) & 0xff;
                int b = p & 0xff;

                pixels[y][x] = r;

                p = (a << 24) | (r << 16) | (g << 8) | b;
                image.setRGB(x, y, p);
            }

        }

        return pixels;
    }

and the image that I am currently working on is this one https://www.researchgate.net/profile/Ayman-Al-Dmour/publication/304496637/figure/fig1/AS:377628822392833@1467045135613/Test-images_Q320.jpg the rest of the code is a function that takes an image, a vector size - height and weight- and eventually its suppose to compress it using vector quantization

int [][] pixels = readImage(filePath);
int numofVectors1 = (pixels.length * pixels.length) / (vectorHeight * vectorWidth);
        ArrayList<int[][]> vectors = new ArrayList<>(numofVectors1);
         for (int j = 0; j < pixels.length; j++) {
                for (int i = 0; i < pixels.length; i++) {
                    int[][] array = new int[][]{
                            {pixels[j * vectorHeight][i * vectorHeight], pixels[j * vectorHeight][(i * vectorHeight) + 1], pixels[j * vectorHeight][(i * vectorHeight) + 2], pixels[j * vectorHeight][(i * vectorHeight) + 3]},
                            {pixels[(j * vectorHeight) + 1][i * vectorHeight], pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 1], pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 2], pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 3]},
                    };
                    vectors.add(array);
                }

        }

"my for loops aren't right" post your code so we can help you — Enrico
– Enrico, Commented Dec 10, 2021 at 17:26
I tried but all my loops were so wrong so they were deleted. — Doha Ramadan
– Doha Ramadan, Commented Dec 10, 2021 at 17:27

Enrico · Accepted Answer · 2021-12-11 16:39:47Z

2

In your case it's helpful to write down what you want:

         [0][0] [0][1] [1][0] [1][1]
         [0][2] [0][3] [1][2] [1][3]
         [0][4] [0][5] [1][4] [1][5]

         [2][0] [2][1] [3][0] [3][1]
         [2][2] [2][3] [3][2] [3][3]
         [2][4] [2][5] [3][4] [3][5]

         [4][0] [4][1] [5][0] [5][1]
         [4][2] [4][3] [5][2] [5][3]
         [4][4] [4][5] [5][4] [5][5]

Maybe you can already see a pattern here. First, I created the inner loop for the first three lines:

for (int i = 0; i < 3; i++) {
    int[][] array = new int[][]{
            {pixels[0][i * 2], pixels[0][(i * 2) + 1]},
            {pixels[1][i * 2], pixels[1][(i * 2) + 1]}
    };
    System.out.println(Arrays.deepToString(array));
}

As you see, it's always the zeroth and first row for the first three lines. And in the next three lines, it's always the second and thrird row. And the rule for all columns is that it's always zero, two, four and one, three, five.

So it comes to the nested loop:

for (int j = 0; j < 3; j++) {
    for (int i = 0; i < 3; i++) {
        int[][] array = new int[][]{
            {pixels[j * 2][i * 2], pixels[j * 2][(i * 2) + 1]},
            {pixels[(j * 2) + 1][i * 2], pixels[(j * 2) + 1][(i * 2) + 1]}};
        System.out.println(Arrays.deepToString(array));
    }
}

Now you can store the created arrays for example in a list.

EDIT

Sorry, I think I made a mistake. This should do what you want: create 6400 4x4 arrays. So you have to loop until the square root of the number of arrays you want(in this case 6400). Do you have a possibility to check if the arrays are correct now? Try this:

int vectorHeight = 4, vectorWidth = 4;
int numofVectors1 = (pixels.length * pixels.length) / (vectorHeight * vectorWidth);
ArrayList<int[][]> vectors = new ArrayList<>(numofVectors1);
int numberOfArrays = 6400;
        for (int j = 0; j < Math.sqrt(numberOfArrays); j++) {
            for (int i = 0; i < Math.sqrt(numberOfArrays); i++) {
                int[][] array = new int[][]{
                        {
                                pixels[j * vectorHeight][i * vectorHeight],
                                pixels[j * vectorHeight][(i * vectorHeight) + 1],
                                pixels[j * vectorHeight][(i * vectorHeight) + 2],
                                pixels[j * vectorHeight][(i * vectorHeight) + 3]
                        },
                        {
                                pixels[(j * vectorHeight) + 1][i * vectorHeight],
                                pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 1],
                                pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 2],
                                pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 3]
                        },
                        {
                                pixels[(j * vectorHeight) + 2][i * vectorHeight],
                                pixels[(j * vectorHeight) + 2][(i * vectorHeight) + 1],
                                pixels[(j * vectorHeight) + 2][(i * vectorHeight) + 2],
                                pixels[(j * vectorHeight) + 2][(i * vectorHeight) + 3]
                        },
                        {
                                pixels[(j * vectorHeight) + 3][i * vectorHeight],
                                pixels[(j * vectorHeight) + 3][(i * vectorHeight) + 1],
                                pixels[(j * vectorHeight) + 3][(i * vectorHeight) + 2],
                                pixels[(j * vectorHeight) + 3][(i * vectorHeight) + 3]
                        },
                };
                vectors.add(array);
            }
        }

edited Dec 11, 2021 at 16:39

answered Dec 10, 2021 at 17:53

Enrico

4452 silver badges11 bronze badges

Sign up to request clarification or add additional context in comments.

13 Comments

Doha Ramadan Over a year ago

thank you so much. but this solution only works for this example but the 320 * 320 example - I have another 2d array of size 320 * 320 which I want to store its data in 6400 2d arrays of size 4*4 -will need another code which will also be static. in my program i am taking the size - 4*4- from the user so I'm looking for an algorithm to work on different sizes.

Enrico Over a year ago

This would be similiar... instead of looping until 3, use 320. And instead of 2*2 you have to implement 4*4, which also will have a algorithm. Write down the first few lines and you will see the algorithm

Doha Ramadan Over a year ago

i did and i get the right results regarding the first array of the 2d array and the second I did a different result here's the code:

Doha Ramadan Over a year ago

int[][] array = new int[][]{                         {pixels2[j * vectorHeight][i * vectorHeight], pixels2[j * vectorHeight][(i * vectorHeight) + 1],pixels2[j * vectorHeight][(i * vectorHeight) + 2],pixels2[j * vectorHeight][(i * vectorHeight) + 3]},                         {pixels2[(j * vectorHeight) + 1][i * vectorHeight], pixels2[(j * vectorHeight) + 1][(i * vectorHeight) + 1],pixels2[(j * vectorHeight) + 2][(i * vectorHeight) + 2],pixels2[(j * vectorHeight) + 3][(i * vectorHeight) + 3]},                 };

Doha Ramadan Over a year ago

vector height is 4

|

Collectives™ on Stack Overflow

how to split a 2d array into multiple 2d arrays of different sized in java

1 Answer 1

13 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

13 Comments

Your Answer

Sign up or log in

Post as a guest

Related