Java >> Java Program >  >> Java

2D Array Java Exempel

Java

I det här inlägget presenterar vi ett omfattande 2D Array Java-exempel. Java stöder endimensionella, tvådimensionella och generellt flerdimensionella arrayer.

1. Inledning

En array är ett containerobjekt som innehåller ett fast antal värden av en enda typ. Längden på en array fastställs när arrayen skapas.

Java ger oss möjligheten att använda arrayer med många dimensioner. Syntaxen för att deklarera en flerdimensionell matris är som:

{Datatype}[1D][2D][..][ND]

Du kan titta på följande video och lära dig hur du använder arrays i Java:

De vanligaste flerdimensionella arrayerna som används i java-appar är en (1D), två (2D) och tre (3D) dimensionella. 2D array representerar tabelldata i rad- och kolumnstil. Den första parentesen är för raderna och den andra parentesen är för kolumnen. T.ex. int[3][2] deklarerar en 2D heltalsmatris med 3 rader och 2 kolumner.

[rowIdx][colIdx] kolumn 0 kolumn 1
rad 0 objekt[0][0] objekt[0][1]
rad 1 objekt[1][0] objekt[1][1]
rad 2 objekt[2][0] objekt[2][1]

I det här exemplet ska vi demonstrera:

  • Deklarera en 2D-matris
  • Deklarera och skapa en 2D-array
  • Deklarera, skapa och initiera en 2D-array
  • Deklarera, skapa och tilldela värdet till en 2-D-arrays element
  • Skriv ut en 2D-matris
  • Visa ArrayIndexOutBoundException

2. Teknik som används

Exempelkoden i den här artikeln byggdes och kördes med:

  • Java 11
  • Maven 3.3.9
  • Juni 4.12
  • Eclipse Oxygen

3. Maven Project

I det här steget kommer jag att skapa ett Maven-projekt som inkluderar 2D-arrayexempel.

3.1 Beroenden

Jag kommer att inkludera Junit i pom.xml .

pom.xml 

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>jcg.zheng.demo</groupId>
	<artifactId>java-2dArray-demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<build>
		<sourceDirectory>src</sourceDirectory>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.8.0</version>
				<configuration>
					<release>11</release>
				</configuration>
			</plugin>
		</plugins>
	</build>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>
	</dependencies>
</project>

3.2-kort

I det här exemplet kommer jag att skapa en Card klass som ska användas för att skapa en 2D-array med Card typ.

Card.java 

package jcg.zheng.demo.data;

public class Card {

	public Card(String suit, String rank) {
		super();
		this.suit = suit;
		this.rank = rank;
	}

	private String suit;

	private String rank;

	public String getSuit() {
		return suit;
	}

	public void setSuit(String suit) {
		this.suit = suit;
	}

	public String getRank() {
		return rank;
	}

	public void setRank(String rank) {
		this.rank = rank;
	}

	@Override
	public String toString() {
		return "[" + rank + " of " + suit + "]";
	}

}

4. JUnit Test

4.1. 2D Integer Array

I det här steget kommer jag att skapa en java-klass med namnet TwoDIntArrayTest med följande metoder:

  • declare_array – definierar en 2D-matris med en heltalstyp.
  • declare_and_create_array – definierar en 2D heltalsmatris med 4 rader. Kolumnerna är null objekt.
  • declare_and_create_array_with_column – definierar en 2D heltalsmatris med 4 rader och 2 kolumner. Kolumnerna är en 1D-matris med standardvärdet 0.
  • declare_create_and_initialize_array – definierar en 2D-heltalsmatris med initiala värden.
  • declare_create_assign_array – definierar en 2D-heltalsmatris och allokerar med en radstorlek och tilldelar kolumnerna för varje rad.
  • print2DIntArray – skriver ut en 2-D heltalsarrays element.
  • array_has_boundary – visar att arrayen har en fast storlek, den kommer att skapa ett undantag när den kommer åt en array utanför dess gräns.

TwoDIntArrayTest.java 

package jcg.zheng.demo.array;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;

import org.junit.Test;

public class TwoDIntArrayTest {

	private static final int COLUMN_COUNT = 4;
	private static final int ROW_COUNT = 2;

	@Test
	public void declare_array() {
		int[][] anArray;
		System.out.println("done");
	}

