이진 검색(binary search)
요소가 오름차순 또는 내림차순으로 정렬된 배열에서 검색하는 알고리즘 → 데이터가 키값으로 이미 정렬(sort)되어 있는 것이 전제 조건
종료 조건은 일치하는 값을 찾거나 더 이상 검색 범위가 없을 때
선형 검색보다 빠르게 검색 가능
이진 검색
package ch03_3;
import java.util.Scanner;
// 이진 검색
public class Ex10_binSearch {
// 요솟수가 n개인 배열 a에서 key와 같은 요소를 이진 검색
static int binSearch(int[] a, int n, int key) {
int pl = 0; // 검색 범위의 첫 인덱스
int pr = n - 1; // 검색 범위의 끝 인덱스
do {
int pc = (pl + pr) / 2; // 중앙 요소의 인덱스
if(a[pc] == key) {
return pc; // 검색 성공
}
else if (a[pc] < key) {
pl = pc + 1; // 검색 범위를 뒤쪽 절반으로 좁힘
} else {
pr = pc - 1; // 검색 범위를 앞쪽 절반으로 좁힘
}
} while (pl <= pr);
return -1; // 검색 실패
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("요솟수: ");
int num = scanner.nextInt();
int[] x = new int[num]; // 요솟수가 num인 배열
System.out.println("오름차순으로 입력하세요.");
System.out.print("x[0]: ");
x[0] = scanner.nextInt();
for (int i = 1; i < num; i++) {
do{
System.out.print("x[" + i + "]: ");
x[i] = scanner.nextInt();
} while (x[i] < x[i - 1]); // 바로 앞 요소보다 작으면 다시 입력
}
System.out.print("검색할 값: ");
int key = scanner.nextInt();
int index = binSearch(x, num, key); // 배열 x에서 값이 key인 요소 검색
if(index == -1) {
System.out.println("그 값의 요소가 없습니다.");
} else {
System.out.println("그 값은 x[" + index + "]에 있습니다.");
}
}
}
/*
요솟수: 5
오름차순으로 입력하세요.
x[0]: 1
x[1]: 3
x[2]: 5
x[3]: 7
x[4]: 9
검색할 값: 3
그 값은 x[1]에 있습니다.
*/
시간 복잡도(time complexity)
실행에 필요한 시간을 평가한 것
공간 복잡도(space complexity)
기억 영억과 파일 공간이 얼마나 필요한가를 평가한 것
static int seqSearch(int[] a, int n, int key) {
int i = 0; // 실행횟수 1, 복잡도 O(1)
while(i < n) { // 실행횟수 n/2, 복잡도 O(n)
if(a[i] == key) // 실행횟수 n/2, 복잡도 O(n)
return i; // 실행횟수 1, 복잡도 O(1)
i++; // 실행횟수 n/2, 복잡도 O(n)
}
retuen -1; // 실행횟수 1, 복잡도 O(1)
}
선형 검색(보초법 - for문)
package ch03_3;
import java.util.Scanner;
// 선형 검색(보초법 - for문)
public class Ex11_seqSearchSenFor {
// 배열 a의 앞쪽 n개의 요소에서 key와 일치하는 요소 선형검색(보초법)
static int seqSearchSen(int[] a, int n, int key) {
int i;
a[n] = key; // 보초를 추가
for (i = 0; a[i] != key; i++)
;
return i == n ? -1 : i;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("요솟수: ");
int num = scanner.nextInt();
int[] x = new int[num + 1]; // 요솟수가 num + 1 인 배열
for (int i = 0; i < num; i++) {
System.out.print("x[" + i + "]: ");
x[i] = scanner.nextInt();
}
System.out.print("검색할 값: "); // 키값
int key = scanner.nextInt();
int index = seqSearchSen(x, num, key); // 배열 x에서 값이 key인 요소 검색
if (index == -1) {
System.out.println("그 값의 요소가 없습니다.");
} else {
System.out.println("그 값은 x[" + index + "]에 있습니다.");
}
}
}
선형 검색(검색 과정 출력)
package ch03_3;
import java.util.Scanner;
// 선형 검색(검색 과정 출력)
public class Ex12_seqSearchEx {
// 배열 a의 앞쪽 n개의 요소에서 key와 일치하는 요소 선형검색(보초법)
static int seqSearchEx(int[] a, int n, int key) {
System.out.print(" |");
for (int i = 0; i < n; i++) {
System.out.printf("%4d", i);
}
System.out.println();
System.out.print("---+");
for (int i = 0; i < 4 * n + 2; i++) {
System.out.print("-");
}
System.out.println();
for (int i = 0; i < n; i++) {
System.out.print(" |");
System.out.printf(String.format("%%%ds*\\n", (i*4) + 3), "");
System.out.printf("%3d|", i);
for (int j = 0; j < n; j++) {
System.out.printf("%4d", a[j]);
}
System.out.println("\\n |");
if(a[i] == key) return i; // 검색 성공
}
return -1; // 검색 실패
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("요솟수: ");
int num = scanner.nextInt();
int[] x = new int[num]; // 요솟수가 num인 배열
for (int i = 0; i < num; i++) {
System.out.print("x[" + i + "]: ");
x[i] = scanner.nextInt();
}
System.out.print("검색할 값: "); // 키값
int key = scanner.nextInt();
int index = seqSearchEx(x, num, key); // 배열 x에서 값이 key인 요소 검색
if (index == -1) {
System.out.println("그 값의 요소가 없습니다.");
} else {
System.out.println("그 값은 x[" + index + "]에 있습니다.");
}
}
}
/*
| 0 1 2 3 4 5 6
---+------------------------------
| *
0| 6 4 3 2 1 9 8
|
| *
1| 6 4 3 2 1 9 8
|
| *
2| 6 4 3 2 1 9 8
|
그 값은 x[2]에 있습니다.
*/
특정 값을 갖는 배열 안의 모든 요소를 다른 배열에 카피
package ch03_3;
import java.util.Scanner;
// 특정 값을 갖는 배열 안의 모든 요소를 다른 배엘에 카피
public class Ex04_searchIndex {
// 배열 a의 앞쪽 n개 요소에서 key와 일치하는 모든 요소의 인덱스를
// 배열 idx에 순서대로 저장하고 일치하는 요솟수 반환
static int searchIdx(int[] a, int n, int key, int[] idx) {
int index = 0;
for (int i = 0; i < n; i++) {
if (a[i] == key) {
idx[index++] = i;
}
}
return index;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("요솟수 : ");
int num = scanner.nextInt();
int[] a = new int[num];
int[] idx = new int[num];
for (int i = 0; i < num; i++) {
System.out.print("a[" + i + "]: ");
a[i] = scanner.nextInt();
}
System.out.print("검색값: ");
int key = scanner.nextInt();
int count = searchIdx(a, num, key, idx);
if (count == 0) {
System.out.println("그 값의 요소는 존재하지 않습니다.");
} else {
for (int i = 0; i < count; i++) {
System.out.println("그 값은 a[" + idx[i] + "]에 있습니다.");
}
}
}
}
/*
요솟수 : 5
a[0]: 2
a[1]: 7
a[2]: 4
a[3]: 2
a[4]: 5
검색값: 2
그 값은 a[0]에 있습니다.
그 값은 a[3]에 있습니다.
*/
이진검색(검색 과정 출력)
package ch03_3;
import java.util.Scanner;
// 이진검색(검색 과정 출력)
public class Ex05_binSearchEx {
// 배열 a의 앞쪽 n개의 요소에서 key와 일치하는 요소를 이진검색(검색 과정 출력)
static int binSearchEx(int[] a, int n, int key) {
System.out.print(" |");
for (int i = 0; i < n; i++) {
System.out.printf("%4d", i);
}
System.out.println();
System.out.print("---+");
for (int i = 0; i < 4 * n + 2; i++) {
System.out.print("-");
}
System.out.println();
int pl = 0; // 검색 범위 맨 앞 인덱스
int pr = n - 1; // 검색 범위 맨 끝 인덱스
do {
int pc = (pl + pr) / 2; // 중앙 요소의 인덱스
System.out.print(" |");
if (pl != pc) {
System.out.printf(String.format("%%%ds<-%%%ds+",
(pl * 4) + 1, (pc - pl) * 4), "", "");
} else {
System.out.printf(String.format("%%%ds<-+", pc * 4 + 1), "");
}
if (pc != pr) {
System.out.printf(String.format("%%%ds->\\n", (pr - pc) * 4 - 2), "");
} else {
System.out.println("->");
}
System.out.printf("%3d|", pc);
for (int i = 0; i < n; i++) {
System.out.printf("%4d", a[i]);
}
System.out.println("\\n |");
if (a[pc] == key) {
return pc; // 검색 성공
} else if (a[pc] < key) {
pl = pc + 1; // 검색 범위를 뒤쪽 절반으로 좁힘
} else {
pr = pc - 1; // 검색 범위를 앞쪽 절반으로 좁힘
}
} while (pl <= pr);
return -1; // 검색 실패
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("요솟수: ");
int num = scanner.nextInt();
int[] a = new int[num];
System.out.println("오름차순으로 입력하세요.");
System.out.print("a[0]: ");
a[0] = scanner.nextInt();
for (int i = 1; i < num; i++) {
do {
System.out.print("a[" + i + "]: ");
a[i] = scanner.nextInt();
} while (a[i] < a[i - 1]); // 바로 앞 요소보다 작으면 다시 입력
}
System.out.print("검색 값: ");
int key = scanner.nextInt();
int idx = binSearchEx(a, num, key);
if(idx == -1) {
System.out.println("그 값의 요소는 존재하지 않습니다.");
} else {
System.out.println("그 값은 a[" + idx + "]에 있습니다.");
}
}
}
/*
검색 값: 2
| 0 1 2 3 4 5 6
---+------------------------------
| <- + ->
3| 1 2 3 5 6 8 9
|
| <- + ->
1| 1 2 3 5 6 8 9
|
그 값은 a[1]에 있습니다.
*/
이진 검색(일치하는 맨 앞 요소 찾기)
package ch03_3;
import java.util.Scanner;
// 이진 검색(일치하는 맨앞 요소 찾기)
public class Ex06_binSearchX {
// 배열 a의 앞쪽 n개의 요소에서 key와 일치하는 요소 이진검색
static int binSearchX(int[] a, int n, int key) {
int start = 0; // 검색 시작 인덱스
int end = n - 1; // 검색 끝 인덱스
do {
int index = (start + end) / 2;
if (a[index] == key) {
// key와 같은 맨앞의 요소 검색
for (; index > start; index--) {
if (a[index - 1] < key) break;
}
return index;
} else if (a[index] < key) {
start = index + 1; // 검색 범위 앞쪽 절반으로 좁힘
} else {
end = index - 1; // 검색 범위 뒤쪽 절반으로 좁힘
}
} while (start <= end);
return -1;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("요솟수: ");
int num = scanner.nextInt();
int[] a = new int[num];
System.out.println("오름차순으로 입력하세요.");
System.out.print("a[0] : ");
a[0] = scanner.nextInt();
for (int i = 1; i < num; i++) {
do {
System.out.print("a[" + i + "]: ");
a[i] = scanner.nextInt();
} while (a[i] < a[i - 1]); // 바로 앞 요소보다 작으면 다시 입력
}
System.out.print("검색 값: ");
int key = scanner.nextInt();
int index = binSearchX(a, num, key);
if(index == -1) {
System.out.println("그 값의 요소는 존재하지 않습니다.");
} else {
System.out.println("그 값은 a[" + index + "]에 있습니다.");
}
}
}
/*
요솟수: 5
오름차순으로 입력하세요.
a[0] : 1
a[1]: 2
a[2]: 2
a[3]: 4
a[4]: 6
검색 값: 2
그 값은 a[1]에 있습니다.
*/
Arrays.binarySearch로 이진 검색
package ch03_3;
import java.util.Arrays;
import java.util.Scanner;
// Arrays.binarySearch로 이진 검색
public class Ex07_binarySearchTester {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("요솟수: ");
int num = scanner.nextInt();
int[] x = new int[num];
System.out.println("오름차순으로 입력하세요.");
System.out.print("x[0]: ");
x[0] = scanner.nextInt();
for (int i = 1; i < num; i++) {
do {
System.out.print("x[" + i + "]: ");
x[i] = scanner.nextInt();
} while (x[i] < x[i - 1]); // 바로 앞 요소보다 작으면 다시 입력
}
System.out.print("검색할 값: ");
int key = scanner.nextInt();
int idx = Arrays.binarySearch(x, key); // 배열 x에서 값이 key인 요소 검색
if(idx < 0) {
System.out.println("그 값의 요소가 없습니다.");
} else {
System.out.println("그 값은 x[" + idx + "]에 있습니다.");
}
}
}
/*
요솟수: 5
오름차순으로 입력하세요.
x[0]: 18
x[1]: 20
x[2]: 43
x[3]: 65
x[4]: 86
검색할 값: 65
그 값은 x[3]에 있습니다.
*/
Arrays.binarySearch로 이진 검색(실패 시 삽입포인트 출력)
package ch03_3;
import java.util.Arrays;
import java.util.Scanner;
// Arrays.binarySearch로 이진 검색(실패시 삽입포인트 출력)
public class Ex08_binarySearchTester {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("요솟수: ");
int num = scanner.nextInt();
int[] x = new int[num];
System.out.println("오름차순으로 입력하세요.");
System.out.print("x[0]: ");
x[0] = scanner.nextInt();
for (int i = 1; i < num; i++) {
do {
System.out.print("x[" + i + "]: ");
x[i] = scanner.nextInt();
} while (x[i] < x[i - 1]); // 바로 앞 요소보다 작으면 다시 입력
}
System.out.print("검색할 값: ");
int key = scanner.nextInt();
int idx = Arrays.binarySearch(x, key); // 배열 x에서 값이 key인 요소 검색
if(idx < 0) {
int index = -idx - 1;
System.out.println("그 값의 요소는 존재하지 않습니다.");
System.out.printf("삽입 포인트는 %d입니다.\\n", index);
System.out.printf("x[%d]의 바로 앞에 %d을(를) 삽입하면 배열의 정렬상태가 유지됩니다.", index, key);
} else {
System.out.println("그 값은 x[" + idx + "]에 있습니다.");
}
}
}
/*
요솟수: 5
오름차순으로 입력하세요.
x[0]: 1
x[1]: 3
x[2]: 5
x[3]: 7
x[4]: 9
검색할 값: 8
그 값의 삽입 포인트는 4입니다.
*/
인스턴스 메서드(비정적 메서드)
static을 붙이지 않고 선언한 메서드로, 해당 클래스형의 개별 인스턴스에 속함
클래스 메서드(정적 메서드)
static을 붙여 선언한 메서드로, 특정 인스턴스에 속하지 않음
클래스 전체에 대한 처리 또는 클래스의 개별 인스턴스와 관계없는 처리를 할 때 사용함
인스턴스와 클래스 메서드
package ch03_3;
// 아이디를 부여하는 클래스
class Id{
// 클래스 변수 - 인스턴스와 관계없이 1개만 만들어짐
private static int counter = 0; // 아이디를 몇 개 부여했는지 저장
// 인스턴스 변수 - 인스턴스마다 각각 1개씩 할당됨
private int id; // 아이디
// 생성자
public Id() {
id = ++counter;
}
// counter를 반환하는 클래스 메서드 - 클래스 메서드(마지막 부여한 아이디 반환)
public static int getCounter() {
return counter;
}
// 아이디를 반환하는 인스턴스 메서드 - 인스턴스 메서드(개별 인스턴스의 아이디 반환)
public int getId() {
return id;
}
}
public class Ex09_idTester {
public static void main(String[] args) {
Id a = new Id(); // 아이디 1
Id b = new Id(); // 아이디 2
// 인스턴스 메서드 호출 - 클래스형변수.메서드이름()
System.out.println("a의 아이디: " + a.getId());
System.out.println("b의 아이디: " + b.getId());
// 클래스 메서드 호출 - 클래스이름.메서드이름()
System.out.println("부여한 아이디의 개수: " + Id.getCounter());
}
}
/*
a의 아이디: 1
b의 아이디: 2
부여한 아이디의 개수: 2
*/
문자열의 배열(자바의 키워드)에서 검색
package ch03_3;
import java.util.Arrays;
import java.util.Scanner;
// 문자열의 배열(자바의 키워드)에서 검색
public class Ex10_stringBinarySearch {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 자바에서 사용하는 키워드
String[] x = {
"abstract", "assert", "boolean", "break", "byte",
"case", "catch", "char", "class", "const",
"continue", "default", "do", "double", "else",
"enum", "extends", "final", "finally", "float",
"for", "goto", "if", "implements", "import",
"instanceof", "int", "interface", "long", "native",
"new", "package", "private", "protected", "public",
"return", "short", "static", "strictfp", "super",
"switch", "synchronized", "this", "throw", "throws",
"transient", "try", "void", "volatile", "while"
};
System.out.print("원하는 키워드를 입력하세요: ");
String key = scanner.next();
int idx = Arrays.binarySearch(x, key); // 배열 x에서 값이 key인 요소 검색
if (idx < 0) {
System.out.println("해당 키워드가 없습니다.");
} else {
System.out.println("해당 키워드는 x[" + idx + "]에 있습니다.");
}
}
}
/*
원하는 키워드를 입력하세요: int
해당 키워드는 x[26]에 있습니다.
*/
자연 정렬을 위한 클래스 정의
// Comparable 인터페이스 구현
class A implements Comparable<A> {
// 필드, 메서드 등
// compareTo 메서드 구현
public int compareTo(A c) {
// this가 c보다 크면 양의 값 반환
// this가 c보다 작으면 음의 값 반환
// this가 c와 같으면 0 반환
}
// equals 메서드 구현
public boolean equals(Object c) {
// this가 c와 같으면 true 반환
// this가 c와 같지 않으면 false 반환
}
}
자연 정렬 되지 않은 배열에서 검색하기 위한 제너릭 메서드(generic method)
static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)
// 검색 대상 a, 키값 key, 클래스 T(또는 그 상위 클래스)의 두 객체 사이 대소 관계를 생성하기 위한 comparator// java.util.Comparator의 정의
package java.util;
public interface Comparator<T> {
int compare(T o1, T o2);
boolean equals(Object obj);
}
// o1 > o2 이면 양수 반환
// o1 < o2 이면 음수 반환
// o1 == o2 이면 0 반환
클래스 X의 내부에서 COMPARATOR를 정의하는 방법
import java.util.Comparator;
class X {
// 필드, 메서드 등
// 클래스의 인스턴스 생성
public static final Comparator<T> COMPARATOR = new Comp();
// Comparator 인터페이스와 compare 메서드를 구현한 클래스
private static class Comp implements Comparator<T> {
public int compare(T d1, T d2) {
// d1이 d2보다 크면 양수 반환
// d1이 d2보다 작으면 음수 반환
// d1이 d2와 같으면 0 반환
}
}
}
신체검사 데이터 배열에서 이진 검색
package ch03_3;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
// 신체검사 데이터 배열에서 이진 검색
public class Ex11_physExamSearch {
// 신체검사 데이터 정의
static class PhyscData {
private String name; // 이름
private int height; // 키
private double vision; // 시력
// 생성자
public PhyscData(String name, int height, double vision) {
this.name = name;
this.height = height;
this.vision = vision;
}
// 문자열로 만들어 반환하는 메서드
public String toString() {
return name + " " + height + " " + vision;
}
// 키의 오름차순으로 정렬하기 위한 comparator
public static final Comparator<PhyscData> HEIGHT_ORDER = new HeightOrderComparator();
private static class HeightOrderComparator implements Comparator<PhyscData> {
public int compare(PhyscData d1, PhyscData d2) {
return (d1.height > d2.height) ? 1 : (d1.height < d2.height) ? -1 : 0;
}
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
PhyscData[] x = {
new PhyscData("강민하", 162, 0.3),
new PhyscData("이수연", 168, 0.4),
new PhyscData("황지안", 169, 0.8),
new PhyscData("유서범", 171, 1.5),
new PhyscData("김찬우", 173, 0.7),
new PhyscData("장경오", 174, 1.2),
new PhyscData("박준서", 175, 2.0),
};
System.out.print("키가 몇 cm인 사람을 찾고있나요?: ");
int height = scanner.nextInt();
int idx = Arrays.binarySearch(
x, // 배열 x에서
new PhyscData("", height, 0.0), // 키가 height인 요소를
PhyscData.HEIGHT_ORDER // HEIGHT_ORDER에 의해 검색
);
if(idx < 0) {
System.out.println("그 값의 요소가 없습니다.");
} else {
System.out.println("그 값은 x[" + idx + "]에 있습니다.");
System.out.println("찾은 데이터: " + x[idx]); // 묵시적으로, toString 메서드가 호출됨
}
}
}
/*
키가 몇 cm인 사람을 찾고있나요?: 174
그 값은 x[5]에 있습니다.
찾은 데이터: 장경오 174 1.2
*/
신체검사 데이터 배열에서 이진 검색(시력)
package ch03_3;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
// 신체검사 데이터 배열에서 이진 검색(시력)
public class Ex12_physExamSearch {
// 신체검사 데이터 정의
static class PhyscData {
private String name; // 이름
private int height; // 키
private double vision; // 시력
// 생성자
public PhyscData(String name, int height, double vision) {
this.name = name;
this.height = height;
this.vision = vision;
}
// 문자열로 만들어 반환하는 메서드
public String toString() {
return name + " " + height + " " + vision;
}
// 시력 내림차순 정렬을 위한 comparator
public static final Comparator<PhyscData> VISION_ORDER = new VisionOrderComparator();
private static class VisionOrderComparator implements Comparator<PhyscData> {
public int compare(PhyscData d1, PhyscData d2) {
return (d1.vision > d2.vision) ? 1 : (d1.vision < d2.vision) ? -1 : 0;
}
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
PhyscData[] x = {
// 배열 요소는 시력 오름차순으로 정렬
new PhyscData("강민하", 162, 0.3),
new PhyscData("이수연", 168, 0.4),
new PhyscData("김찬우", 173, 0.7),
new PhyscData("황지안", 169, 0.8),
new PhyscData("장경오", 174, 1.2),
new PhyscData("유서범", 171, 1.5),
new PhyscData("박준서", 175, 2.0),
};
System.out.print("검색할 시력: ");
double vision = scanner.nextDouble();
int idx = Arrays.binarySearch(
x, // 배열 x에서
new PhyscData("", 0, vision), // 시력이 vision인 요소를
PhyscData.VISION_ORDER // VISION_ORDER에 의해 검색
);
if(idx < 0) {
System.out.println("그 값의 요소가 없습니다.");
} else {
System.out.println("그 값은 x[" + idx + "]에 있습니다.");
System.out.println("찾은 데이터: " + x[idx]); // 묵시적으로, toString 메서드가 호출됨
}
}
}
/*
검색할 시력: 0.8
그 값은 x[3]에 있습니다.
찾은 데이터: 황지안 169 0.8
*/
제네릭스(Generics)
처리 대상의 자료형에 의존하지 않도록 클래스(인터페이스)를 구현하는 기능
자료형에 의존하지 않기에 범용(generic)으로 사용할 수 있음 → 자료형 문제로부터 안전
제네릭 클래스와 인터페이스는 클래스와 인터페이스 이름 바로 뒤에 <Type> 형식의 매개변수를 붙여 선언
class 클래스이름 <매개변수> {}
interface 인터페이스이름 <매개변수> {}
// 쉼표로 구분하면 매개변수 여러개 지정 가능
class 클래스이름 <매개변수1, 매개변수2, ...> {}
interface 인터페이스이름 <매개변수1, 매개변수2, ...> {}
파라미터 이름을 작성하는 방법
대문자 1개 사용(소문자는 가급적 사용하지 않음)
컬렉션(collection) 내부 요소의 자료형은 element의 머리글자인 E 사용
맵(Map) 내 키(key)와 값(value)의 자료형은 key와 value의 머리글자인 K와 V 사용
일반적인 자료형은 T 사용
// 파라미터에 와일드카드 지정 가능
<? extends T> // 클래스 T의 하위 클래스를 전달받음
<? super T> // 클래스 T의 상위 클래스를 전달받음
제네릭 클래스의 예
package ch03_3;
// 제네릭 클래스의 예
public class Ex13_genericClassTester {
// 제네릭 클래스의 매개변수를 T라고 작성함
static class GenericCless<T> {
private T xyz;
// 생성자
GenericCless(T t) {
this.xyz = t;
}
// xyz getter
T getXyz() {
return xyz;
}
}
public static void main(String[] args) {
// 아래와 같이 매개변수에 String을 넘기거나 Integer를 넘길수도 있음
GenericCless<String> s = new GenericCless<>("ABC");
GenericCless<Integer> n = new GenericCless<>(123);
System.out.println(s.getXyz());
System.out.println(n.getXyz());
}
}
/*
ABC
123
*/'공부기록 > 알고리즘' 카테고리의 다른 글
| Chapter 04-2. 스택과 큐_큐란 (0) | 2024.08.04 |
|---|---|
| Chapter 04-1. 스택과 큐_스택이란 (0) | 2024.08.04 |
| Chapter 03-2. 검색 알고리즘_선형 검색 (0) | 2024.08.04 |
| Chapter 03-1. 검색 알고리즘_검색 알고리즘이란 (0) | 2024.08.04 |
| Chapter 02-2. 기본 자료구조_클래스란 (0) | 2024.06.22 |
댓글