-
[1]단일 차원 배열
1)배열의 정의 : 동일한 자료형으로 선언된 데이터 공간을 메모리상에 연속적으로 나열하여 데이터 관리의 효율성을 높인것
자료형이 똑같아야된다 (ex. int x; int y, int z)
2)기존 자료 처리와 배열의 비교
-동일 자료형의 관리
-유사 문구의 관리
3)단일 차원 배열의 선언
-자료형[] 배열명;
(만약 배열 선언 시에 개수를 지정하면 컴파일 에러)
-자료형 배열명[];
예) short[] sh;
int a[];
int a[3]; << 에러
4)단일 차원 배열이 초기화
미리선언해두고 아랫쪽에 따로 정의할때
-배열명 = new 자료형[개수] //배열선언
default 초기화([개수]에 default 값이 [개수]공간 속에 들어가게 됨)
◈boolean -->false
◈byte, short, int --> 0
◈char -->0, '\0'
◈long -->0L
◈float -->0.0f
◈double -->0.0
◈String -->null
new : 동적 메모리 할당 연산자.
-배열명 = new 자료형[]{값1, 값2 ,값3, 값n};
원하는 값을 넣고싶을때
값n의 갯수만큼 배열의 갯수가 잡힌다.
5)선언과 초기화
배열을 선언하면서 초기화할때
-자료형[] 배열명 = {값1, 값2, 값3, 값n};
c언어 배열 초기방식
예) char[] ch = {'A','B','C'}; 선언과 동시사용
int[] a; 선언하고
a = new int[3]; 배열
flaot[] b;
b= new float[]{1.2f, 2.3f, 3.4f};
float f2[] = new float[]; << 에러
※메모리 각역영(Constant, Heap , Stack)
Garbage Collection Heap 영역 :
사용자가 컨트롤 하지 않아도 자동적으로 데이타가 필요 없어질때
Garbage Collector동작하는 영역
이영역에 데이타를 할당시킬수 있는 new연산자
※배열명은 무조건 4byte
레퍼런스변수 (주소를 기억하는 공간)
[2]배열관리
1.배열관리
-배열명은 Reference이다.
Reference : Garbage Collection Heap의 주소를 참조한다.
레퍼런스 변수의 초기값은 null(default)값이다.
-배열명은 4byte 객체이다. (배열도 객체이다)
int[] x = new int[] {3, 6, 3}; //x= 4byte
short[] y = new short[3]; //y =4byte
자료명에 관계없이 배열명은 무조건 4byte
-배열의 길이는 length 속성을 이용할 수 있다.
length는 배열객체를 관리하는 클래스의 필드이다.
x.length: x가 가지고있는 맴버의 갯수를 알수있다.
-배열의 실제 데이터는 Heap영역에 표시된다.
(new 연산자의 의미 : Heap에 대한 할당)
-Garbage Collection에 의해 소멸된다.
더이상 참조를 받지 않게되면 Garbage Collecter에 의해 소멸된다.
레퍼런스변수의 초기값은 null(default)값이다.
(배열도 class형태를 띠고 있기 때문)
예) int[] x = new int[] {3, 6, 3};
x= null;
x=null 을 넣으면 {3, 6, 3}은 메모리는 남아잇는데 더이상 쓸 수 없다.
{3, 6, 3};의 주소를 모르기때문(x만 알고있다가 x가 초기화 되었기 때문)
-각공간은 첨자로 구분된다.(첨자는 0부터)
int[] x = new int[] {3, 6, 1};
//x[0] =3, x[1] = 6, x[2] = 1;이당
for문 이용해서 출력할수 있다.
for(int i = 0; i < 4 ; ++i){
System.out.println("x[" + i + "] = " + x[i]);
//"x[i]" 문자열에선 변수가 먹히지 않는다.
“x[i]”로 출력할 경우 계속 x[i]로 출력된다.
}
-공간의 값은 자동으로 Dfault 초기화된다.
일반 자료형은 반드시 초기화 시켜줘야댄다.
-동적으로 공간 할당이 가능하다.
프로그램 실행 할 때 마다 공간을 바꾸고 싶을 때.
입력 받은 값을 통하여 동적으로 배열을 할당시킬 수 있다.
int num = 0;
int[] x = null;
System.out.print("num = ");
num = Integer.parseInt(in.readLine());
x = new int[num];
for(int i =0; i
System.out.println("x[" + i + "] = " + x[i]);
}
[3]main Method 의 String 배열
(public static void main{String[] ar}
1. 용도 : 프로그램 시작 시 초기값 전달
String[]: 프로그램 시작하면서 각 프로그램마다 필요한 매개변수를 전달해주는 역할
초기화 매개변수로 데이터를 전달해주는 역할
2. 형식 : java 클래스명 초기값 초기값
예) class Exam_07{
public static void main(String[] ar) {
//ar = new String[]{"aaa", "bbb", "ccc"};
System.out.println("ar.length = " + ar.length);
for(int i =0 ; i < ar.length ; ++i){
System.out.println(“ar[“+ i + “] = “ +ar[i]);
}
}
}
javac Exam_07.java 컴파일후
java Exam_07 aaa bbb ccc
ar.length =3
ar[0] = aaa
ar[1] = bbb
ar[2] = ccc라고 나온다.
만약 여기서 java Exam_07 aaa bbb 라고하면
ar.length =2
ar[0] =aaa
ar[1] =bbb
♠ArrayIndexOutOfBoundsException이라고나온다.
배열(Array)의 요소번호(위치번째)(Index)의 범위(Bounds)를 벗어난(Out of) 예외(Exception)적인 상황
♠숫자 바꿀때마다 컴파일을 다시 할 필요가 없다.
♠실행 시킬 때 사용자가 어떠한 데이터 값으로 처리함에 따라 결과가 달라진다.
※자바는 인터프리터 언어이기 때문에 한줄씩 실행하다가 에러가 난 위치에서 멈춘다
3. 배열 길이 : ar.length
4. 종료 Method : System.exit(처리수)
정상 종료일때 :0 //우린 0을 쓴다
그렇지 않을 때 1 , -1 을쓴다.
[4]단일 차원 배열 사용 예제1
1.데이터 공간 할당 및 값 입력과 출력 예제
예)Exam_06.java , Exam_08.java
배열을 쓰면 무조건 for문을 같이 이용해야한다.
2.주민번호 검증 예제
Exam_09.java 배열 주민번호예제
요즘은 이름하고 주민번호가 매칭시켜서 쓴다.
이름하고 주민번호하고 맞지 않으면 쓸모 없다.
123456-ABCDEFG(14자리)
12 : 태어난 연도
34 : 태어난 월
56 : 일
A :성별자리
0,9: 1800년대생
1,2: 1900년대생
3,4: 2000년대생
5,6: 외국인
B:태어난 지역 ,출생지
CD: 시도(0서울 1:경기,인천, 2:부산, 3:강원도, 4:충정도, 5:전라도, 6:대구,광주,
7:경북,경남 8:경남 9:제주도)
EF: 동
G: 검증번호
3.특정 개수의 알파벳 입력 및 개수 출력 예제
Exam_10.java
char[] ch= null; //갯수만큼 데이타를 입력 받을 공간
int[] alpha = new int[26]; //0: a개수 1: b개수 25: z개수
// 특성개수만큼 알파벳을 입력받으면 그 개수에 대한 만큼의
데이타를 분할해서 처리할수 있도록 만들어 줄것이다.
4.성적처리 및 석차 처리 예제
5.Random을 이용한 야구게임 예제
6.투숙객 관리 예제
===========================================================================
Chapter
6
배열(Array)
배열이란 '자료들의 모임 또는 집합'을 말하는 것으로 예를 들어 음식의 집합은 짬뽕, 짜장면, 볶음밥, 비빔밥 등이 될 것이고, 스포츠의 집합은 축구, 배구, 야구 등이 될 것이다. 이런 집합을 프로그래밍에서는 배열이라 하고 자바에서는 자료형에 따라 기본 자료형 배열과 객체형 배열로 나뉜다. 자바는 배열도 객체로 취급한다. 기본 자료형은 객체가 아니지만 기본 자료형이 모여서 만들어진 배열은 객체이다. 프로그래밍에서 배열을 사용하는 이유는 자료를 효율적으로 관리하기 위함이다.
<기본 자료형 배열>
문자형 배열: 'A', 'D', 'q', 'b', ...
정수형 배열: 123, 456, -564L, ...
실수형 배열: 2.13, 3.0, -1.23F, ...
<객체형 배열>
String형 배열: "abc", new("def"), "한글", ...
이 외에도 수없이 많다.
<차원에 따른 분류>
1차원 배열, 2차원 배열, 3차원 배열, ...
기본 자료형 배열
배열도 객체이므로 객체를 참조할 수 있는 레퍼런스를 먼저 만들어야 한다. a라는 이름을 가지는 정수형 배열의 레퍼런스를 만들어 보자.
int[] a; // 1번
int []a; // 2번
int[]a; // 3번
int a[]; // 4번
위 네 가지는 모두 같은 표현이다. []는 배열을 뜻한다. 정확히 말하면 1차원 배열을 뜻한다. 4번은 C/C++에서 사용하는 표현으로 자바는 이것도 지원한다. 하지만 권장하고 싶지는 않다. 필자가 생각하기에 가장 적절한 표현은 1번이다. 'int[]'를 참조할 수 있는 레퍼런스 a를 만들기 때문이다. 이제 레퍼런스를 만들었으므로 이제 실제로 객체를 만들어 참조하게 하자.
a=new int[5];
객체를 만드는 것과 유사해 보인다. 배열도 객체이므로 new 키워드를 사용한다. 'new int[5]'는 원소의 개수가 5개인 정수(int) 배열을 만들라는 의미이고, 'a=new int[5]'는 a가 이 배열을 참조하게 하는 것이다.
이것을 그림으로 표현하면 다음과 같다.
[그림 6-1] 기본 자료형의 1차원 배열
위의 그림과 같이 각각의 원소에 번호를 붙여서 원소를 구분하는데 번호는 0부터 시작한다. 배열의 원소 개수가 5개이므로 번호는 0부터 4까지이다. 이것은 학교에서 학생에게 번호를 부여하는 것과 유사하다. 다른 점이 있다면 0부터 시작하는 것이다. 이와 같이 자료들이 한 줄로 나열된 배열을 1차원 배열이라고 한다.
배열도 객체이므로 멤버 변수와 멤버 메소드를 가지고 있다. 멤버 중에서 관심 있게 보아야할 것은 배열의 길이(원소의 개수)를 기억하고 있는 length이다. 이 멤버 변수는 접근 지정자가 public이므로 어디서든지 사용될 수 있다.
다음 예제는 배열의 길이를 구하는 예제다. 쉬운 예제이므로 자세한 설명은 생략한다.
Array1.java
public class Array1{
public static void main(String[] args){
int[] a; // x1
a=new int[10]; // x2
System.out.println(a.length); // 배열 a가 가지는 원소의 개수를 출력한다.
}
}
출력 결과
10
x1행과 x2행을 합쳐서 'int[] a=new int[10];'으로 적어도 될 것이다.
배열의 원소에 접근할 때는 '배열이름[원소번호]'의 형태로 접근한다.
a[0]=10; // 배열 a의 0번 원소에 10을 기억시킨다.
b= a[3]; // 배열 a의 3번 원소의 값을 b에 대입한다.
다음 예제는 네 과목의 점수에 대한 총점과 평균을 구하는 예제이다.
Array2.java
public class Array2{
public static void main(String[] args){
int[] a=new int[4]; // 네 과목의 점수를 기억할 배열
int sum=0; // 총점을 위한 변수
a[0]=90; a[1]=80; a[2]=75; a[3]=85; // 점수를 입력한다.
for(int i=0;i<a.length;i++) // 총점을 구한다. a.length==4
sum+=a[i];
System.out.println("총점: "+sum); // 총점 출력
System.out.println("평균: "+(double)sum/a.length); // 평균 출력
}
}
출력 결과
총점: 330
평균: 82.5
혼자 해보기
Alone6_1.java
10개의 원소를 가지는 정수형 배열 a를 만들고 'a[i]=i*i'가 되도록 각 원소에 값을 대입하고 출력해보자.
출력 결과 예시
a[0]=0
a[1]=1
a[2]=4
...
a[9]=81
1차원 배열의 초기화
배열도 기본 자료형과 같이 초기화할 수 있다.
int[] a=new int[]{1, 2, 3, 4, 5}; // 1번
int[] b={6, 7, 8, 9}; // 2번
배열을 초기화하는 방법은 위와 같이 두 가지가 있는데 2번은 C++를 해본 사용자를 위한 자바의 배려이다. 하지만 1번과 같이 하는 것이 더 자연스러운 표현인 것 같다.
1번과 같이 하면 원소의 개수가 5개인 배열이 만들어지고 차례대로 1, 2, 3, 4, 5가 대입된다. 2번도 마찬가지로 원소의 개수가 4개인 배열이 만들어지고 차례대로 6, 7, 8, 9가 대입된다.
Array3.java
public class Array3{
public static void main(String[] args){
int[] a=new int[]{12, 22, 37, 48, 59};
double[] b={1.2, -2.7, 9.53, 3.0};
System.out.println(a.length);
System.out.println(b.length);
System.out.println(a[1]);
System.out.println(b[2]);
}
}
출력 결과
5
4
22
9.53
객체형 배열(Object Array)
객체형 배열을 다른 말로 부른다면 레퍼런스 배열이라고 하고 싶다. 왜냐하면 객체형 배열은 레퍼런스의 집합이기 때문이다. 즉, 객체형 배열에서 배열의 원소는 레퍼런스이다.
String형 배열을 예로 들어보자.
String[] s; // x1
s=new String[3]; // x2
x1행은 String형 배열의 레퍼런스 s를 만든다. x2행에서 's=new String[3]'은 원소의 개수가 3개인 배열(s[0], s[1], s[2])을 만들고 s가 참조하게 한다. 여기서 원소들은 레퍼런스이다.
원소 s[0], s[1], s[2]는 레퍼런스이므로 객체를 만들고 참조하게 하자.
s[0]=new String("철수");
s[1]=new String("영희");
s[2]=new String("효정");
s[0]은 "철수" 객체를 참조하고, s[1]은 "영희"객체를 참조한다. s[2]도 마찬가지로 "효정" 객체를 참조하게 된다. 이상을 그림으로 표현하면 [그림 6-2]와 같은데 그림을 잘 보고 객체형 배열에 대하여 이해하길 바란다.
[그림 6-2] 객체형 배열
Array4.java
public class Array4{
public static void main(String[] args){
String[] s=new String[3];
s[0]=new String("안녕");
s[1]=new String("hello");
s[2]=new String("방가");
for(int i=0;i<s.length;i++)
System.out.println(s[i]);
}
}
출력 결과
안녕
hello
방가
사용자가 정의한 클래스로부터 생성된 객체형 배열에 대한 예제를 살펴보자. [그림 6-2]를 머리 속으로 떠올리면서 생각하면 이해가 쉬울 것이다.
Array5.java
public class Array5{
int a, b;
public static void main(String[] args){
Array5[] arr=new Array5[2]; // Array5형 배열 arr( 원소 2개)
arr[0]=new Array5(); // arr[0]에 객체 할당
arr[1]=new Array5(); // arr[1]에 객체 할당
arr[0].a=10; arr[0].b=20;
arr[1].a=30; arr[1].b=40;
System.out.println(arr[0].a+arr[0].b);
System.out.println(arr[1].a+arr[1].b);
}
}
출력 결과
30
70
혼자 해보기
Alone6_2.java
클래스 Alone6_2는 아래와 같다.
public class Alone6_2{
private int a, b;
public Alone6_2(){}
public void setAB(int a, int b){
this.a = a;
this.b = b;
}
public int getA(){ return a; }
public int getB(){ return b; }
public static void main(String[] args){...}
}
열 개의 원소를 가지는 Alone6_2형 배열 ob를 만들고 다음 조건을 만족하도록 값을 대입하고 출력해보자.
<조건>
ob[0].a = 1 , ob[0]. b =2
ob[i+1].a= ob[i].a + ob[i].b, ob[i+1].b= ob[i].a * ob[i].b
출력 결과 예시
ob[0].a = 1, ob[0].b = 2
ob[1].a = 3, ob[1].b = 2
ob[2].a = 5, ob[2].b = 6
ob[3].a = 11, ob[3].b = 30
...
객체형 배열의 초기화도 기본 자료형의 초기화와 비슷하다.
Array6.java
public class Array6{
public static void main(String[] args){
String[] s1={new String("abc"), new String("kor")};
String[] s2=new String[]{new String("안녕"), new String("방가")};
System.out.println(s1[0]);
System.out.println(s2[1]);
}
}
출력 결과
abc
방가
배열을 만들고 초기화하지 않으면 기본 자료형에는 0이, 객체형에는 null이 대입된다.
Array7.java
public class Array7{
public static void main(String[] args){
int[] a=new int[2];
String[] b=new String[2];
System.out.println(a[0]+" "+a[1]);
System.out.println(b[0]+" "+b[1]);
}
}
출력 결과
0 0
null null
2차원 배열
1반 학생 수가 5명이라고 가정하자. 아래 그림과 같이 3학년 1반 학생들을 1차원 배열로 생각할 수 있을 것이다.
[그림 6-3] 1차원 배열
위 그림은 '1반'이 학생들의 배열을 참조하는 것을 표현한 것이다.
1반 = new 학생[5];
3학년에는 세 개의 반이 있다고 생각하자.
1반 = new 학생[5]; // 5명
2반 = new 학생[4]; // 4명
3반 = new 학생[3]; // 3명
여기서 1반, 2반, 3반이 레퍼런스임을 유념하기 바란다.
위에서 만들어진 3개의 반이 모여서 3학년을 구성하는데 아래와 같다.
3학년=new 반[3];
이상을 조합하여 그림으로 표현해보자.
[그림 6-4] 2차원 배열
그림과 같이 1차원 배열이 모여서 만들어진 배열을 2차원 배열이라고 한다.
알아두기
또 1학년, 2학년, 3학년이 모여서 한 학교를 이루므로 한 학교의 전교생은 3차원 배열로 볼 수 있다. 3차원 배열은 2차원 배열의 배열이다.
3학년이 존재하지 않으면 3학년 1반도 존재하지 않기 때문에 3학년 1반을 만들기 위해선 3학년을 먼저 만들어야 한다. 즉, 2차원 레퍼런스를 먼저 만들어야 한다.
3학년=new 반[3];
1반 = new 학생[5];
2반 = new 학생[4];
3반 = new 학생[3];
2차원 배열에 대한 기본 개념을 살펴보았다. 이제 구체적인 자바 문법으로 옮겨 보자. [][]은 2차원 배열을 나타낼 때 사용한다.
int[][] a;
a는 정수형 2차원 배열의 레퍼런스이다.
a=new int[3][];
위는 1차원 배열의 레퍼런스 a[0], a[1], a[2]를 만들고 a가 참조하게 하는 코드다. [3][]에서 뒤에 있는 [] 안이 비어 있다. 이유는 아직 1차원 배열의 객체가 없으므로 []안을 비워 두는 것이다.
1차원 배열의 레퍼런스 a[0], a[1], a[2]에게 객체를 할당해 보자.
a[0]=new int[5];
a[1]=new int[4];
a[2]=new int[3];
a[0]의 첫 번째 원소에 10을 대입해 보자. 배열의 원소는 0부터 시작한다.
a[0][0]=10;
'int[][] a;'로 2차원 배열을 정의하였기 때문에 a[x][y]에 정수를 대입할 수 있다.
a[2]의 3번째 원소에 20을 대입해 보자.
a[2][2]=10;
아래 예제와 그림을 보고 2차원 배열을 나의 것으로 만들자.
Array8.java
public class Array8{
public static void main(String[] args){
int[][] a; // 2차원 배열의 레퍼런스, a
a=new int[3][]; // 1차원 배열의 레퍼런스, a[0], a[1], a[2]
a[0]=new int[5]; // a[0][0], a[0][1], a[0][2], a[0][3], a[0][4]
a[1]=new int[4]; // a[1][0], a[1][1], a[1][2], a[1][3]
a[2]=new int[3]; // a[2][0], a[2][1], a[2][2]
System.out.println(a.length);
System.out.println(a[0].length);
System.out.println(a[1].length);
System.out.println(a[2].length);
}
}
출력 결과
3
5
4
3
a의 원소는 a[0], a[1], a[2]이고 개수는 3개이다. a[1]의 원소는 a[1][0], a[1][1], a[1][2], a[1][3]이고 개수는 4개이다.
[그림 6-5] 2차원 배열 a
아래는 2차원 배열을 만들고 사용하는 기본적인 예제이다.
Array9.java
public class Array9{
public static void main(String[] args){
int[][] a;
a=new int[2][];
a[0]=new int[2];
a[1]=new int[3];
a[0][0]=10;
a[1][1]=20;
for(int i=0;i<a.length;i++){ // a.length = 1차원 배열의 개수
for(int j=0;j<a[i].length;j++) // a[i].length = a[i]의 원소의 개수
System.out.print(a[i][j]+" ");
System.out.println();
}
}
}
출력 결과
10 0
0 20 0
초기화하지 않은 원소에는 0이 대입되었다.
다음 예제는 2차원 배열의 원소의 합을 구하는 프로그램이다.
Array10.java
public class Array10{
public static void main(String[] args){
int[][] a;
a=new int[3][];
int[] sum=new int[3]; // 합을 기억할 배열
a[0]=new int[]{100, 80, 80, 75, 90}; // 배열의 초기화
a[1]=new int[]{50, 60, 60, 65, 55};
a[2]=new int[]{100, 100, 100, 100, 100};
for(int i=0;i<a.length;i++)
for(int j=0;j<a[i].length;j++)
sum[i]+=a[i][j]; // 배열의 합을 구한다.
for(int i=0;i<sum.length;i++) // sum[i] 출력
System.out.println("합계= "+sum[i]);
}
}
출력 결과
합계= 425
합계= 290
합계= 500
sum[i]가 기억하고 있는 값은 다음과 같다.
sum[0]=a[0][0]+a[0][1]+a[0][2]+a[0][3]+a[0][4] = 425
sum[1]=a[1][0]+a[1][1]+a[1][2]+a[1][3]+a[1][4] = 290
sum[2]=a[2][0]+a[2][1]+a[2][2]+a[2][3]+a[2][4] = 500
아래는 객체형 2차원 배열에 대한 예제다.
Array12.java
public class Array11{
public static void main(String[] args){
String[][] s=new String[2][];
s[0]=new String[2]; // s[0][0], s[0][1] 이 만들어짐
s[1]=new String[2];
s[0][0]=new String("가나다");
s[0][1]=new String("ABC");
s[1][0]=new String("한국인");
s[1][1]=new String("양키");
System.out.println(s[0][0]);
System.out.println(s[1][1]);
}
}
출력 결과
가나다
양키
혼자 해보기
Alone6_3.java
출력 결과와 같이 실행되도록 아래 코드를 완성하라.
public class Alone6_3{
public static void main(String[] args){
char[][] ch = new char[10][];
for(int i=0; i<ch.length; i++)
ch=new char[10];
for(int i=0; i<ch.length; i++){
for(int j=0; j<ch[i].length; j++){
// 여기에 코드 삽입
}
for(int i=0; i<ch.length; i++){
for(int j=0; j<ch[i].length; j++)
System.out.println(ch[i][j]);
System.out.println();
}
}
}
출력 결과 예시
☆☆☆☆☆☆☆☆☆☆
☆☆★★★★★★☆☆
☆★☆★★★★☆★☆
☆★★☆★★☆★★☆
☆★★★☆☆★★★☆
☆★★★☆☆★★★☆
☆★★☆★★☆★★☆
☆★☆★★★★☆★☆
☆☆★★★★★★☆☆
☆☆☆☆☆☆☆☆☆☆
3차원 배열
3차원 배열은 2차원 배열의 배열이다.
int[][][] a=new int[2][][];
[][][]은 3차원 배열을 나타낸다. new int[2][][]는 2차원 배열의 레퍼런스 배열을 만든다. 따라서 a[0], a[1]이 생긴다. [][] 안이 비어있는 이유는 아직 2차원 배열의 객체가 없기 때문이다.
a[0]=new int[2][]; // x1
a[1]=new int[3][]; // x2
x1행은 a[0]이 2차원 배열의 레퍼런스이므로 a[0]에 1차원 배열의 레퍼런스 배열을 할당한다. 따라서 a[0][0], a[0][1] 가 만들어진다. x2행도 마찬가지 방법으로 a[1][0], a[1][1], a[1][2]가 만들어진다.
a[0][0]=new int[4]; // x1
a[0][1]=new int[4]; // a[0][1][0], a[0][1][1], a[0][1][2], a[0][1][3]
a[1][0]=new int[3];
a[1][1]=new int[3];
a[1][2]=new int[3]; // a[1][2][0], a[1][2][1], a[1][2][2]
x1행은 정수 배열을 4개 만들고 a[0][0]가 참조하게 한다. 따라서 a[0][0][0], a[0][0][1], a[0][0][2], a[0][0][3]이 만들어진다.
나머지도 마찬가지이다.
3차원 배열 a를 그림으로 나타내면 [그림 6-6]과 같다.
[그림 6-6] 3차원 배열
다음 예제를 해보자.
Array12.java
public class Array12{
public static void main(String[] args){
int[][][] a=new int[2][][]; // a[0], a[1]
a[0]=new int[2][]; // a[0][0], a[0][1]
a[1]=new int[3][]; // a[1][0], a[1][1], a[1][2]
a[0][0]=new int[4]; // a[0][0][0], a[0][0][1], a[0][0][2], a[0][0][3]
a[0][1]=new int[4]; // a[0][1][0], a[0][1][1], a[0][1][2], a[0][1][3]
a[1][0]=new int[3];
a[1][1]=new int[3];
a[1][2]=new int[3]; // a[1][2][0], a[1][2][1], a[1][2][2]
a[0][0][0]=10;
a[1][1][1]=20;
System.out.println(a.length);
System.out.println(a[1].length);
System.out.println(a[1][2].length);
System.out.println(a[1][1][1]);
}
}
출력 결과
2
3
3
20
알아두기
2차원 배열의 레퍼런스를 정의하는 방법
int[][] a;
int[] a[];
int a[][];
위 세 경우 모두 2차원 배열의 레퍼런스 변수 a를 정의하는 것이다. 하지만 첫 번째 방법을 사용하는 것이 가장 바람직하다.
주의하기
배열 만들기
int[] a, b;
위와 같이 변수를 정의하면 b는 정수형 변수일까? 답: 아니다.
b도 a와 같이 1차원 배열의 레퍼런스이다.
int[] a, b[]; 이렇게 정의하면 b는 2차원 배열의 레퍼런스이다.
int a[], b; 이렇게 정의하면 b는 배열이 아니라 정수형 변수이다.
아래 예제로 확인해보자.
Array13.java
public class Array13{
public static void main(String[] args){
int[] a, b;
b=new int[3];
b[0]=30;
System.out.println(b[0]);
}
}
출력 결과
30
연습 문제
1. 20개의 원소를 가지는 정수형 1차원 배열 f를 만들자. 다음 조건을 만족하도록 값을 대입하고 출력해보자.
f[0]=1, f[1]=2
f[i+2]=f[i]+f[i+1]
2. 1번 문제에서 임의의 n에 대하여 f[n]의 값을 출력하는 프로그램을 만들어보자. 배열을 사용하는 방법과 사용하지 않는 방법에 대하여 생각해보자.
3. 100개의 원소를 가지는 정수형 1차원 배열 rnd를 만들자. 각 원소에 0.0에서 1.0사이의 난수를 대입하고 평균을 구해보자.
※ 난수는 Math.random()을 이용한다.
double a=Math.random(); // a는 0.0 ~ 1.0 사이의 값을 갖는다.
4. 문자형 2차원 배열을 만들고 다음과 같이 출력되도록 각 원소에 값을 대입하고 출력해보자.
ABCDEFGHIJ
CDEFGHIJKL
EFGHIJKLMN
GHIJKLMNOP
5. 문자형 2차원 배열을 만들고 다음과 같이 출력되도록 각 원소에 값을 대입하고 출력해보자.
1@2@3@4@5@
2@3@4@5@6@
3@4@5@6@7@
4@5@6@7@8@
5@6@7@8@9@
6. 다음 조건을 만족하는 학생 클래스를 정의하고 객체를 만들어서 테스트해보자.
학생은 이름과 학번, 점수 배열을 가진다. 점수 배열은 열 개 과목의 점수를 기억할 수 있다. 점수를 입력받는 메소드와 총점, 평균을 반환하는 메소드를 제공한다.
7. 다음 조건을 만족하는 오목판 클래스를 정의하고 객체를 만들어서 테스트해보자.
오목판은 15×15 크기의 격자로 구성된다. 좌표(x, y) 위치에 '흑' 또는 '백' 돌을 놓을 수 있고, (x, y)에 놓여진 돌이 무엇인 지도 알 수 있다. 승패를 알 수 있는 메소드도 제공한다.
8. 마방진(Magic Square)이란 정사각형 안에 놓인 가로, 세로, 대각선에 있는 수들의 합이 일정한 사각형을 말한다. 물론 1부터 n까지의 수를 사용하되 중복되지 않는다.
[그림 6-7] 마방진
홀수형 마방진을 만드는 방법은 여러 가지가 있다. 다음과 같이 실행되는 프로그램을 제작해보자. 다른 홀수에 대해서도 올바르게 수행되어야 한다.
실행 결과 예시
<7 * 7 마방진>
28 19 10 1 48 39 30
29 27 18 9 7 47 38
37 35 26 17 8 6 46
45 36 34 25 16 14 5
4 44 42 33 24 15 13
2 3 43 41 32 23 21
20 11 2 49 40 31 22
'프로그램 > JAVA' 카테고리의 다른 글
java context lookup (0) 2008.04.10 컨텍스트 리스너에 대한 간단한 예제 소스 (1) 2008.04.03 ServletConfig 와 ServletContext의 차이 (0) 2008.04.03 Syntax error on token "}", delete this token 이런 오류였는데... (0) 2008.04.02 java.lang.reflect.InvocationTargetException (0) 2008.04.01 reflect예제. (0) 2008.04.01 JDK 설치 (0) 2007.11.13