	@Test
	public void declare_and_create_array() {
		int[][] anArray = new int[ROW_COUNT][];
		for (int i = 0; i < ROW_COUNT; i++) {
			assertNull(anArray[i]);
		}
	}

	@Test
	public void declare_and_create_array_with_column() {
		int[][] anArray = new int[ROW_COUNT][COLUMN_COUNT];

		for (int i = 0; i < ROW_COUNT; i++) {
			assertNotNull(anArray[i]);
			for (int j = 0; j < COLUMN_COUNT; j++) {
				assertEquals(0, anArray[i][j]);
			}
		}
	}

	@Test
	public void declare_create_and_initialize_array() {
		int[][] tableInt = new int[][] { { 1, 2, 3 }, { 6, 7, 8 }, { 5, 6, 7 } };

		print2DIntArray(tableInt);
	}

	@Test
	public void declare_create_assign_array() {
		int[][] tableInt = new int[ROW_COUNT][];

		for (int i = 0; i < ROW_COUNT; i++) {
			int[] row = new int[COLUMN_COUNT];
			tableInt[i] = row;
			for (int j = 0; j < COLUMN_COUNT; j++) {
				assertEquals(0, tableInt[i][j]);
			}
		}

	}

	private void print2DIntArray(int[][] tableInt) {
		for (int i = 0; i < tableInt.length; i++) {
			for (int j = 0; j < tableInt[i].length; j++) {
				System.out.printf("tableInt[%d][%d] = %d\n", i, j, tableInt[i][j]);
			}
			System.out.println();
		}
	}

	@Test(expected = ArrayIndexOutOfBoundsException.class)
	public void array_has_boundary() {
		int[] test = new int[ROW_COUNT];
		test[test.length] = 4;
	}

}

Som du kan se är detta sätt mycket likt deklarationen av endimensionell array. Kör mvn test -Dtest=TwoDIntArrayTest och fånga resultatet här.

Utdata 

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running jcg.zheng.demo.array.TwoDIntArrayTest
done
tableInt[0][0] = 1
tableInt[0][1] = 2
tableInt[0][2] = 3

tableInt[1][0] = 6
tableInt[1][1] = 7
tableInt[1][2] = 8

tableInt[2][0] = 5
tableInt[2][1] = 6
tableInt[2][2] = 7

Tests run: 6, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.172 sec

Results :

Tests run: 6, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  10.678 s
[INFO] Finished at: 2019-11-01T11:30:11-05:00
[INFO] ------------------------------------------------------------------------

C:\MaryZheng\Workspaces\jdk12\java-2dArray-demo>

4.2 2D Object Array

Istället för att bara deklarera primitiva typer i en array kan vi också använda objekt. I det här exemplet kommer jag att skapa TwoDObjectarrayTest klass för att täcka definitionen av Card 2D-array. Varje cell i denna 2-dimensionella array representerar en instans av Card klass.

  • declare_and_create_2D_array_default_null – definierar en 2D Card array med 4 rader och 2 kolumner och verifierar att standardelementen är null objekt.
  • declare_create_initialize_string_2d_array – definierar, skapar och initierar en 2D String array.
  • print2DArray – skriver ut ett 2D-matriselement med två for slingor
  • deal_poker_card_game – illustrerar en 2D Card array med ett pokerspel. Den drar 5 kort för 4 spelare och skriver ut spelarnas hand.

TwoDObjectArrayTest.java 

package jcg.zheng.demo.array;

import static org.junit.Assert.assertEquals;

import org.junit.Test;

import jcg.zheng.demo.data.Card;

public class TwoDObjectArrayTest {

	private static final int COLUMN_COUNT = 4;
	private static final int ROW_COUNT = 2;
	
	@Test
	public void declare_and_create_2D_array_default_null() {
		Card[][] array_2d = new Card[ROW_COUNT][COLUMN_COUNT];

		for (int i = 0; i < ROW_COUNT; i++) {
			for (int j = 0; j < COLUMN_COUNT; j++) {
				assertEquals(null, array_2d[i][j]);
			}
		}
	}

	@Test
	public void declare_create_initialize_String_2d_array() {
		String[][] array_2d = new String[][] { { "apple", "orange" }, { "kiwi", "strawberry" },
				{ "cranberry", "grape" } };

		print2DArray(array_2d);
	}

	private void print2DArray(Object[][] array_2d) {
		for (int i = 0; i < array_2d.length; i++) {
			for (int j = 0; j < array_2d[i].length; j++) {
				System.out.printf("[%d][%d]=%s ", i, j, array_2d[i][j]);
			}
			System.out.println();
		}
	}

