Basic operations on 2D arrays ep02

Hello, my young Java enthusiasts!

Today, we will explore something cool called "Accessing and changing things in 2D arrays."

Does it sound tricky?

Don't worry, I'll explain it in an easy way.

You already know, a 2D array is like a special box that holds lots of numbers or words in a neat pattern. It's like a grid, just like the one you see on your game board.

In this blog, we'll learn how to find and even change things inside this magical box.

So, get ready for some fun and let's dive in together to discover the secrets of 2D arrays!

👉 Accessing elements in arrays

Picture this: you have a 2D array that's like a world map filled with funny creatures.

Each cell in the array represents a special location where these creatures reside. To access a particular creature, you need to navigate through rows and columns like a treasure hunt.

It's like saying, "I'm looking for the giggly goblin at row 2, column 3!" Just remember, rows and columns start from 0, so it's a bit like giving directions to a funny friend who sometimes gets lost.

So, gear up with your laughter goggles, and let's go on a whimsical adventure, accessing funny creatures from your Java 2D array!

Here’s an example:

public class TwoDArrayAccessExample {
public static void main(String[] args) {
// Let's create a 2D array of integers
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

// Accessing elements in the 2D array
int element1 = matrix[0][0];
int element2 = matrix[1][2];

// Printing the accessed elements
System.out.println("The first element is: " + element1);
System.out.println("The second element is: " + element2);
}
}
//output
//The first element is: 1
//The second element is: 6

In this example, we have a 2D array called "matrix" that stores integers in a grid-like structure. To access elements in the 2D array, we use two sets of square brackets. The first set represents the row index, and the second set represents the column index. In our code, matrix[0][0] accesses the element at the first row and first column, while matrix[1][2] accesses the element at the second row and third column.

The accessed elements are then printed using System.out.println(). When you run this code, it will display the values of the first element (1) and the second element (6) from the 2D array.

Remember, indices in arrays start from 0, so the first row or column is at index 0, the second row or column is at index 1, and so on.

👉 Manipulating elements in arrays

Now that you all are clear with accessing elements, let’s get ready for some funny business as we change things up in a 2D array in Java!

Imagine a playful game world where each element represents a silly character. You have the power to make hilarious transformations - like turning a serious scientist into a clown or making a knight ride a unicycle!

With coding, you can access each character using its row and column coordinates and give them a funny makeover.

Just remember to restore everything back to normal before the characters catch on! So, get ready to laugh as we twist and tweak elements in your Java 2D array.

In the programming realm, you can change elements in a 2D array by accessing them using their row and column indices.

This allows you to modify specific values within the array.

For example, if you have a 2D array representing a game board, you can update the state of the game by changing the values of certain cells. To change an element, you simply assign a new value to the corresponding position in the array.

The process involves specifying the row and column indices within square brackets, like array[row][column] = newValue;.

This allows you to update the content of a specific cell or perform other desired modifications. With this flexibility, you can dynamically alter the data stored in a 2D array and adapt it to your program's requirements.

Certainly! Let's dive into manipulting elements in a 2D array in Java with a code example:

public class TwoDArrayModificationExample {
public static void main(String[] args) {
// Let's create a 2D array of characters
char[][] grid = {
{'A', 'B', 'C'},
{'D', 'E', 'F'},
{'G', 'H', 'I'}
};

// Changing an element in the 2D array
grid[1][2] = 'X';

// Printing the modified 2D array
for (int row = 0; row < grid.length; row++) {
for (int col = 0; col < grid[row].length; col++) {
System.out.print(grid[row][col] + " ");
}
System.out.println();
}
}
}

In this example, we have a 2D array called "grid" that stores characters. To change an element in the array, we specify the row and column indices and assign a new value to it. In the code, we change the element at position (1, 2) from 'F' to 'X'.

The modified 2D array is then printed using nested loops. The outer loop iterates over the rows, and the inner loop iterates over the columns. Each element is printed, followed by a space. After printing each row, a newline character is added to start the next row on a new line.

When you run this code, it will display the 2D array with the modified element.

Hope you guys enjoyed reading!

Feel free to experiment with different changes and explore the vast possibilities of modifying elements in 2D arrays in Java!

Happy learning.

Now what?

Check out the following blogs for single-dimension arrays :

Introduction to arrays:

https://madalgos.in/blog-space/18

https://madalgos.in/blog-space/19

Basic operations on arrays:

https://madalgos.in/blog-space/20

https://madalgos.in/blog-space/21

Introduction to multidimensional arrays:

https://madalgos.in/blog-space/22

https://madalgos.in/blog-space/23