반응형
package array;
public class Ex {
public static void main(String[] args) {
/*
* 배열(Array)
* - 같은 타입 데이터 여러개를 하나의 묶음(변수)으로 다루는 메모리 공간
*
* [ 특징 ]
* 1. 같은 타입 데이터만 저장 가능
* 2. 여러 변수에 해당하는 메모리 공간이 연속된 공간에 차례대로 생성됨
* => 한 번 생성된 배열은 크기 변경 불가능
* 3. 기본 데이터타입과 참조 데이터타입 모두 배열로 사용 가능
* 4. 배열은 선언, 생성, 초기화의 3단계 과정을 거쳐서 사용
* 5. 배열 생성 시 각 공간에 해당하는 인덱스(번호)가 자동으로 부여됨
* => 0부터 시작하며, 배열크기-1 까지 부여됨
* 6. 배열이 생성될 경우 배열의 데이터 저장 공간은
* 배열의 데이터타입에 해당하는 기본값으로 자동으로 초기화
* (byte, short, int = 0, long = 0L, float = 0.0f, double = 0.0,
* char = '\u0000' 또는 0, boolean = false, String = null)
* 7. 배열의 이름(변수명)을 사용하여 배열에 접근 가능(인덱스 필요)
* 8. 배열의 크기는 배열명.lengh 속성을 통해 알아낼 수 있음
*
* < 배열 선언 기본 문법 >
* 데이터타입[] 변수명;
* => 변수 선언과 유사하나, 데이터타입 뒤에 [] 기호를 붙여 배열 표시
* => 배열 공간이 생성되기 전이므로, 아직 데이터 저장은 불가
* => 선언된 배열의 변수는 참조형 변수로 취급됨
* (주의! int 는 기본형이지만, int[] 은 참조형)
*
* < 배열 생성 기본 문법 >
* 변수명 = new 데이터타입[배열크기];
* => new 키워드를 사용하여 배열 공간을 생성하는데
* 데이터타입 뒤의 대괄호 안에 생성할 배열의 크기를 명시
* => 생성되는 배열의 위치(주소값)를 선언된 배열 타입 변수에 저장
* => 이제, 실제 메모리 공간이 생성되었으므로 데이터 저장이 가능
* => 생성된 배열에는 자동으로 인덱스 번호가 부여됨
* (인덱스번호는 0 ~ 배열크기-1 까지 자동으로 부여됨)
*
* < 배열 선언 및 생성을 하나의 문장으로 결합 >
* 데이터타입[] 변수명 = new 데이터타입[배열크기];
*
* < 배열 접근 기본 문법 >
* 변수명[인덱스]
* => 변수명에 해당하는 주소(배열 공간)에 접근한 뒤
* 인덱스에 해당하는 데이터 저장 공간에 접근
* => 배열에 데이터 초기화(저장) 시
* 변수명[인덱스] = 데이터;
*
* < 반복문을 사용한 배열의 모든 인덱스 접근 기본 공식 >
* for(int i = 0; i < 배열명.length; i++) {
* // 배열명[i] 형태로 접근
* }
*/
// 학생 점수 5개를 별도의 변수에 저장하고 관리하는 경우
// int score1 = 90, score2 = 60, score3 = 80, score4 = 100, score5 = 50;
// int scoreTotal = score1 + score2 + score3 + score4 + score5;
// ======================================================
// 학생 점수 5개(정수)를 저장할 배열(score) 선언 및 생성, 초기화
// 1. 배열 선언 : 데이터타입[] 배열명;
// int[] score; // int형 정수 여러개를 저장할 배열 score 를 선언
// => 아직 데이터를 저장할 수 있는 메모리 공간은 생성되기 전
// score = 90; // 오류 발생! 배열 이름으로 사용되는 변수에 데이터 저장 불가!
// 2. 배열 생성 : 배열명 = new 데이터타입[배열크기];
// score = new int[5];
// 연속적인 int형 배열 공간 5개를 생성하고,
// 해당 공간의 메모리 주소를 int[] 타입 변수 score 에 저장
// => 이 때, 5개의 메모리 공간에는 각각의 인덱스 번호가 자동으로 부여됨
// (인덱스 번호는 0 ~ 4 까지 부여됨)
// 배열 선언 및 생성을 하나의 문장으로 결합
int[] score = new int[5];
// 배열에 접근하여 각 배열 공간의 데이터 출력
// => 배열명이 score 이므로 score[인덱스] 형식으로 접근
// System.out.println(score); // 배열명 그대로 출력 시 주소값 출력(데이터 X)
System.out.println(score[0]); // score 배열의 0번 인덱스 데이터 값 출력
System.out.println(score[1]); // score 배열의 1번 인덱스 데이터 값 출력
System.out.println(score[2]); // score 배열의 2번 인덱스 데이터 값 출력
System.out.println(score[3]); // score 배열의 3번 인덱스 데이터 값 출력
System.out.println(score[4]); // score 배열의 4번 인덱스 데이터 값 출력
// => 이 때, 배열은 자동으로 기본값으로 초기화 되므로 0 출력됨
/*
* 주의! 생성된 배열의 인덱스 범위를 벗어나는 배열 접근 시 오류 발생!
* => 단, 문법적으로 오류가 아니기 때문에 코드 상에서는 알 수 없고
* 프로그램 실행 시점에서 오류가 발견됨
*/
// System.out.println(score[5]); // 실행 시 오류 발생!
// Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
// at array.Ex.main(Ex.java:82)
// => ArrayIndexOutOfBoundsException: 5 => 5번 인덱스가 범위를 벗어남
// => array.Ex.main(Ex.java:82) => Ex.java 클래스의 82번 라인이 오류
System.out.println("------------------");
// 배열에 데이터 저장(초기화) => 90, 100, 80, 70, 50
score[0] = 90;
score[1] = 100;
score[2] = 80;
score[3] = 70;
score[4] = 50;
// score[10] = 100; // 존재하지 않는 인덱스 접근. 실행 시 오류 발생!
// System.out.println(score[0]); // score 배열의 0번 인덱스 데이터 값 출력
// System.out.println(score[1]); // score 배열의 1번 인덱스 데이터 값 출력
// System.out.println(score[2]); // score 배열의 2번 인덱스 데이터 값 출력
// System.out.println(score[3]); // score 배열의 3번 인덱스 데이터 값 출력
// System.out.println(score[4]); // score 배열의 4번 인덱스 데이터 값 출력
// for문을 사용하여 배열 인덱스 범위(0 ~ 4)까지 반복하면서
// 출력문을 통해 배열 인덱스에 차례대로 접근하여 데이터 출력
// for(int i = 0; i < 5; i++) { // for(int i = 0; i <= 4; i++) 동일
// // => 0 ~ 4 까지 1씩 증가하는 제어변수 i를 인덱스 번호로 활용 가능
// System.out.println(score[i]); // score[0] ~ score[4] 까지 대응
// }
// => 배열의 모든 인덱스에 접근 시 조건식에 배열 크기 직접 지정할 경우
// 배열 크기가 변경되면 조건식 코드도 변경되어야 한다!
// 배열명.length 속성을 사용하여 배열의 크기(길이)를 알아낼 수 있다!
System.out.println("배열 score 의 크기 : " + score.length);
// => 배열의 크기값을 반복문의 조건식에 활용하면
// 배열 크기가 변경되어도 동적으로 대응 가능
// 배열 전체 접근 기본 공식을 사용하여 배열 데이터 모두 출력
for(int i = 0; i < score.length; i++) { // 배열크기-1 까지 접근 가능
// System.out.println(score[i]);
System.out.println(i + "번 인덱스 : " + score[i]);
}
System.out.println("=====================================");
// 배열 선언 시 [] 기호 위치에 따른 차이점
int[] arr1, arr2; // arr1, arr2 모두 int[] 타입 변수로 선언됨
int arr3, arr4[]; // arr3 는 int, arr4 는 int[] 타입 변수로 선언됨
// => 따라서, 자바에서 추천하는 문법(데이터타입 뒤 [] 명시) 사용 권장
}
}
/*
90
100
80
70
50
=========================
배열 score의 크기 : 5
=========================
0번 인덱스: 90
1번 인덱스: 100
2번 인덱스: 80
3번 인덱스: 70
4번 인덱스: 50
=========================
*/package array;
public class Ex2 {
public static void main(String[] args) {
/*
* < 배열 선언, 생성, 초기화를 한꺼번에 수행하는 문법 >
* 데이터타입[] 변수명 = {데이터1, 데이터2, ..., 데이터n};
* => 배열 생성 문법을 별도로 명시하지 않고
* 중괄호를 사용하여 초기화할 데이터를 리터럴 형태로 전달하면
* 해당 데이터 갯수만큼 배열 공간이 자동으로 생성됨
* => n개 만큼의 공간을 생성하면서 인덱스번호가 0 ~ n-1 까지 부여되고
* 자동으로 기본값으로 초기화됨
*/
// int[] arr = new int[5];
// arr[0] = 1;
// arr[1] = 2;
// arr[2] = 3;
// arr[3] = 4;
// arr[4] = 5;
// 위의 문장들을 하나로 결합하여 리터럴로 즉시 초기화까지 수행
int[] arr = {1, 2, 3, 4, 5};
// => 주의! 5개의 리터럴 지정 시 5개 데이터 저장 공간만 생성되므로
// 추가적인 데이터 저장은 불가능하게 된다!
// 배열 arr 의 모든 요소 출력
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("------------------------------");
// int형 배열 arr2 를 먼저 선언한 후
// 별도로 정수리터럴 1, 2, 3, 4, 5 로 한꺼번에 초기화하는 경우
int[] arr2;
// arr2 = new int[5]; // 배열 생성 문장 사용 시
// arr2 = {1, 2, 3, 4, 5}; // 오류 발생! 별도로 초기화 시 사용 불가능
// => new 키워드를 사용하는 방법과 결합하여 문법을 지정해야함
arr2 = new int[]{1, 2, 3, 4, 5};
// => 주의! 배열 크기는 지정하지 않도록 한다!
System.out.println("------------------------------");
// String 타입 문자열 데이터 3개("Java", "JSP", "Android")를 저장하는
// 배열 strArr 을 생성하고 리터럴로 즉시 초기화까지 수행 후 출력
String[] strArr = {"Java", "JSP", "Android"};
for(int i = 0; i < strArr.length; i++) {
System.out.println(strArr[i]);
}
System.out.println("=============================");
int[] a = {1, 2, 3};
int[] b = {4, 5, 6};
int[] c = {7, 8, 9};
a = b; // b 의 주소값을 a 에 저장
// 기존에 a가 가리키던(참조하던) 1, 2, 3 저장 공간을 버리고
// b 가 가리키는 4, 5, 6 저장 공간의 주소값을 전달받아 참조하게 됨
// 이 때, 기존 1, 2, 3 저장 공간은 더 이상 참조되지 않으므로
// 불필요한 메모리 공간이 되어 Garbage Collector 에 의한 정리 대상이 됨
// => 즉, 더 이상 필요없는 메모리 공간은 자동으로 정리됨
b = c; // c 의 주소값을 b 에 저장
// 기존에 b가 참조하던 4, 5, 6 저장 공간을 버리고
// c 가 가리키는 7, 8, 9 저장 공간의 주소값을 전달받아 참조
// 이 때, 기존 4, 5, 6 저장 공간은 여전히 a에 의해 참조되고 있으므로
// Garbage Collector 에 의한 정리 대상이 아니다!
}
}
/*
1
2
3
4
5
------------------------------------
Java
JSP
Android
------------------------------------
*/package array;
public class Ex3 {
public static void main(String[] args) {
/*
* 배열 내의 데이터에 대한 연산 누적
* 0. 연산을 누적할 변수 선언 및 초기화
* 1. 배열 생성 및 데이터 저장
* 2. for문을 사용하여 배열 내의 모든 인덱스에 차례대로 접근
* => 배열의 인덱스 번호를 제어변수로 지정하여
* 해당 배열 내의 데이터를 누적 변수에 누적
* 3. for문 종료 후 누적 변수 값 사용
*/
// 0. 합계를 누적할 누적변수(int형 변수 total) 선언 및 초기화
int total = 0;
// 1. 정수형 데이터 1 ~ 10까지를 저장하는 배열 arr 생성
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// 2. for문을 사용하여 배열 내의 모든 인덱스에 차례대로 접근
for(int i = 0; i < arr.length; i++) {
// System.out.println(arr[i]); // 배열 내의 모든 데이터 출력
// 배열 내의 모든 데이터를 차례대로 total 변수에 누적
total += arr[i]; // 배열 arr 의 i번 인덱스 데이터를 total 에 누적
}
// 3. 누적 변수(합계) 출력
System.out.println(total);
System.out.println("===============================");
int oddTotal = 0; // 홀수의 합을 누적할 변수
int evenTotal = 0; // 짝수의 합을 누적할 변수
// 배열 내의 모든 인덱스에 차례대로 접근
// => 이 때, 각 인덱스 데이터가 홀수, 짝수일 때 각각의 변수에 누적
for(int i = 0; i < arr.length; i++) {
if(arr[i] % 2 == 0) { // 배열 데이터 arr[i] 가 짝수일 때
// 짝수 합을 저장하는 evenTotal 에 배열 데이터를 누적
evenTotal += arr[i];
} else { // 배열 데이터 arr[i] 가 홀수일 때
// 홀수 합을 저장하는 oddTotal 에 배열 데이터를 누적
oddTotal += arr[i];
}
}
System.out.println("배열 내의 홀수의 합 = " + oddTotal); // 25
System.out.println("배열 내의 짝수의 합 = " + evenTotal); // 30
System.out.println("=====================================");
// 배열 내의 정수 중 최대값을 max 에 저장 후 출력
int max = 0;
int[] array = {1, 5, 3, 8, 7};
for(int i = 0; i < array.length; i++) {
// System.out.println(array[i]);
// max 에 저장된 값과 배열(array)의 i번에 저장된 값을 비교하여
// max 값보다 배열 데이터가(array[i]) 더 클 경우
// 배열 데이터(array[i])를 max 변수에 저장
if(array[i] > max) { // if(max < array[i]) {}
System.out.println(array[i] + " 가(이) " + max + "보다 크다!");
max = array[i];
System.out.println("======> max = " + max);
} else {
System.out.println(array[i] + " 가(이) " + max + "보다 크지 않다!");
}
}
System.out.println("max = " + max);
System.out.println("==============================");
// 주의! 최대값 등의 비교 시 비교 대상을 변수에 직접 저장할 경우
// 조건에 만족하지 않은 데이터가 있을 수 있다!
// 따라서, 배열 내의 데이터를 비교해야하는 경우
// 비교 대상 값으로 배열 내의 데이터를 갖고 시작하는 것이 좋다!
// ex) 음수끼리의 최대값을 계산하는데 초기값으로 0을 설정하는 경우
// 모든 데이터가 0보다 크지 않으므로 최대값 계산이 불가능하게 됨
// => 따라서, 0 대신 배열의 첫번째 데이터를 초기값으로 갖고 비교
int[] array2 = {-9, -5, -3, -8, -7};
// array2 배열의 0번 인덱스 데이터를 최대값으로 저장
int max2 = array2[0];
// 주의! 0번 데이터를 이미 최대값으로 저장했기 때문에
// 0번 인덱스를 제외한 나머지값만 비교하면 됨(1번부터 반복)
for(int i = 1; i < array2.length; i++) {
System.out.println(array2[i] + " vs " + max2);
if(array2[i] > max2) {
max2 = array2[i];
}
}
System.out.println("max2 = " + max2);
}
}
/*
55
=============================
배열 내의 홀수의 합: 25
배열 내의 짝수의 합: 30
=============================
1 가(이) 0보다 크다!
======> max = 1
5 가(이) 1보다 크다!
======> max = 5
3 가(이) 5보다 크지 않다!
8 가(이) 5보다 크다!
======> max = 8
7 가(이) 8보다 크지 않다!
max = 8
=============================
-5 vs -9
-3 vs -5
-8 vs -3
-7 vs -3
max2 = -3
*/package array;
public class Ex4 {
public static void main(String[] args) {
/*
* 2차원 배열
* - 1차원 배열 여러개의 묶음을 관리하는 배열
* - 행과 열로 이루어진 테이블(표) 구조와 유사한 구조의 배열
* => 행과 열의 인덱스는 1차원 배열과 동일(0부터 시작)
*
* < 2차원 배열 선언 및 생성 기본 문법 >
* 데이터타입[][] 변수명 = new 데이터타입[행크기][열크기];
*
* < 2차원 배열 접근 기본 문법 >
* 변수명[행인덱스][열인덱스];
*
* < 2차원 배열 선언, 생성, 초기화를 한꺼번에 수행하는 문법 >
* 데이터타입[][] 변수명 = {
* {값1, 값2, ..., 값n}, // 0행(0열, 1열, ..., n열)
* {값1, 값2, ..., 값n}, // 1행(0열, 1열, ..., n열)
* ....생략....
* {값1, 값2, ..., 값n}, // m행(0열, 1열, ..., n열)
* };
*/
// int형 2차원 배열 arr 생성(3행 2열 크기)
// int[][] arr;
// arr = new int[3][2];
// 위의 두 문장을 한 문장으로 결합(선언 및 생성 동시에 수행)
int[][] arr = new int[3][2];
/*
* 0열 1열
* -----------------------
* 0행 | 1(0,0) | 2(0,1) |
* -----------------------
* 1행 | 3(1,0) | 4(1,1) |
* -----------------------
* 2행 | 5(2,0) | 6(2,1) |
* -----------------------
*/
arr[0][0] = 1; arr[0][1] = 2;
arr[1][0] = 3; arr[1][1] = 4;
arr[2][0] = 5; arr[2][1] = 6;
System.out.println(arr[0][0]);
System.out.println(arr[0][1]);
System.out.println(arr[1][0]);
System.out.println(arr[1][1]);
System.out.println(arr[2][0]);
System.out.println(arr[2][1]);
System.out.println("-----------------------");
/*
* 0열 1열
* -----------------------
* 0행 | 1(0,0) | 2(0,1) |
* -----------------------
* 1행 | 3(1,0) | 4(1,1) |
* -----------------------
* 2행 | 5(2,0) | 6(2,1) |
* -----------------------
*/
int[][] arr2 = {
// 전체 블록 내의 중괄호(블록) 갯수 = 행의 갯수
// 내부 중괄호(블록) 내의 데이터 갯수 = 열의 갯수
{1, 2}, // 0행(0열, 1열)
{3, 4}, // 1행(0열, 1열)
{5, 6} // 2행(0열, 1열)
};
System.out.println("==============================");
/*
* 이름을 저장하는 배열 names 생성하고 다음과 같이 초기화
* --------------------------------------------------------
* 0행 : 홍길동 이순신 강감찬
* 1행 : 김태희 전지현 송혜교
* 2행 : 유재석 정우성 조인성
* --------------------------------------------------------
*/
String[][] names = {
{"홍길동", "이순신", "강감찬"},
{"김태희", "전지현", "송혜교"},
{"유재석", "정우성", "조인성"}
};
}
}package array;
public class Test {
public static void main(String[] args) {
// int형 배열 공간 5개를 생성(arr)하고 임의의 정수 5개로 초기화 후 출력
// int[] arr;
// arr = new int[5];
int[] arr = new int[5];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
// arr[4] = 50; // 초기화하지 않을 경우 4번 인덱스는 0으로 자동 초기화됨
for(int i = 0; i < arr.length; i++) {
System.out.println(i + "번 인덱스 데이터 : " + arr[i]);
}
/*
0번 인덱스 데이터 : 10
1번 인덱스 데이터 : 20
2번 인덱스 데이터 : 30
3번 인덱스 데이터 : 40
4번 인덱스 데이터 : 0
*/
System.out.println("====================================");
// boolean 타입 배열 3개 생성하고
// 임의의 boolean 타입 데이터 초기화 후 출력
boolean[] arr2 = new boolean[3];
arr2[0] = true;
// 1번, 2번 인덱스 초기화하지 않을 경우 기본값 false 로 자동 초기화 됨
for(int i = 0; i < arr2.length; i++) {
System.out.println(i + "번 인덱스 데이터 : " + arr2[i]);
}
/*
0번 인덱스 데이터 : true
1번 인덱스 데이터 : false
2번 인덱스 데이터 : false
*/
System.out.println("====================================");
// String 타입 배열 3개 생성하고
// 0번 "홍길동", 1번 "이순신" 문자열로 초기화 후 출력
String[] arr3 = new String[3];
arr3[0] = "홍길동";
arr3[1] = "이순신";
for(int i = 0; i < arr3.length; i++) {
System.out.println(i + "번 인덱스 데이터 : " + arr3[i]);
}
/*
0번 인덱스 데이터 : 홍길동
1번 인덱스 데이터 : 이순신
2번 인덱스 데이터 : null
*/
System.out.println("===============================");
// double 타입 데이터 5개를 저장하는 배열 arr4 생성 후
// 임의의 4개의 실수로 초기화 후 전체 데이터 차례대로 출력
// double[] arr4;
// arr4 = new double[5];
double[] arr4 = new double[5];
arr4[0] = 1.1;
arr4[1] = 2.2;
arr4[2] = 3.3;
arr4[3] = 4.4;
for(int i = 0; i < arr4.length; i++) {
System.out.println(arr4[i]);
/*1.1
2.2
3.3
4.4
0.0
*/
}
}
}배열문제 JAVA0416-Test4 다시 풀어보기
package array;
public class Test4 {
public static void main(String[] args) {
int[][] array = {
{95,86},
{83,92,96},
{78,83,93,87,88}
};
//누적값 저장할 변수 선언
int sum = 0;
double avg = 0.0;
int count = 0;
for(int i =0; i <array.length; i++) { //행크기 반복(3번)
for(int j=0; j <array[i].length; j++) { //열크기 반복(10번)
sum += array[i][j]; //데이터값 sum에 누적
count++; //안쪽 for문이 10번 반복할 동안 증감
}
}
avg = (double)sum/ count; // 881.0 / 10 = 88.1
System.out.println("sum : " +sum);
System.out.println("avg : " + avg);
System.out.println("===================================");
/*
* 거스름돈을 몇 개의 동전으로 지불할 수 있는지를 계산하는 문제이다.
* 변수 money 의 금액을 동전으로 바꾸었을 때
* 각각 몇 개의 동전이 필요한지 계산해서 출력하라.
* 단, 가능한 한 적은 수의 동전으로 거슬러 주어야한다
* [Hint] 나눗셈 연산자와 나머지 연산자를 사용해야 한다.
*
* [ 출력 예시 ]
* money = 2680
* 500원 = 5
* 100원 = 1
* 50원 = 1
* 10원 = 3
*/
int[] coinUnit = {500, 100, 50, 10};
int money = 2680;
System.out.println(money);
for(int i = 0; i <coinUnit.length; i++) {
/*
* 거스름돈(money)을 각 동전으로 나누었을 때 몫 = 필요 동전 수
* 거스름돈(money)을 각 동전으로 나눈 나머지 = 남은 거스름돈
*/
System.out.println(coinUnit[i] + "원 : " + money/coinUnit[i]);
money%= coinUnit[i]; //**데이터값 0자리부터 나눠서 남은 값을 차레대로 나눈 나머지
}
System.out.println("남은 거스름돈 : " + money);
}
}반응형
'JAVA' 카테고리의 다른 글
| [Java] 객체지향(Method) (0) | 2021.10.28 |
|---|---|
| [Java] 배열 테스트 문제 (0) | 2021.10.28 |
| [Java] 반복문 (0) | 2021.10.26 |
| [Java] 다중 else if 문, 중첩 if문, switch문 (0) | 2021.10.26 |
| [Java] 조건문(if문, else if문) (0) | 2021.10.26 |