	@Test
	public void deal_poker_card_game() {
		// 4 players play one game of poker
		int PLAYER_COUNT = 4;
		int HAND_CARD_COUNT = 5;

		Card[][] cards = new Card[HAND_CARD_COUNT][PLAYER_COUNT];
		// draw first card for 4 players
		cards[0][0] = new Card("Spade", "1");
		cards[0][1] = new Card("Heart", "J");
		cards[0][2] = new Card("Diamond", "3");
		cards[0][3] = new Card("Club", "K");

		// draw second card for 4 players
		cards[1][0] = new Card("Heart", "1");
		cards[1][1] = new Card("Spade", "10");
		cards[1][2] = new Card("Club", "5");
		cards[1][3] = new Card("Diamond", "8");

		// draw third card for players
		cards[2][0] = new Card("Spade", "11");
		cards[2][1] = new Card("Heart", "A");
		cards[2][2] = new Card("Diamond", "8");
		cards[2][3] = new Card("Club", "K");

		// draw fourth card for players
		cards[3][0] = new Card("Heart", "9");
		cards[3][1] = new Card("Spade", "2");
		cards[3][2] = new Card("Club", "Q");
		cards[3][3] = new Card("Diamond", "7");

		// draw fifth card for players
		cards[4][0] = new Card("Heart", "5");
		cards[4][1] = new Card("Spade", "K");
		cards[4][2] = new Card("Club", "10");
		cards[4][3] = new Card("Diamond", "4");

		print2DArray(cards);

		// print out each player's hand
		for (int playerIdx = 0; playerIdx < PLAYER_COUNT; playerIdx++) {
			System.out.printf("\nPlayer " + (playerIdx + 1) + " hand :");

			for (int cardIndex = 0; cardIndex < HAND_CARD_COUNT; cardIndex++) {
				System.out.print(cards[cardIndex][playerIdx] + " ");
			}
		}

	}
}

För en bättre förståelse kan du se resultatet av exekveringen av ovanstående kod.

Utdata 

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running jcg.zheng.demo.array.TwoDObjectArrayTest
[0][0]=[1 of Spade] [0][1]=[J of Heart] [0][2]=[3 of Diamond] [0][3]=[K of Club]
[1][0]=[1 of Heart] [1][1]=[10 of Spade] [1][2]=[5 of Club] [1][3]=[8 of Diamond]
[2][0]=[11 of Spade] [2][1]=[A of Heart] [2][2]=[8 of Diamond] [2][3]=[K of Club]
[3][0]=[9 of Heart] [3][1]=[2 of Spade] [3][2]=[Q of Club] [3][3]=[7 of Diamond]
[4][0]=[5 of Heart] [4][1]=[K of Spade] [4][2]=[10 of Club] [4][3]=[4 of Diamond]

Player 1 hand :[1 of Spade] [1 of Heart] [11 of Spade] [9 of Heart] [5 of Heart]
Player 2 hand :[J of Heart] [10 of Spade] [A of Heart] [2 of Spade] [K of Spade]
Player 3 hand :[3 of Diamond] [5 of Club] [8 of Diamond] [Q of Club] [10 of Club]
Player 4 hand :[K of Club] [8 of Diamond] [K of Club] [7 of Diamond] [4 of Diamond] [0][0]=apple [0][1]=orange
[1][0]=kiwi [1][1]=strawberry
[2][0]=cranberry [2][1]=grape
Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.401 sec

Results :

Tests run: 3, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  10.294 s
[INFO] Finished at: 2019-11-01T11:33:18-05:00
[INFO] ------------------------------------------------------------------------

C:\MaryZheng\Workspaces\jdk12\java-2dArray-demo>

5. Sammanfattning

I det här exemplet visade jag hur man deklarerar, skapar och initierar en 2D-array med både heltal och Card . Kom ihåg att Array har element med fast storlek och skickar en ArrayIndexOutBoundException om åtkomst till ett index som ligger utanför gränsen.

Klicka här för hur du lägger till och tar bort ett element och klicka här för hur du kopierar en array.

6. Ladda ner källfilen

Det här exemplet består av ett Maven-projekt som inkluderar en handledning om 2D-array för deklaration, skapande, initiering, tilldelning, åtkomst och hämtning.

Java-tagg