5주차 후기
이제 점점 자바가 끝나가는게 느껴진다. 진도가 나가면 나갈수록 객체지향 파트의 중요성을 깨닫게 된다. 예전에 생각 없이 공식처럼 쓰던 것들이 속에서 어떤 일이 일어나는지 조금이나마 알게 되니 좀 신기하면서 재미있기도 하고 너무 복잡하게 느껴지기도 하고 그렇다. 6주차에는 아마 자바로만 프로젝트를 진행할 거 같은데 어쩌다 보니 팀장이 되었다. 내가 맨 처음에 선생님 바로 앞자리쪽으로 앉기도 했고 주변 사람들과 서로 이해 안가는 부분이나 문제풀다가 막히는 부분을 많이 이야기 하고 했었는데 아무래도 선생님과 자리가 가깝다 보니까 선생님이 그런 얘기들을 자연스럽게 들으시면서 팀장을 정하시지 않았을까 생각이든다. 팀장이 4명인데 4명중 3명은 맨 앞줄이고 나머지 한명도 두번째 줄이라 아마 내 생각이 맞다고 본다ㅋㅋ. 처음에는 엄청 부담스러웠는데 지금은 좀 부담을 놓으려고 한다. 할만하니까 시켰겠지 이런 생각을 하면서 걱정을 하지 않기로 했다. 팀장이 된 이후로 팀원들이 어려워 하는 것들이나 평소에 내가 중요하다고 생각하는 걸 좀 봐주면서 팀원들이 하는걸 봤는데 다들 이해력이 좋은 것 같아서 다행이다. 다음주는 추석이 있어서 쉬는날이 좀 긴데 이때 팀원들과 어떤식으로 진행할지 고민중인데 노트북 들고 만나서 하는 건 좀 무리인가 싶기도 해서 디스코드로 상의나 화면공유등을 활용해서 하지 않을까 생각중이다. 요즘 항상 하는 생각이 시간이 부족하다는 생각이다. 공부를 하면 할수록 복습할 것이 늘어나고 한번에 이해를 못할까봐 미리 조금이나마 보고 가야될 것 같은 생각도 들고 그렇다. 아마 다른 사람들도 비슷하겠지. 그래도 잘 이겨냈으면 좋겠다. 나중에는 지금보다 더 힘들거니까. 5주차는 여기까지.
20일차
String 클래스(136)
/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- String 클래스
============================================*/
/*
○ String 클래스는 내부 문자열 데이터에 대한 수정이 불가능하다
(즉, 내용 불변 : immutable)
문자열의 내용이 변경되면 새로운 객체를 생성하며
참조 대상을 잃어버린 객체는 가비지 컬렉션의 대상이 되고,
새로운 객체에 새 주소를 할당하게 되므로 해시코드도 변하게 될 수 있다.
○ String 클래스 간에 + 연산자를 사용하게 되면 문자열 간의 결합이 가능하며
String 클래스와 다른 클래스 객체, 또는 기본형 데이터 간에 + 연산자를
사용하는 경우에도 내부적으로 자동 String 클래스로 변환이 가능하다.
※ 눈으로(시각적으로) 확인되는 결과는 이렇지만...
String 은 내용을 변경할 수 없기 때문에
+ 연산자를 사용하게 되면
내부적으로 StringBuffer 를 생성하여 append() 메소드를 이용하여
문자열에 대한 결합을 수행하게 된다. 따라서 동적인 문자열을
많이 사용하는 Servlet 등에서는 되도록이면 String을 사용하는 것
보다 StringBuffer 나 char[] 를 사용하는 것이 효율적일 수 있다.
-> 정적인 문자열을 처리하는 경우에는 주로 String 클래스를 사용
동적인 문자열을 처리하는 경우에는
런 타임 시 동적으로 처리해주는 StringBuffer 클래스를
사용하는 것이 효율적이다.
○ String 객체의 생성 및 특징
String 객체를 생성하는 방법은
1. 문자열 상수를 지정하는 방법과
2. String 클래스의 생성자를 이용하는 방법
이렇게 두 가지 방법이 있다.
String Str1 = "Java";
String Str2 = "Java";
String Str3 = "Java";
String Str4 = new String("Java");
String Str5 = new String("Java");
String Str6 = new String("Java");
하지만, 문자열 상수를 대입 연산자를 사용하여 저장하는 방법을 통해
객체를 생성하는 경우와 new 연산자를 이용하여 객체를 생성하는것은
내부적으로 의미가 다르다.
*/
public class Test136
{
public static void main(String[] args)
{
String s1 = "seoul";
String s2 = "seoul";
String s3 = new String("seoul");
String s4 = new String("seoul");
System.out.println("s1 : " + s1);
System.out.println("s2 : " + s2);
System.out.println("s3 : " + s3);
System.out.println("s4 : " + s4);
// s1 : seoul
// s2 : seoul
// s3 : seoul
// s4 : seoul
System.out.println("s1 == s2 : " + (s1 == s2));
System.out.println("s2 == s3 : " + (s2 == s3));
System.out.println("s3 == s4 : " + (s3 == s4));
System.out.println("s4 == s1 : " + (s4 == s1));
// s1 == s2 : true
// s2 == s3 : false
// s3 == s4 : false
// s4 == s1 : false
// s1과 s2객체가 참조하는 문자열 상수가 동일한 경우 문자열이 저장된
// 기억장소의 영역이 동일하기 때문에 s1객체와 s2객체는 동일한 기억장소를
// 참조하게 된다. 하지만, s3와 s4는 동일한 영역이 아닌 다른 기억 공간을
// 새롭게(new) 확보하여 문자열 상수를 그공간에 대입한 경우이므로 두 인스턴스는
// 같은 영역을 참조하는 것이 아니다. 따라서, s3 == 34는 거짓이 되며 만약, 같은
// 문자열 상수인지의 여부를 비교해야 할 경우라면 equals() 메소드를 이용해야 한다.
// String 클래스는 Object 의 equals()를 Overriding
// return : true if the given object represents a String equivalent to this string, false otherwise
System.out.println("s1.equals(s2) : " + s1.equals(s2));
System.out.println("s2.equals(s3) : " + s2.equals(s3));
System.out.println("s3.equals(s4) : " + s3.equals(s4));
System.out.println("s4.equals(s1) : " + s4.equals(s1));
// s1.equals(s2) : true
// s2.equals(s3) : true
// s3.equals(s4) : true
// s4.equals(s1) : true
System.out.println("s1 : " + s1.hashCode());
System.out.println("s2 : " + s2.hashCode());
System.out.println("s3 : " + s3.hashCode());
System.out.println("s4 : " + s4.hashCode());
// s1 : 109324212
// s2 : 109324212
// s3 : 109324212
// s4 : 109324212
// 객체가 같으면 hashcode가 같지만 hashcode가 같다고 해서 같은 객체는 아님
s2 += " Korea";
System.out.println("s2 : " + s2);
// s2 : seoul Korea
s2 = "korea";
System.out.println("s2 : " + s2);
// s2 : korea
// 이와 같은 경우
// s2가 참조한 "seoul"이 저장된 영역은 s2 +=" Korea"; 가 수행되는 시점에서
// 해당 영역의 값이 변경되는 것이 아니라 가비지 컬렉션의 대상이 되며,
// "seoul Korea" 상수가 저장된 영역을 s2가 참조하게 되었다가 다시 s2가 참조한
// "seoul Korea"가 저장된 영역은 s2 = "Korea"; 가 수행되는 시점에서 가바지
// 컬렉션의 대상이 되며, "Korea" 문자열 상수가 새롭게 저장된 영역을
// s2가 참조하게 된다.
// -> ※ String 객체의 내용은 불변이다
}
}String 클래스(137)
/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- String 클래스
============================================*/
public class Test137
{
public static void main(String[] args)
{
String s = "seoul korea";
System.out.println("s : " + s);
// s : seoul Korea
// ○ 문자열 추출
System.out.println(s.substring(6, 9));
// Kor
// ※ String.substring(s, e)
// String 문자열을 대상으로 s 번째에서 e - 1번째 까지 추출(인덱스는 0부터)
System.out.println(s.substring(7));
// orea
// ※ String.substring(s)
// String 문자열을 대상으로 s 번째에서 끝까지 추출(즉, 문자열이 가진 길이만큼)
// ○ 문자열의 데이터(값) 비교
System.out.println(s.equals("seoul korea"));
System.out.println(s.equals("seoul Korea"));
// true
// false
// 대소문자 엄격히 구분
System.out.println(s.equalsIgnoreCase("SEOUL KOREA"));
// true
// 대소문자 구분 안함
// ○ 찾고자하는 대상 문자열(s)에 Kor 문자열이 존재할까?
// 존재한다면 그 위치는 어떻게 될까
// "seoul korea"
// 0123456789
System.out.println(s.indexOf("kor"));
// 6
System.out.println(s.indexOf("ea"));
// 9
System.out.println(s.indexOf("e"));
// 1
// 먼저 찾은 문자열의 인덱스를 반환하고 종료
System.out.println(s.indexOf("tt"));
// -1
// 못찾으면 음수
// ○ 대상 문자열(s)이 rea로 끝나는지 여부 혹인
// true / false
System.out.println(s.endsWith("rea"));
System.out.println(s.endsWith("oul"));
// true
// false
// ○ 찾고자하는 대상 문자열(s)에 e 문자열이 존재할까?
// 존재한다면 그 위치는 어떻게 될까
// (단, 뒤에서 부터 검사)
// seoul korea
System.out.println(s.indexOf("e"));
System.out.println(s.indexOf("o"));
// 1
// 2
System.out.println(s.lastIndexOf("e"));
System.out.println(s.lastIndexOf("o"));
// 9
// 7
// ○ 대상 문자열(s) 중 6번째 인덱스 위치의 문자는?
// seoul korea
System.out.println(s.charAt(6));
// k
// System.out.println(s.charAt(22)); "seoul korea" 인덱스가 10까지 있다
// StringIndexOutOfBoundsException: String index out of range: 22 -> 런타임 에러
// ○ 대상 문자열(s)과 비교 문자열 seoul corea 중
// 어떤 문자열이 더 큰가? -> 문자열에 대한 크기 비교
// -> 두 문자열이 같다면 -> 0
// -> 두 문자열이 다르다면 -> ???
// seoul korea
System.out.println(s.compareTo("seoul korea"));
// 0 -> 두 문자열이 같다
System.out.println(s.compareTo("seoul corea"));
// 8
// c ~ k -> defhijk 8 차이를 반환
// ○ 대상 문자열(s) 중
// 해당 문자열을 찾아서 원하는 형태로 수정된 문자열 반환
s = "우리나라 대한민국 대한독립 만세";
//s.replaceAll("대한", "자주"); // 대한을 자주로 바꾼 String을 반환하지만 원본값을 바꾸진 않는다
s = s.replaceAll("대한", "자주");
System.out.println("처리 결과 : " + s);
// 처리 결과 : 우리나라 자주민국 자주독립 만세
// ○ 공백 제거
s = " 사 랑 ";
//System.out.println(s);
// 사 랑 // 뒤쪽 공백 확인 불가
System.out.println("|" + s + "|");
// | 사 랑 |
System.out.println("|" + s.trim() + "|");
// |사 랑|
// 양쪽 가장자리 공백 제거
System.out.println("|" + s.replaceAll(" ", "") + "|");
// |사랑|
int temp = Integer.parseInt("50");
//System.out.println(temp); 50
System.out.printf("%d\n", temp);
// 50
// 30
s = Integer.toString(30);
System.out.printf("%s\n", s);
// 30 문자열 형태로 담겨서 출력됨
int n = 2345678;
System.out.printf("%d", n);
System.out.format("%d", n);
// 23456782345678 개행없이 출력함
System.out.println();
s = String.format("%d", n); // printf와 사용법은 유사하다. 출력을 시키는게 아니라 어떤 형태의 문자열을 만드는 것
System.out.println(s);
// 2345678
s = String.format("%.2f", 123.456);
System.out.println(s);
// 123.46
s = String.format("확인 : %b", true);
System.out.println(s);
// 확인 : true
s = String.format("결과 : %,d", n);
System.out.println(s);
// 결과 : 2,345,678
//String str = "기본,열정,배려";
//String[] strArr = str.split(",");
// 위와 동일한 구문
String[] strArr = "기본,열정,배려".split(",");
for(String str : strArr)
System.out.print(str + " ");
System.out.println();
// 기본 열정 배려
}
}StringBuffer 클래스(138)
/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- StringBuffer 클래스
============================================*/
/*
○ StringBuffer 클래스
문자열을 처리하는 클래스로 String 클래스와의 차이점은 String 클래스는
내부 문자열 데이터의 수정이 불가능하지만 StringBuffer클래스는 문자열을
사용할 때 내부 문자열을 실행 단계에서 변경할 수 있다.
즉, StringBuffer 객체는 가변적인 길이를 가지므로 객체를 생성하는
시점에서 미리 그 크기나 값을 지정하거나 실행 시점에 버퍼의 크기를
바꿀 수 잇는 기능을 제공한다.
또한, JDK 1.5이후부터는 문자열을 처리하는 StringBuilder 라는 클래스도
제공한다. StringBuilder 클래스의 기능은 StringBuffer 클래스와 동일하지만
가장 큰 차이점은 multi-thread unsafe 라는 점이다. 즉, Syncronization 이
없기 때문에 StringBuffer 보다 빠르며, 동시성(동기화) 문제가 없다면
StringBuilder를 사용하는 것이 성능을 향상시킬 수 있다.
*/
public class Test138
{
public static void main(String[] args)
{
String str1 = new String("seoul");
String str2 = new String("seoul");
System.out.println(str1 == str2);
System.out.println(str1.equals(str2)); // 값을 비교
// false
// true
StringBuffer sb1 = new StringBuffer("korea");
StringBuffer sb2 = new StringBuffer("korea");
System.out.println(sb1 == sb2);
System.out.println(sb1.equals(sb2));
// StringBuffer클래스에서는 equals메소드를 오버라이딩 하지 않았다.
// false
// false
System.out.println("--------------------------------------------");
System.out.println(sb1);
// korea StringBuffer클래스에서 toString() 오버로딩
System.out.println(sb1.toString());
// korea
System.out.println(sb1.toString().equals(sb2.toString()));
// true
System.out.println("--------------------------------------------");
StringBuffer sb3 = new StringBuffer();
// StringBuffer 기본 생성자 호출(인스턴스 생성 과정)
// 기본적으로 생성되는 버퍼의 크기는 16
// capacity()
System.out.println("버퍼 크기 : " + sb3.capacity());
// 버퍼 크기 : 16
System.out.println(sb3);
// 아무것도 출력되지 않음
/*
String name = "aaa";
name += "bbb";
name += "ccc";
name += "ddd";
System.out.println(name);
// aaabbbcccddd 이러한 방식은 메모리를 많이 쓴다
*/
sb3.append("seoul"); // sb3 += "seoul"
sb3.append("korea"); // sb3 += "korea"
sb3.append("우리나라"); // sb3 += "우리나라"
sb3.append("대한민국"); // sb3 += "대한민국"
System.out.println(sb3);
// seoulkorea우리나라대한민국
System.out.println(sb3.toString());
// seoulkorea우리나라대한민국
// 버퍼 크기 다시 확인
System.out.println("버퍼 크기 : " + sb3.capacity());
// 버퍼 크기 : 34
String temp1 = "java and oracle";
System.out.println(temp1.toUpperCase());
// JAVA AND ORACLE
String temp2 = "JAVA AND ORACLE";
System.out.println(temp2.toLowerCase());
// java and oracle
//System.out.println(sb3.toUpperCase());
//System.out.println(sb3.toLowerCase());
// 컴파일 에러 -> cannot find symbol
// StringBuffer 클래스엔 이러한 메소드들이 없다.
System.out.println(sb3.toString().toUpperCase());
// SEOULKOREA우리나라대한민국
// StringBuffer인 sb3를 .toString() 으로 String형으로 바꿔주고 String메소드인 .toUpeerCase() 사용해주었다.
// ※ 주의 : 대문자형태로 출력되었다 하더라도 기존의 sb3값은 변하지 않는다.
// ○ 대상 문자열(sb3 -> "seoulkorea우리나라대한민국") 중 "seoul" 문자열 앞에 "한국" 이라는 문자열 추가
// 즉, "한국seoulkorea우리나라대한민국" 으로 구성
sb3.insert(0, "한국"); // 인덱스, 삽입할 문자열
System.out.println("seoul 앞에 \"한국\" 추가 : " + sb3);
// seoul 앞에 "한국" 추가 : 한국seoulkorea우리나라대한민국
System.out.println("seoul 앞에 \"한국\" 추가 : " + sb3.toString());
// seoul 앞에 "한국" 추가 : 한국seoulkorea우리나라대한민국
// ○ 대상 문자열(sb3 -> "한국seoulkorea우리나라대한민국") 중 "korea" 문자열 뒤에
// "사랑"이라는 문자열 추가 단, 대상 문자열의 인덱스를 눈으로 확인하지 않고 할 것
// 즉 "한국seoulkorea사랑우리나라대한민국" 으로 구성
/*
int index = sb3.toString().indexOf("korea") + 5;
// StirngBuffer에도 indexOf 있어서 toString 필요 없다.
sb3.insert(index, "사랑");
System.out.println(sb3);
// 한국seoulkorea사랑우리나라대한민국
*/
System.out.println(sb3.indexOf("korea"));
// 7
// System.out.println(sb3.insert(sb3.indexOf("korea"), "사랑"));
// 한국seoul사랑korea우리나라대한민국
System.out.println(sb3.insert(sb3.indexOf("korea") + "korea".length(), "사랑"));
// 한국seoulkorea사랑우리나라대한민국
System.out.println(sb3.toString());
// 한국seoulkorea사랑우리나라대한민국
// ○ 대상 문자열(sb3) 에서
// 우리나라 문자열 삭제
// sb3.delete(14, 18);
// System.out.println(sb3);
// 한국seoulkorea사랑대한민국
sb3.delete(sb3.indexOf("우리나라"), sb3.indexOf("우리나라") + "우리나라".length());
System.out.println(sb3);
// ○ 대상 문자열(sb3) 에서
// "korea" 이후 모든 문자열 삭제(korea 포함)
// 한국seoulkorea사랑대한민국 -> 한국seoul
sb3.delete(sb3.indexOf("korea"), sb3.length());
System.out.println(sb3);
// 한국seoul
System.out.println("버퍼 크기 : " + sb3.capacity());
// 버퍼 크기 : 34
// 안의 내용물이 커지면 버퍼 크기도 커지지만 내용물이 줄어든다고 해서 버퍼크기가 자동으로 감소하지 않는다
// 문자열(sb3)의 길이 확인
System.out.println("문자열의 길이 : " + sb3.length());
// 문자열의 길이 : 7
// 버퍼 크기 조절
// -> 현재 문자열을 담아둘 수 있는 버퍼의 크기로
// trimToSize()
sb3.trimToSize();
// 버퍼 크기 조절 이후 버퍼 크기 다시 확인
System.out.println("버퍼 크기 : " + sb3.capacity());
// 버퍼 크기 : 7
}
}StringBuffer 클래스(139)
/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- StringBuffer 클래스
============================================*/
public class Test139
{
public static void main(String[] args)
{
String s1 = "123456789";
s1 = (s1 + "123").replace('2', 'A'); // 1A34567891A3
// "123456789"
// "123456789123"
// "1A34567891A3"
System.out.println("s1 : " + s1); // s1 : 1A34567891A3
StringBuffer s2 = new StringBuffer("123456789");
s2.delete(0, 3).replace(1, 3, "24").delete(4, 6);
// 123456789
// 456789
// 424789
// 4247
System.out.println("s2 : " + s2);
// 4247
StringBuffer s3 = new StringBuffer("123456789");
String s4 = s3.substring(3, 6); // 456
StringBuffer s5 = new StringBuffer("123456789");
s5.delete(0, 3).delete(1, 3).delete(2, 5).insert(1, "24");
// 123456789
// 456789
// 4789
// 47
// 4247
System.out.println("s5 : " + s5);
// s5 : 4247
}
}StringTokenizer 클래스(140)
/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- StringTokenizer 클래스
============================================*/
/*
○ StringTokenizer 클래스는
문자열 파싱(parsing)을 위한 정보를 제공하는 클래스로
파싱(parsing)하고자 하는 문자열을 인자로 받아 생성하는데, 여기에서 사용되는
파싱(parsing)이라는 개념은 하나의 문자열을 여러 문자열로 나누는 작업을
의미하게 되며, 이 때 나누는 단위가 되는 문자열을 토근(token)이라고 한다.
StringTokenizer 클래스를 사용하기 위해서는 java.util.StringToknizer 를
import 해야 한다.
StringTokenzier 클래스는 호환성을 유지하는 목적으로 보관 유지되고 있으며,
문자열을 파싱(parsing)하기 위해서는 String 클래스의 split() 메소드나,
javax.util.regex 패키지를 사용할 것은 권장하고 있다.
○ 생성자
- 원형
StringTokenizer(String str)
StringTokenizer(String str, String delim)
StringTokenizer(String str, String delim, boolean returnDelims)
: 주어진 문자열 str을 단어로 분리하는 객체를 생성하며 공백(구분) 문자는
delim에 포함된 문자로 처리하게 된다 만약 returnDelims 가 true이면 구분
문자도 분리된 데이터로 처리하게 된다.
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Test140
{
public static void main(String[] args) throws IOException
{
String strTemp;
String[] strArr;
int n;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("파싱할 문자열 입력(컴마 구분) : ");
strTemp = br.readLine();
// "사과,딸기,바나나,포도"
// StringTokenizer 클래스 인스턴스 생성
StringTokenizer st = new StringTokenizer(strTemp, ",");
//-- strTemp 를 대상 문자열로
// ","를 구분자로
// 테스트
// System.out.println(st.countTokens());
// 파싱할 문자열 입력(컴마 구분) : 사과,딸기,바나나,포도
// 4
// StringTokenizer 의 int countTokens() 메소드
// : 파싱된 문자열의 갯수를 반환(리턴)한다.
strArr = new String[st.countTokens()]; // new String[4]
n = 0;
while(st.hasMoreTokens()) // true true true true false
{
strArr[n++] = st.nextToken();
//strArr[0] = "사과";
//strArr[1] = "딸기";
//strArr[2] = "바나나";
//strArr[3] = "포도";
}
// hasMoreToken()
// 사용할 수 없는 토큰이 남아있는 경우 true를 반환. 더 이상 사용할
// 토큰이 없는 경우 false를 반환. 확인에 대한 결과만 반환할 뿐 실제
// 내용을 읽어들이지도 않고, 실제 내용을 읽어들이는 헤드를 이동시키지도
// 않는다.
// nextToken()
// 다음 토큰을 얻어온다. 다음 토큰을 얻어오며 헤드를 이동시키게 된다.
// 구분자를 바꾸었을 경우 다음 호출에도 바뀐 구분자를 이용하여 토큰을 분리한다.
System.out.print("파싱된 토큰(문자열) : ");
for(String str : strArr)
System.out.print(str + " ");
System.out.println();
// 파싱할 문자열 입력(컴마 구분) : 사과,딸기,바나나,포도
// 파싱된 토큰(문자열) : 사과 딸기 바나나 포도
}
}21일차
캐릭터 셋 (141)
/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- 문자열 관련 클래스
- 캐릭터 셋(CharacterSet)
============================================*/
/*
■ 캐릭터 셋(Character Set)
○ 유니코드(unicode)
국제 표준으로 제정된 2바이트계의 만국 공통의 국제 문자부호 체계
(UCS: Universal Code System)를 말한다. 애플컴퓨터, IBM, 마이크로소프트 등이
컨소시엄으로 설립한 유니코드(Unicode)가 1990년에 첫 버전을 발표하였고 ISO/IEC JTC1
에서 1995년 9월 국제표준으로 제정하였다. 공식 명칭은 ISO/IEC 10646-1(Unicersal
Multiple-Octet Coded Character Set)이다.
데이터의 교환을 원할하게 하기 위해서 문자 1개에 부여되는 값을 16비트로 통일하였다.
코드의 1문자 당 영어는 7비트, 비영어는 8비트, 한글이나 일본어는 16비트의 값을 가지게 되는데
이들을 모드 16비트로 통일한 것이다.
○ UTF-8과 UTF-16
UTF-8과 UTF-16 의 차이를 한 마디로 말하면 문자를 표현할 때의 단위가 다르다는 것이다.
UTF-8은 8비트 가변장 멀티바이트에서 문자를 표현하고, UTF-16 가변장 멀티바이트에서
문자를 표현한다.
-UTF-8(8bit UCS Transformation Format)
웹에서 기본적으로 사용하는 코드. UCW-2로 정의되는 문자 집합을 이용하여 기술된 문자열을
바이트 열로 변환하는 방식의 1개 1문자를 1~6바이트 가변장 멀티바이트로 변환한다.
-UTF-16(16bit UCS Transformation Format)
자바의 기본 코드. 자바에서는 문자 하나를 저장하면 바이트 수는 영문자든, 한글문자든,
2바이트를 차지하게 된다. UCS-2로 정의되는 문자 집합을 이용해서 기술된 문자열에 UCS-4의
일부의 문자를 채워넣기 위한 인코딩 방식. UTF-8과 병용할 수 있다. UCS-2로 이용할 수 있는
문자 수를 대폭 늘릴 수 있다.
※ 자바단에서는 UTF-16을 사용하고 웹에서는 UTF-8을 사용하기 때문에 경우에 따라 변환해야 하는
상황이 발생할 수 있다.
■ 문자 코드의 종류
○ KSC5601
한글 완성형 표준(한글 2,350자 표현). 한국공업표준 정보처리분야(c)의 5601번 표준안.
○ KSC5636
영문자에 대한 표준. 한국공업표준 정보처리분야(c)의 5636번 표준안. 기존 ASCII Code에서
역슬래시(\)를 원(￦) 표시로 대체.
○ EUC-KR(MS949)
Bell-Laboratories 에서 유닉스 상에서 영문자 이외의 문자를 지원하기 위해 제안한 확장
유니코드(Extend UNIX Code) 중 한글 인코딩 방식.영문은 KSC5636으로 처리하고, 한글은 KSC5601로
처리 즉, EUC-KR(MS949) = KSC5636 + KSC5601
○ UTF-8
영문과 숫자는 1바이트, 한글은 3바이트로 표현. (웹에서 많이 사용. UTF-8 형식으로 JSP를 작성할
때에는 파일도 UTF-8 형식으로 저장해야 한다.)
○ UTF-16
자바 기본 문자 코드. 영문과 숫자는 1바이트, 한글은 2바이트로 표현.
○ ISO-8859-1
서유럽 언어 표기에 필요한 US-ASCII 에 없는 94개 글자의 순차적 나열.
*/
import java.io.UnsupportedEncodingException;
public class Test141
{
public static void main(String[] args) throws UnsupportedEncodingException
{
byte[] buf;
String name = new String("홍길동");
System.out.println("디폴트 캐릭터셋 : " + System.getProperty("file.encoding")); // 시스템속성값확인
// 디폴트 캐릭터셋 : MS949
// String.getBytes();
// 대상 문자열을 디폴트 캐릭터셋으로(시스템에 설정된 인코딩 방식을 활용해서) 바이트 배열을 반환하는 메소드
buf = name.getBytes();
System.out.println("Length : " + buf.length);
// Length : 6
for(byte b : buf)
System.out.println("[" + b + "]");
System.out.println();
/*
[-56]
[-85]
[-79]
[-26]
[-75]
[-65]
*/
// "UTF-8" 캐릭터셋으로 바이트 배열을 반환
// String.getBytes("utf-8");
// 대상 문자열을 매개변수로 넘겨받은 인코딩 방식을 활용해서 바이트 배열을 반환하는 메소드
buf = name.getBytes("utf-8"); // UnsupportedEncodingException 예외처리 해줘야 함
System.out.println("Length : " + buf.length);
// Length : 9
for(byte b : buf)
System.out.println("[" + b + "]");
System.out.println();
/*
[-19]
[-103]
[-115]
[-22]
[-72]
[-72]
[-21]
[-113]
[-103]
*/
// new String("홍길동")
// new String(바이트배열, 인코딩방식);
// new String(buf, "utf-8");
// utf-8 형태로 저장된 바이트 배열을 String 객체로 파라미터 값 utf-8을 부여하여 생성
System.out.println("Value 1 : " + new String(buf, "utf-8"));
// Value 1 : 홍길동
System.out.println();
// new String(바이트배열[, 기본인코딩방식]); -> [, 기본인코딩방식]이 생략되어있다고 생각하면 된다.
// new String(buf);
// utf-8 형태로 저장된 바이트 배열을 String 객체로 두 번째 파라미터 값 없이 부여하여 생성
// -> 즉, ms949 방식으로 buf 바이트배열을 합쳐서 문자열 객체를 생성한 후 출력
System.out.println("Value 1 : " + new String(buf));
// Value 1 : ?솉湲몃룞
System.out.println();
String convert = new String(name.getBytes("euc-kr"), "utf-8"); // 두가지 방식을 통일해야 함
// name이 깨진채로 convert형에 저장됨
buf = convert.getBytes();
System.out.println("Length : " + buf.length);
// Length : 4
buf = convert.getBytes("utf-8");
System.out.println("Length : " + buf.length);
// Length : 8
/*
※ check
문자열을 euc-kr 인코딩 방식에서 utf-8 방식으로 변환하겠다는 의도로 이와 같이 코딩을 해버리면
이러한 변환(잘못된 변환)으로 인해 배열이 깨져서 이 이후에는 euc-kr이든 utf-8이든 어떠한 바이트
배열로 읽어오든 결과물이 깨져 있는 것을 확인할 수 있다.
이미 깨져서 생성된 String 객체의 바이트 배열은 어떤 방식으로든 복구가 불가능하다.
*/
}
}Calendar 클래스(142)
/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- Calendar 클래스
============================================*/
/*
※ Calendar 클래스는 추상 클래스이기 때문에 객체를 생성할 수 없다.
(추상 클래스 : 미완성된 클래스 -> 상속을 위해 존재하는 클래스)
Calendar ob = new calendar();
-> 이와 같은 구문을 통해 인스턴스 생성 불가.
○ Calendar 클래스 객체(인스턴스)를 생성할 수 있는 방법
1. Calendar ob1 = Calendar.getInstance();
2. Calendar ob2 = new GregorianCalendar();
// GregorianCalendar gc = new GregorianCalendar();
// Calendar ob2 = gc;
// Calendar ob2 = (Calendar)gc;
3. GregorianCalendar ob3 = new GregorianCalendar();
*/
// 연, 월, 일, 요일을 Calendar 객체로부터 가져와 출력
import java.util.Calendar;
import java.util.GregorianCalendar;
public class Test142
{
public static void main(String[] args)
{
// Calendar 객체 생성
// Calendar ob = new Calendar(); 추상클래스이기 때문에 객체 생성 불가
Calendar rightNow = Calendar.getInstance();
// 생성된 달력(Calendar) 인스턴스를 통해
// 날짜 관련 정보를 얻어낼 수 있는 메소드 -> get()
int y = rightNow.get(Calendar.YEAR);
System.out.println("y : " + y);
// y : 2023
int m = rightNow.get(Calendar.MONTH) + 1; // + 1
System.out.println("m : " + m);
// m : 9
int d = rightNow.get(Calendar.DATE);
System.out.println("d : " + d);
// d : 19
int w = rightNow.get(Calendar.DAY_OF_WEEK);
System.out.println("w : " + w);
// w : 3
// 테스트(확인)
/*
System.out.println(Calendar.SUNDAY); // 1 일
System.out.println(Calendar.MONDAY); // 2 월
System.out.println(Calendar.TUESDAY); // 3 화
System.out.println(Calendar.WEDNESDAY); // 4 수
System.out.println(Calendar.THURSDAY); // 5 목
System.out.println(Calendar.FRIDAY); // 6 금
System.out.println(Calendar.SATURDAY); // 7 토
*/
System.out.println(y + "-" + m + "-" + d + " " + w);
// 2023-9-19 3
String week = "";
switch(w)
{
/*
case Calendar.SUNDAY : week = "일요일"; break;
case Calendar.MONDAY : week = "월요일"; break;
case Calendar.TUESDAY : week = "화요일"; break;
case Calendar.WEDNESDAY : week = "수요일"; break;
case Calendar.THURSDAY : week = "목요일"; break;
case Calendar.FRIDAY : week = "금요일"; break;
case Calendar.SATURDAY : week = "토요일"; break;
*/
case 1 : week = "일요일"; break;
case 2 : week = "월요일"; break;
case 3 : week = "화요일"; break;
case 4 : week = "수요일"; break;
case 5 : week = "목요일"; break;
case 6 : week = "금요일"; break;
case 7 : week = "토요일"; break;
}
System.out.println(y + "-" + m + "-" + d + " " + week);
// 2023-9-19 화요일
System.out.println("////////////////////////");
// Calendar 객체 생성
Calendar rightNow2 = new GregorianCalendar();
String[] week2 = {"일요일", "월요일", "화요일", "수요일", "목요일", "금요일", "토요일"};
// 달력의 날짜 세팅 -> set 메소드 활용
rightNow2.set(2024, 2, 19); // 2024년 3월 19일
System.out.println(rightNow2.get(Calendar.DAY_OF_WEEK));
// 3
System.out.println(week2[rightNow2.get(Calendar.DAY_OF_WEEK) - 1]);
// 화요일
}
}Calendar 클래스(143)
/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- Calendar 클래스
============================================*/
/*
○ java.util.Calendar 클래스는
날짜와 시간을 객체 모델링화 한 클래스로 연, 월, 일, 요일, 시, 분, 초 까지의
시간과 날짜와 관련된 정보를 제공한다. 그리고, Calendar 클래스는 추상클래스 이므로
직접 객체를 생성할 수 없으며 실제적인 메소드 구현은 Calendar 클래스의 서브 클래스인
GregorianCalendar 클래스에 정의되어 있다.
시스템으로부터 현재 시스템 시간 정보를 얻어올 때 getInstance()라는 정적(static)
메소드를 이용하여 객체를 생성할 수 있다. 생성된 Calendar 클래스 객체는 시스템의 현재
날짜와 시간 정보를 가지며, 이 객체가 생성되면 갖고있는 시간정보들은 get() 메소드를
활용하여 쉽게 가져올(사용할) 수 있다.
getInstance() 메소드는 내부적으로 GregorianCalendar 객체를 생성하여 반환해 주기 때문에
GregorianCalendar 객체를 직접 생성하여 날짜 시간 정보를 구할 수도 있다.
*/
/*
○ 실습 문제
사용자로부터 연, 월을 입력받아 달력을 그려주는(출력하는) 프로그램을 구현한다.
단, Calendar 클래스를 활용하여 작성할 수 있도록 한다.
※ API Document 참조하여 getActualMaximum() 메소드의 활용 방법 검토할 것
실행 예)
연도 입력 : 0
연도 입력 : 2024
월 입력 : -10
월 입력 : 13
월 입력 : 5
[ 2024년 5월 ]
일 월 화 수 목 금 토
============================
1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31
============================
계속하려면..
*/
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Scanner;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
public class Test143
{
public static void main(String[] args) throws IOException
{
/*
Calendar ob= new GregorianCalendar();
Scanner sc = new Scanner(System.in);
String[] weekNames = {"일", "월", "화", "수", "목", "금", "토"};
int y,m;
int d;
do
{
System.out.print("연도 입력 : ");
y = sc.nextInt();
}
while (y == 0);
do
{
System.out.print("월 입력 : ");
m = sc.nextInt() + 1;
}
while (m < 1 || m > 12);
ob.set(y,m,1); // 2024년 3월 1일
d = ob.getActualMaximum(Calendar.DAY_OF_MONTH);
//System.out.println(d);
int day = ob.get(Calendar.DAY_OF_WEEK);
//System.out.println(day);
System.out.printf(" [ %d년 %d월 ]\n", y, m - 1);
System.out.println("\n 일 월 화 수 목 금 토");
System.out.println("============================");
for(int i = 0; i <= d + day; i++)
{
if(i <= day)
System.out.printf(" ");
else
{
System.out.printf("%4d",i - day);
}
if(i % 7 == 6 || i == d + day)
System.out.println();
}
System.out.println("============================");
*/
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Calendar cal = Calendar.getInstance();
int y,m; // 년 월
int w; // 요일
int i; // 루프 변수
do
{
System.out.print("연도 입력 : ");
y = Integer.parseInt(br.readLine());
}
while (y < 1);
do
{
System.out.print("월 입력 : ");
m = Integer.parseInt(br.readLine());
}
while (m < 1 || m > 12);
// 사용자로부터 입력받은 연(y), 월(m)을 이용하여 달력의 날짜 세팅
cal.set(y,m - 1,1);
// 월 구성 시 입력값(m)을 그대로 사용하는 것이 아니라 입력값에서 1을 뺀 값으로 월을 설정해야 함
// 일 구성시 입력받은 연, 월에 해당하는 1일로 설정해야 한다.
// 1일의 요일을 확인해야 달력을 그릴 수 있다.
// 세팅된 달력의 날짜로부터 요일 가져오기
w = cal.get(Calendar.DAY_OF_WEEK);
// 테스트(확인)
System.out.println("w : " + w);
// 연도 입력 : 2023
// 월 입력 : 12
// w : 6 -> 금요일 -> 2023년 12월 1일은 금요일
// 결과 출력 -> 달력 그리기
System.out.println();
System.out.println("\t[ " + y + "년 " + m + "월 ]\n");
System.out.println(" 일 월 화 수 목 금 토");
System.out.println("============================");
for(i = 1; i < w; i++)
System.out.print(" ");
// 테스트(확인)
// System.out.printf("%4d",1);
// 일 월 화 수 목 금 토
// ============================
// 1
// 테스트(확인)
//System.out.println(cal.getActualMaximum(Calendar.DATE));
// Calender 클래스 getActualMaximum() 메소드
for(i = 1; i <= cal.getActualMaximum(Calendar.DATE); i++)
{
System.out.printf("%4d", i);
w++;
if(w % 7 == 1)
System.out.println();
}
if(w % 7 != 1) // 일요일 개행이 적용되지 않았을 경우에만 개행
System.out.println();
System.out.println("============================");
}
}Calendar 클래스(144)
/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- Calendar 클래스
============================================*/
/*
○ 오늘을 기준으로 입력받는 날짜만큼 후의 연, 월, 일, 요일을
확인하여 결가를 출력하는 프로그램을 구현한다.
실행 예)
오늘 날짜 : 2023-9-19 화요일
몇 일 후의 날짜를 확인하고자 하십니까? : 200
===============[확인 결과]=================
200일 후 : xxxx-xx-xx x요일
Calender 와 관련한 API Document 참조
add()
현재 날짜를 기준으로 날 수 더하는 연산 메소드
-> 객체.add(Calendar.DATE 날수);
*/
import java.util.Calendar;
import java.util.Scanner;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class Test144
{
public static void main(String[] args) throws IOException
{
/*
Calendar rightNow = Calendar.getInstance();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String weekName[] = {"일","월","화","수","목","금","토"};
int y = rightNow.get(Calendar.YEAR);
int m = rightNow.get(Calendar.MONTH)+1;
int d = rightNow.get(Calendar.DATE);
int w = rightNow.get(Calendar.DAY_OF_WEEK) - 1;
System.out.printf("오늘 날짜 : %d-%d-%d %s요일\n", y, m, d, weekName[w]);
System.out.print("몇 일 후의 날짜를 확인하고자 하십니까? : ");
int day = Integer.parseInt(br.readLine());
System.out.println();
rightNow.add(Calendar.DATE,day);
y = rightNow.get(Calendar.YEAR);
m = rightNow.get(Calendar.MONTH)+1;
d = rightNow.get(Calendar.DATE);
w = rightNow.get(Calendar.DAY_OF_WEEK) - 1;
System.out.println("===============[확인 결과]=================");
System.out.printf("%d일 후 : %d-%d-%d %s요일\n", day, y, m, d , weekName[w]);
System.out.println("===========================================");
*/
Scanner sc = new Scanner(System.in);
Calendar now = Calendar.getInstance();
int nalsu; // 사용자로부터 입력받은 날 수
int y,m,d,w; // 연, 월, 일, 요일
String[] week = {"일","월","화","수","목","금","토"};
// 현재 연,월,일,요일 가져오기(get)
y = now.get(Calendar.YEAR);
m = now.get(Calendar.MONTH)+1;
d = now.get(Calendar.DATE);
w = now.get(Calendar.DAY_OF_WEEK);
// 가져온 값들을 출력
System.out.println("오늘 날짜 : " + y + "-" + m + "-" + d + " " + week[w-1] + "요일");
// 오늘 날짜 : 2023-9-19 화요일
do
{
System.out.print("몇 일 후의 날짜를 확인하고자 하십니까? : ");
nalsu = sc.nextInt();
}
while (nalsu < 1);
now.add(Calendar.DATE, nalsu);
// 결과 출력
System.out.println();
System.out.println("===============[확인 결과]=================");
System.out.printf("%d일 후 : %tF %tA\n", nalsu, now, now);
System.out.println("===========================================");
// String.format("%tF", 달력객체); // %t가 들어가면 날짜객체일 가능성이 크다
// -> 년-월-일 형태의 문자열 반환
// String.format("%tA", 달력객체);
// -> 요일 형태의 문자열 반환
}
}22일차
Math 클래스(145)
/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- Math 클래스
============================================*/
/*
○ java.lang.Math 클래스는
수학(Mathmatics)과 관련된 유용한 속성과 메소드를 제공하는 클래스로 생성자가
있긴 하지만 private 으로 선언되어 있기 때문에 외부에서 객체(인스턴스)를 생성
할 수 없다. 단, 모든 메소드가 static 으로 정의되어 있으므로 객체를 생성하지
않고 바로 접근하여 사용하는 것이 가능하다.
○ java.lang.Math 클래스의 주요 상수 및 메소드
- public static final double E = 2.72...;
: 자연 로그 상수
- public static final double PI = 3.141592...;
: 원주율
- public static double sin(double a)
- public static double cos(double a)
- public static double tan(double a)
: sin(a), cos(a), tan(a) 값을 반환한다. (삼각함수)
- public static double asin(double a)
- public static double acos(double a)
- public static double atan(double a)
: asin(a), acos(a), atan(a) 값을 반환한다. (삼각함수의 역함수)
- public static double toRadians(double angdeg)
: 각도(angdeg)를 라디안(radian)으로 바꾸어 반환한다.
- public static double toDegrees(double angrad)
: 라디안(radian)을 각도(degree)로 바꾸어 반환한다.
- public static doiuble exp(double a)
: e 의 a 승을 구하여 반환한다.
- public static double log(double a)
: 로그(log) 값을 구하여 반환한다.
- public static double sqrt(double a)
: a 의 제곱근을 구하여 반환한다.
- public static double ceil(double a)
: a 보다 크거나 같은 정수를 반환한다. (올림의 개념)
- public static double floor(double a)
: a 보다 작거나 같은 정수를 반환한다. (절삭의 개념)
- public static double pow(double a, double b)
: a 의 b 승을 구하여 반환한다.
- public static int round(float a)
- public static long round(double a)
: a 를 반올림하여 결과값을 반환한다.
- public static double random()
: 0.0 ~ 1.0 사이의 난수(임의의 실수)를 발생시켜 반환한다.
*/
public class Test145
{
public static void main(String[] args)
{
System.out.println("원주율 : " + Math.PI);
// 원주율 : 3.141592653589793
System.out.println("2의 제곱근 : " + Math.sqrt(2));
// 2의 제곱근 : 1.4142135623730951
System.out.println("파이에 대한 Degree : " + Math.toDegrees(Math.PI));
System.out.println("2파이에 대한 Degree : " + Math.toDegrees(2.0 * Math.PI));
// 파이에 대한 Degree : 180.0
// 2파이에 대한 Degree : 360.0
// 각도를 라디안으로 변환
double radian45 = Math.toRadians(45);
System.out.println("각도 45 : " + radian45);
System.out.println("싸인 45 : " + Math.sin(radian45));
System.out.println("코싸인 45 : " + Math.cos(radian45));
System.out.println("탄젠트 45 : " + Math.tan(radian45));
// 각도 45 : 0.7853981633974483
// 싸인 45 : 0.7071067811865475
// 코싸인 45 : 0.7071067811865476
// 탄젠트 45 : 0.9999999999999999
System.out.println("로그 25 : " + Math.log(25));
// 로그 25 : 3.2188758248682006
System.out.println("2의 4승 : " + Math.pow(2, 4));
// 2의 4승 : 16.0
System.out.println("0.0 ~ 1.0 사이의 난수 : " + Math.random());
// 0.0 ~ 1.0 사이의 난수 : 0.7688199099459435
// 0.0 ~ 1.0 사이의 난수 : 0.5368860586303785 -> 실행할 때마다 다르게 나온다.
}
}로또 프로그램 구현(146)
/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- Random 클래스
============================================*/
/*
○ java.util.Random 클래스는
여러 형태의 난수를 발생시켜 제공하는 클래스이다. Math 클래스의 정적 메소드인
random() 메소드도 난수를 제공하는 메소드이지만 0.0 ~ 1.0 사이의 실수 형태만
발생하게 되므로 필요한 형태의 난수를 만들어내기 위해서는 추가적인 연산을
여러 형태로 수행해야 한다. 그래서 자바는 여러 형태의 난수를 발생시켜 주는
전용 클래스인 Random 클래스를 별도로 제공하고 있다.
// 로또 번호 생성(난수 발생 프로그램)
프로그램이 실행되면
기본적으로 로또 5게임을 수행하는 프로그램을 구현한다.
실행 예)
3 12 15 24 31 41
1 12 18 36 41 42
4 9 12 13 22 30
5 10 13 14 22 40
22 31 36 40 43 44
계속하려면 아무 키나 누르세요
*/
import java.util.Random;
class Lotto
{
// 배열 변수 선언 및 메모리 할당 -> 로또 번호를 담아둘 배열방 6칸
private int[] num;
// 생성자
Lotto()
{
num = new int[6];
}
// getter
public int[] getNum()
{
sorting();
return num;
}
// 6개의 난수를 발생시키는 메소드 정의
public void start()
{
Random rd = new Random();
for(int i = 0; i < 6; i++)
{
num[i] = rd.nextInt(45) + 1;
for(int j = 0; j < i; j++)
{
if(num[i] == num[j])
i--;
}
}
}
// 정렬 메소드 정의
private void sorting()
{
for(int i = 0; i < num.length - 1; i++) // 비교 기준 데이터 0 1 2 3
{
for(int j = i + 1; j < num.length; j++) // 비교 대상 데이터 1234 234 34 4
{
if(num[i] > num[j]) // 오름차순
// if(a[i] < a[j]) // 내림차순
{
num[i] = num[i] ^ num[j];
num[j] = num[j] ^ num[i];
num[i] = num[i] ^ num[j];
}
}
}
}
}
public class Test146
{
public static void main(String[] args)
{
// Lotto 클래스 기반 인스턴스 생성
Lotto lotto = new Lotto();
for(int i = 1; i <= 5; i++)
{
// 로또 1게임 수행
lotto.start();
int[] arr = lotto.getNum();
// 결과 출력
for(int j = 0; j < 6; j++)
{
System.out.printf("%2d ", arr[j]);
}
System.out.println();
}
}
}/*===========================================
■■■ 자바의 주요 클래스 ■■■
- 자바에서 기본적으로 제공하는 주요 클래스들
- Random 클래스
============================================*/
/*
○ java.util.Random 클래스는
여러 형태의 난수를 발생시켜 제공하는 클래스이다. Math 클래스의 정적 메소드인
random() 메소드도 난수를 제공하는 메소드이지만 0.0 ~ 1.0 사이의 실수 형태만
발생하게 되므로 필요한 형태의 난수를 만들어내기 위해서는 추가적인 연산을
여러 형태로 수행해야 한다. 그래서 자바는 여러 형태의 난수를 발생시켜 주는
전용 클래스인 Random 클래스를 별도로 제공하고 있다.
// 로또 번호 생성(난수 발생 프로그램)
프로그램이 실행되면
기본적으로 로또 5게임을 수행하는 프로그램을 구현한다.
실행 예)
3 12 15 24 31 41
1 12 18 36 41 42
4 9 12 13 22 30
5 10 13 14 22 40
22 31 36 40 43 44
계속하려면 아무 키나 누르세요
*/
import java.util.Random;
import java.util.Arrays;
class Lotto
{
// 배열 변수 선언 및 메모리 할당 -> 로또 번호를 담아둘 배열방 6칸
private int[] num;
// 생성자
Lotto()
{
num = new int[6];
}
// getter
public int[] getNum()
{
sorting();
return num;
}
// 6개의 난수를 발생시키는 메소드 정의
public void start()
{
Random rd = new Random();
int n;
int cnt = 0;
run:
while(cnt < 6) // cnt 0 1 2 3 4 5
{
n = rd.nextInt(45) + 1;
for(int i = 0; i < cnt; i++)
{
// num[i] 요소와 n 을 비교
if(num[i] == n)
{
continue run;
}
}
num[cnt++] = n;
}
sorting();
}
// 정렬 메소드 정의
private void sorting()
{
Arrays.sort(num);
}
}
public class Test146
{
public static void main(String[] args)
{
// Lotto 클래스 기반 인스턴스 생성
Lotto lotto = new Lotto();
for(int i = 1; i <= 5; i++)
{
// 로또 1게임 수행
lotto.start();
// 결과 출력
for(int n : lotto.getNum())
{
System.out.printf("%2d ", n);
}
System.out.println();
}
}
}예외 처리(Exception Handling)(147)
/*===========================================
■■■ 예외 처리(Exception Handling) ■■■
============================================*/
/*
○ 프로그램에서 발생하는 오류(Error)는
1. 잘못된 문법을 사용하거나 변수 등을 정의하지 않은 상태에서 사용함으로써
컴파일 단계에서 발생하는 문법적인 오류(Error)와
2. 프로그램을 실행하는 과정에서 발생되는 런타임 오류(Error)로 나눌 수 있다.
- 개발자가 문제 분석을 잘못하거나 실수에 의해 엉뚱한 결과를 가져오게 되는
논리적인 오류(Error)와
- 시스템 이상에서 발생되는 시스템 오류(Error), 그리고
- 프로그램 실행 중 발생되는 비정상적인 상황을 의미하는 예외사항(Exception)이 있다.
예를 들어,
-> 어떤 수를 0으로 나누거나
-> 배열을 젱하는 과정에서 첨자를 벗어나는 상황이 발생하거나
-> 존재하지 않는 파일을 오픈하여 읽어들인다거나
-> 개발자가 이런 예외 사항이 발생할 경우를 미리 예측해서 적절히 대응하기 위한
절차를 구현하도록 문법을 정리해 놓은 것 -> 예외처리
※ 정리해 놓은 문법 (Exception 클래스)
- 예외는 프로그램 실행 중에 발생할 수 있는 명령어의 정상적인 흐름을 방해하는 이벤트로
자바에서 예외는 하나의 오브젝트(Object, 객체)이다.
- 프로그램 실행 중에 메소드 안에서 오류(Error)가 발생하게 될 경우, 메소드는 그 오류에
해당하는 예외 오브젝트를 만들고 그것을 자바 런타임 시스템(Rutine System)에 전달해 준다.
- 자바에서의 모든 예외 클래스로 Throwable 클래스나 Throwable 클래스의 하위 클래스를
상속받아 사용한다.
- Throwable 클래스는 예외를 설명하는 문장이나 예외가 발생할 때의 프로그램 상태에 관한
정보를 포함하고 있다.
- Throwable 클래스에서 파생된 클래스
- Exception 클래스
Exception 예외 클래스는 일반적으로 프로그래머에 의해 복원될 수 없는 예외 사항으로
메소드가 실행 중에 던지는 예의를 가리킨다.
- Error 클래스
심각한 예외의 형태로 개발자가 복원할 수 없는 형태의 예외이다.
※ 예외의 종류
- checked exception
메소드 내에서 예외가 발생한 경우 메소드를 정의할 대 throws 문에 메소드 내에서 발생할
수 있는 예외들을 명시해 주거나 또는 그 예외를 try-catch 해서 처리해 주어야만 하는
예외이다. 컴파일러가 컴파일 하는 과정에서 checked exception이 throws 되는가의 여부 혹은
try-catch 되는지의 여부를 판단하여 프로그램에서 예외를 어떤 방식으로든 처리하지 않으면
컴파일 자체가 불가능하다.
- unchecked exception
사전에 처리하지 않아도 컴파일러가 체크하지 않는 런타임 시에 발생할 수 있는 예외이다.
○ java.lang.Throwable 클래스의 주요 메소드
- String toString()
: Throwable 각각에 대한 설명을 문자열 형태로 반환한다.
- void printStackTrace(PrintStream s)
- void printStackTrace(PrintWriter w)
: 표준 출력 스트림에 스택 호출 목록을 마지막 메소드부터 출력한다.
○ 주요 런타임 예외 클래스
- ArithmeticException
: 수치 계산상의 오류(0으로 나누기 등)
- ArrayStoreException
: 배열에 잘못된 데이터 형을 저장하려 했을 경우 발생하는 오류
- IndexOutOfBoundsException
: 배열, 문자열, 벡터 등에서 인덱스(첨자) 범위가 벗어난 경우 발생하는 오류
- ClassCastException
: 클래스 변환을 잘못한 경우 발생하는 오류
- NullPointerException
: 빈 객체를 참조하는 경우(초기화 되지 않은 변수 사용 등) 발생하는 오류
- SecurityException
: 자바의 내부 보안 사항을 위반하였을 경우 발생하는 오류
:
*/
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
public class Test147
{ // 1 유형의 예외처리
public static void main(String[] args) // throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int a, b, c;
// 2.
/*
try
{
System.out.print("첫 번째 정수 입력 : ");
a = Integer.parseInt(br.readLine());
System.out.print("두 번째 정수 입력 : ");
b = Integer.parseInt(br.readLine());
c = a + b;
System.out.println("결과 : " + c);
}
catch (IOException e)
{
// IOException -> checked exceptoin
// -- 메소드를 정의하는 과정에서 throws 한 예외
// 잡아내거나 던지지 않을 경우 컴파일 에러 발생.
System.out.println(e.toString());
}
*/
/*
// 3.
try
{
System.out.print("첫 번째 정수 입력 : ");
a = Integer.parseInt(br.readLine());
System.out.print("두 번째 정수 입력 : ");
b = Integer.parseInt(br.readLine());
c = a + b;
System.out.println("결과 : " + c);
}
catch (IOException e)
{
// IOException -> checked exceptoin
// -- 메소드를 정의하는 과정에서 throws 한 예외
// 잡아내거나 던지지 않을 경우 컴파일 에러 발생.
System.out.println(e.toString());
}
catch (NumberFormatException e)
{
// NumverFormatException -> unchecked exception
// 런타임 시 발생할 수 있는 예외로
// 반드시 던질 필요도, 잡아낼 필요도 없다.
// -> 별도 처리가 없더라도 컴파일 과정에서 문제삼지 않음
System.out.println(e.toString());
System.out.println(">> 숫자 형태의 데이터를 입력해야 합니다");
// 첫 번째 정수 입력 : abc
// java.lang.NumberFormatException: For input string: "abc"
// >> 숫자 형태의 데이터를 입력해야 합니다
}
*/
// 4.
/*
try
{
System.out.print("첫 번째 정수 입력 : ");
a = Integer.parseInt(br.readLine());
System.out.print("두 번째 정수 입력 : ");
b = Integer.parseInt(br.readLine());
c = a + b;
System.out.println("결과 : " + c);
}
catch (Exception e)
{
System.out.println("e.toString : " + e.toString());
System.out.println("e.getMessage : " + e.getMessage());
System.out.println("printStackTrace.................");
e.printStackTrace();
}
*/
//etc...
try
{
System.out.print("첫 번째 정수 입력 : ");
a = Integer.parseInt(br.readLine());
System.out.print("두 번째 정수 입력 : ");
b = Integer.parseInt(br.readLine());
c = a + b;
System.out.println("결과 : " + c);
}
catch (Exception e)
{
System.out.println("e.toString : " + e.toString());
System.out.println("e.getMessage : " + e.getMessage());
System.out.println("printStackTrace.................");
e.printStackTrace();
}
finally
{
// 예외가 발생하거나 발생하지 않거나 언제나 실행되는 영역
System.out.println("고생 많으셨습니다 감사합니다.");
}
}
}예외 처리(148)
/*===========================================
■■■ 예외 처리(Exception Handling) ■■■
============================================*/
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class Test148
{
private String[] data = new String[3];
public void proc() throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
int n = 0;
System.out.print("이름 입력(종료:Ctrl + z) : ");
while ((str = br.readLine()) != null)
{
data[n++] = str;
System.out.print("이름 입력(종료:Ctrl + z) : ");
}
System.out.println("입력된 내용............");
for(String s : data)
{
if(s != null) // null이 아닌 경우에만 출력
{
System.out.println(s);
}
}
}
public static void main(String[] args) throws IOException
{
Test148 ob = new Test148();
ob.proc();
}
}예외 처리(149)
/*===========================================
■■■ 예외 처리(Exception Handling) ■■■
============================================*/
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class Test149
{
private String[] data = new String[3];
public void proc() //throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
int n = 0;
try
{
System.out.print("이름 입력(종료:Ctrl + z) : ");
while ((str = br.readLine()) != null)
{
data[n++] = str;
System.out.print("이름 입력(종료:Ctrl + z) : ");
}
System.out.println("입력된 내용............");
for(String s : data)
{
if(s != null) // null이 아닌 경우에만 출력
{
System.out.println(s);
}
}
}
catch (IOException e)
{
System.out.println(e.toString());
System.out.println("-> hecked exception 에 대한 처리");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("배열 인덱스 관련 예외 발생");
System.out.println("e.getMessage() : " + e.getMessage());
System.out.println("e.toString() : " + e.toString());
System.out.println("printStackTrace.................");
e.printStackTrace();
}
/*
배열 인덱스 관련 예외 발생
e.getMessage() : 3
e.toString() : java.lang.ArrayIndexOutOfBoundsException: 3
printStackTrace.................
java.lang.ArrayIndexOutOfBoundsException: 3
at Test149.proc(Test149.java:24)
at Test149.main(Test149.java:55
*/
}
public static void main(String[] args) // throws IOException 없어도 됨
{
Test149 ob = new Test149();
ob.proc();
}
}예외 처리 (150)
/*===========================================
■■■ 예외 처리(Exception Handling) ■■■
============================================*/
// Test151.java 파일과 비교
class Demo
{
private int value;
public void setValue(int value)
{
if(value <= 0)
{
return; // 메소드 종료 setValue()
}
this.value = value;
}
public int getValue()
{
return value;
}
}
public class Test150
{
public static void main(String[] args)
{
Demo ob = new Demo();
ob.setValue(-3);
int result = ob.getValue();
System.out.println(result);
}
}예외처리 (151 ~ 152)
/*===========================================
■■■ 예외 처리(Exception Handling) ■■■
============================================*/
// Test150.java 파일과 비교
// ※ throw
class Demo
{
private int value;
public void setValue(int value) //throws Exception
{
if(value <= 0)
{
// return;
throw new Exception("value 는 0 보다 작거나 같을 수 없습니다.");
// new라는 연산자를 통해서 새롭게 Exception 객체 생성(예외 발생)
}
this.value = value;
}
public int getValue()
{
return value;
}
}
public class Test151
{
public static void main(String[] args) //throws Exception
{
Demo ob = new Demo();
try
{
ob.setValue(-3);
int result = ob.getValue();
System.out.println(result);
}
catch (Exception e)
{
System.out.println(e.toString());
}
/*
java.lang.Exception: value 는 0 보다 작거나 같을 수 없습니다.
계속하려면 아무 키나 누르십시오 . . .
*/
}
}/*===========================================
■■■ 예외 처리(Exception Handling) ■■■
============================================*/
// 예외 다시 던지기
// try 문 안의 수행할 문장 중에서 예외가 발생하지 않는다면 catch 문에 속한 문장들은 수행되지 않는다.
// 하지만 try 문 안의 문장을 수행하는 도중에 예외가 발생하면 예외에 해당되는 catch 문이 수행된다.
public class Test152
{
public static void main(String[] args)
{
Test152 ob = new Test152();
try
{
int a = ob.getValue(-2); // 8. 예외 발생
System.out.println("a : " + a);
}
catch (Exception e) // 9. 예외 잡아내기
{
// 10. 잡아낸 예외에 대한 처리
System.out.println("printStackTrace.......");
e.printStackTrace();
}
}
public int getData(int data) throws Exception // 2. 발생한 예외 던지기
{
if(data < 0)
{
// 1. 최초로 예외 발생
throw new Exception("data 가 0 보다 작습니다. ");
}
return data + 10;
}
// 7. 다시 발생한 예외를 던질 수 있도록 처리
public int getValue(int value) throws Exception
{
int a = 0;
try
{
// 3. 예외 발생
a = getData(-2);
}
catch (Exception e) // 4. 예외 잡아내기
{
// 5. 잡아낸 예외에 대한 처리
System.out.println("printStackTrace.........");
e.printStackTrace();
// 6. 잡아서 처리한 예외를 다시 발생
throw e;
}
return a;
/*
printStackTrace.........
java.lang.Exception: data 가 0 보다 작습니다.
at Test152.getData(Test152.java:31)
at Test152.getValue(Test152.java:44)
at Test152.main(Test152.java:15)
printStackTrace.......
java.lang.Exception: data 가 0 보다 작습니다.
at Test152.getData(Test152.java:31)
at Test152.getValue(Test152.java:44)
at Test152.main(Test152.java:15)
*/
}
}예외처리 (153)
/*===========================================
■■■ 예외 처리(Exception Handling) ■■■
============================================*/
// 다른 예외 다시 던지기
public class Test153
{
public int getValue(int value) throws Exception // 7. 예외 던지기
{ // (파랑 폭탄)
int a = 0;
try
{
a = getData(-2); // 3. 예외 발생
} // (빨강 폭탄)
catch (Exception e) // 4. 예외 잡아내기
{ // (빨강 폭탄)
// 5. 예외 처리(빨강 폭탄)
System.out.println("printStackTrace ..........");
e.printStackTrace();
// check
// 6. 예외 발생(파랑 폭탄)
throw new Exception("value 가 음수입니다.");
}
return a;
}
public int getData(int data) throws Exception // 2. 예외 던지기
{ // (빨강 폭탄)
if(data < 0)
{
throw new Exception("data 가 0 보다 작습니다."); // 1. 예외 발생
} // (빨강 폭탄)
return data + 10;
}
public static void main(String[] args)
{
Test153 ob = new Test153();
try
{
int a = ob.getValue(-2); // 8. 예외 발생(파랑 폭탄)
System.out.println("a : " + a);
}
catch (Exception e) // 9. 예외 잡아내기(파랑 폭탄)
{
System.out.println("printStackTrace ..........");
e.printStackTrace();
}
}
/*
printStackTrace ..........
java.lang.Exception: data 가 0 보다 작습니다.
at Test153.getData(Test153.java:34)
at Test153.getValue(Test153.java:15)
at Test153.main(Test153.java:46)
printStackTrace ..........
java.lang.Exception: value 가 음수입니다.
at Test153.getValue(Test153.java:25)
at Test153.main(Test153.java:46)
*/
}컬렉션 프레임워크(154)
/*=====================================================
■■■ 컬렉션 프레임워크(Collection Framework) ■■■
======================================================*/
/*
○ 컬렉션 프레임워크(Collection Framework)
= 컬렉션(Collection) + 프레임워크(Framework)
------------------ ------------------
| 환경, 틀, 약속
|
집합 -> 수집품, 소장품, (물건, 사람들의) 무리
모아놓은 것들 / 모여있는 것들
-> 자료 구조
○ 자료
현실 세계로 부터 단순한 관찰이나 측정을 통해 수집된 사실이나 개념의 값들 또는 그 값들의 집합
○ 자료구조
자료 처리를 위한 자료의 표현, 저장, 관계, 관리 및 이용헤 관한 방법 등의 개념을 이해하여 프로그램에
사용하고 컴퓨터에 의해 처리되는 과정에서 적절한 자료의 표현, 구성 저장 및 처리를 위한 알고리즘 작성
및 선택과 이용방븝을 연구하는 분야.
○ 컬렉션 프레임워크(Collectino Framework)
컬렉션(모아놓은 데이터들)의 표현과 조작을 위한 통일된 아키텍처로 컬렉션 프레임워크를 구성하는 요소는
다음과 같다.
1. 인터페이스(Interface)
기본적으로 컬렉션에 필요한 데이터 관리 기능을 제공한다.
예를 들어, list 는 추가, 삭제, 검색 등의 기능을 제공하는 컬렉션 인터페이스가 존재하며
각 컬렉션마다 고유의 인터페이스가 정의되어 있다.
2. 구현(Implementation)
인터페이스를 구현한 클래스로 각 컬렉션을 실제 어떤 자료구조를 이용하여 표현했느냐에 따라
컬렉션의 종류가 달라지게 된다.
3. 알고리즘(Algorithms)
각 컬렉션들마다 유용하게 사용될 수 있는 메소드를 의미한다.
※ 자바의 컬렉션은 견고한 컬렉션 프레임워크 위에 정의되어 있으므로 각 컬렉션 종류마다 제공되는 메소드의
일관성이 있기 때문에 한 가지 컬렉션을 익혀두면 다른 컬렉션을 사용하는데 용이하다.
list 인터페이스 - 순서가 의미있는 목록
set 인터페이스 - set은 중복이 불가하고 기본적으로 변경 허용안한다. ex) 주머니
map 인터페이스 - 맵은 Key - Value를 쌍으로 저장하는데 쓰인다
○ 스택(Stack)
Stack 클래스는 오브젝트 후입선출(LIFO) 구조의 Stack 을 나타낸다. 이는 벡터(Vector)를
스택으로 처리하는 5개의 메소드로 벡터(Vector) 클래스를 확장하게 된다.
통상의 push() 메소드와 pop() 메소드가 제공되는 것 외에 스택의 선두 항목으로 peek() 을
실시하는 메소드, 스택이 비어있는지의 여부를 확인하는 메소드 isEmpty(), 스택으로 항목을
찾아서 선두로부터 몇 번째인지를 찾아내는 메소드 등이 제공된다.
스택이 처음으로 작성되었을 때, 항목은 존재하지 않는다.
- boolean empty()
스택이 비어있는지 확인한다.
- E Object peek()
스택의 맨 위의 객체를 스택에서 제거하지 않고 반환한다.
- E Object pop()
스택의 맨 위의 객체를 반환하고 스택에서 제거한다.
- E Object push(E item)
객체를 스택 자료구조에 저장한다.
- int search(Object o)
스택의 맨 위에서부터 파라미터 값으로 넘겨받은 객체까지의 거리를 반환한다.
맨 위의 객체의 경우 1을 반환하고 그 아래 객체는 2를 반환하는 형식.
*/
// 제네릭, 제네릭 표현식
import java.util.Stack;
public class Test154
{
public static void main(String[] args)
{
// Stack 자료구조 생성
Stack<Object> myStack = new Stack<Object>();
String str1 = "가가가";
String str2 = "나나나";
String str3 = "다다다";
String str4 = "라라라";
// myStack 이라는 Stack 자료구조 안에 str1 ~ str4 까지 담아내기
// add(), push()
myStack.add(str1); // String 형인 str1이 Object형인 myStack에 들어가면서 업캐스팅 됨
myStack.add(str2);
myStack.push(str3);
myStack.push(str4);
// peek() : 스택 맨 위의 객체 반환. 제거하지 않는다.
String val1 = (String)myStack.peek(); // <Object>형 반환이므로 String val1에 넣기 위해서 다운캐스팅 해주어야 함
System.out.println("val1 : " + val1);
// val1 : 라라라
String val2 = (String)myStack.peek();
System.out.println("val2 : " + val2);
// val2 : 라라라
String val3 = (String)myStack.peek();
System.out.println("val3 : " + val3);
// val3 : 라라라
String value = "";
// myStack 이라는 이름을 가진 Stack 자료구조에 데이터가 비어있는 상태가 아니라면
// 즉, 채워져 있는 상태라면 -> isEmpty()
while(!myStack.isEmpty()) // !false -> true .... -> !true(전부 반환된 후 빈 상태) == false -> while반복문 종료
{
value = (String)myStack.pop(); // E Object pop() 스택의 맨 위의 객체를 반환하고 스택에서 제거한다.
System.out.println("value : " + value);
}
// value : 라라라
// value : 다다다
// value : 나나나
// value : 가가가
}
}23일차
Stack(155)
/*=====================================================
■■■ 컬렉션 프레임워크(Collection Framework) ■■■
======================================================*/
import java.util.Stack;
public class Test155
{
// 정적 문자열 배열 선언 및 초기화
private static final String[] colors = {"검정", "노랑", "초록", "파랑", "빨강", "연두"};
// 생성자
public Test155()
{
// st 라는 Stack 자료구조 생성
// 제네릭을 활용하여 자료구조에 담기는 데이터에 대한 표현 -> <String>
Stack<String> st = new Stack<String>();
// st 라는 Stack 자료구조에 데이터(colors) 담기
// st = colors; X
/*
st.push(colors[0]); // st.add(colors[0]); 과 동일
st.push(colors[1]);
st.push(colors[2]);
st.push(colors[3]);
st.push(colors[4]);
st.push(colors[5]);
*/
/*
for(int i = 0; i < colors.length; i++)
{
st.push(colors[i]); // st.add(colors[i]); 과 동일
}
*/
for(String color : colors)
{
st.push(color); // st.add(color); 과 동일
}
// st.push(10.0); // String형으로 제네릭을 사용했기 때문에 String형이 아닌 자료형은 넣을 수 없다.
// st.push(10); // int cannot be converted to String / 스택의 영향이 아닌 제네릭의 영향
st.push("보라");
// 출력 메소드 호출
popStack(st);
}
// 출력 메소드
private void popStack(Stack<String> st)
{
System.out.print("pop : ");
// System.out.println(st); 요소마다 꺼내와야 함
while (!st.empty()) // isEmpty()
{
System.out.print(st.pop() + " ");
}
System.out.println();
}
public static void main(String[] args)
{
new Test155(); // 생성자만 호출
// pop : 연두 빨강 파랑 초록 노랑 검정
// pop : 보라 연두 빨강 파랑 초록 노랑 검정
}
}큐(queue)(156)
/*=====================================================
■■■ 컬렉션 프레임워크(Collection Framework) ■■■
======================================================*/
/*
○ 큐(queue)
큐(queue)는 선입선출의 FIFO(First Input, First Output) 구조로 먼저 입력된 자료를 먼저 출력하여
Queue 인터페이스를 구현한 클래스는 큐와 관련된 다양한 기능을 제공한다.
※ Queue 인터페이스 인스턴스를 생성하기 위해서는 new 연산자를 이용하여 Queue 인터페이스를 구현한
(Inplements) 클래스의 생성자를 호출한다.
ex) Queue ob = new LinkedList();
○ 주요 메소드
- E element()
큐의 head 요소를 반환하여 제거하지 않는다.
- boolean offer(E o)
지정된 요소를 큐에 삽입한다.
- E peek()
큐의 head 요소를 반환하고 삭제하지 않으며 큐 자료구조가 empty 인 경우 null 을 반환한다.
- E poll()
큐의 head 요소를 반환하고 삭제하며 큐 자료구조가 empty 인 경우 null 을 반환한다.
- E remove()
큐의 head 요소를 반환하고 삭제한다.
*/
import java.util.Queue;
import java.util.LinkedList;
public class Test156
{
public static void main(String[] args)
{
// Queue 자료구조 생성
// Queue myQue = new Queue(); // 인터페이스이므로 이런식으로 객체 생성 불가
Queue<Object> myQue = new LinkedList<>();
// 데이터 준비
String str1 = "가가가";
String str2 = "나나나";
String str3 = "다다다";
String str4 = "라라라";
// myQue 라는 Queue 자료구조에 데이터 추가
myQue.offer(str1);
myQue.offer(str2);
myQue.offer(str3);
myQue.offer(str4);
// boolean test = myQue.offer(str4);
//System.out.println("test : " + test);
// test : true -> 적재가 잘 이루어졌다는 뜻
// 테스트(확인) 더미 데이터
// System.out.println(myQue);
// [가가가, 나나나, 다다다, 라라라] 나오긴 나오지만 실제 데이터가 아니다.
// == 요소요소에 직접 접근해서 컨트롤해야 함!!!
// 제네릭이 Object이기 때문에 Object형으로 나오는데 우리는 String형을 저장했으므로 String 형변환 해준다.
System.out.println("값1 : " + (String)myQue.element()); // 큐는 FIFO형태로 나오므로 가 부터 나오는데 element는 제거하지 않으므로
System.out.println("값2 : " + (String)myQue.element()); // "가가가" 만 나온다
System.out.println("값3 : " + (String)myQue.element());
// 값1 : 가가가
// 값2 : 가가가
// 값3 : 가가가
System.out.println();
String val;
// 1
/*
// peek()
// 큐의 head 요소 반환. 제거 안함. 큐가 empty 일 경우 null 을 반환
while (myQue.peek() != null) // 1. 가가가 값은 null 이 아님 -> peek 이라 확인만 함 3. 나나나 값은 null 이 아님 ...반복
{
// poll()
// 큐의 head 요소 반환. 제거함. 큐가 empty 일 경우 null 을 반환
val = (String)myQue.poll(); // 2. 가가가 값이 String으로 변환되어서 val에 들어가고 poll이라 제거됨
System.out.println("요소 : " + val);
}
// 요소 : 가가가
// 요소 : 나나나
// 요소 : 다다다
// 요소 : 라라라
*/
/*
System.out.println();
while (myQue.poll() != null)
{
val = (String)myQue.poll();
System.out.println("요소 : " + val);
}
// 요소 : 나나나
// 요소 : 라라라
*/
// 2.
/*
while (true)
{
val = (String)myQue.poll();
if(val == null)
break;
else
System.out.println("요소 : " + val);
}
요소 : 가가가
요소 : 나나나
요소 : 다다다
요소 : 라라라
*/
// 3.
while (!myQue.isEmpty())
{
val = (String)myQue.poll();
System.out.println("요소 : " + val);
}
System.out.println();
}
}컬렉션(157)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
import java.util.Queue;
import java.util.LinkedList;
public class Test157
{
// 정적 문자열 배열 선언 및 초기화
private static final String[] colors = {"검정", "노랑", "초록", "파랑", "빨강", "연두"};
public static void main(String[] args)
{
// Queue 자료구조 생성
Queue<String> qu = new LinkedList<String>();
// Queue 인터페이스 기반의 인스턴스를 생성하기 위해서는 new 연산자를 이용하여 Queue
// 인터페이스를 implements 한 하위 클래스의 생성자를 호출해야 한다.
// qu 라는 Queue 자료구조에 colors 배열의 데이터 모두 입력
for(String color : colors)
{
qu.offer(color);
}
// qu라는 Queue 자료구조의 모든 데이터 전체 출력
// peek()
// 큐의 head 요소를 반환하고 삭제하지 않으며 큐 자료구조가 비어잇는 상태가 되면 null 반환
// poll()
// 큐의 head 요소를 반환하고 삭제하며 큐 자료구조가 비어있는 상태가 되면 null 반환
String val;
while (qu.peek() != null)
{
val = qu.poll();
System.out.print(val + " ");
}
}
}Vector(158)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
/*
○ Vector(벡터)
자바의 자료구조 기능을 제공하는 클래스들 중 가장 기본적인 클래스로 배열과 비슷하지만,
배열과 달리 다른 종류의 데이터 형을 가진 데이터 요소들을 가질 수 있으며, 데이터가 가득 차면
자동으로 저장 영역을 확장시키게 된다.
또한, 객체 래퍼런스를 저장하기 때문에 JDK 1.5 이전에는 자바 기본형 데이터는 저장할 수 없었으나
JDK 1.5 이후부터는 오토박싱 / 오토언박싱 기능이 지원되면서 기본 데이터형도 저장할 수 있게 되었다.
백터 클래스의 기본 구조는 시퀀스(Sequence) 데이터 구조에 기반하여 시퀀스 데이터 접근을 순차적인
인덱스 값에 대한 위치로 접근하게 된다. 따라서 자료구조의 양 끝단에서만 접근이 가능한 큐나
한쪽 긑에서만 접근이 가능한 스택과 달리 시퀀스 개념의 인덱스 값을 이요하여 자료구조의 임의의 지점에서
저장 및 접근이 가능하다.
벡터의 시퀀스 구조는
List 인터페이스를 통해 제공받고 있기 때문에 List 인터페이스의 모든 메소드를 사용할 수 있다.
- void add(int index, E element)
- void insertElementAt(E obj, int index)
주어진 위치에 객체를 저장한다.
주어진 위치의 객체부터 오른쪽으로 하나씩 이동한다.
- void addElement(E obj)
- boolean add(E e)
객체를 백터 끝에 추가한다.
- void removeElementAt(int index)
- E remove(int index)
주어진 위치의 객체를 제거한다. 제거 후 주어진 위치 다음의 객체부터 하나씩 왼쪽으로 이동한다.
E remove(int index) 메소드는 저장되었떤 객체를 반환한다.
- boolean removeElement(Object obj)
- boolean remove(Object obj)
대상 객체를 제거한다. 제거 후 주어진 위치 다음의 객체부터 하나씩 왼쪽으로 이동한다.
객체가 정상적으로 제거되었으면 true를 반환한다.
- void removeAllElement()
- void clear()
백터의 모든 요소를 제거한다.
- void setElementAt(E obj, int index)
- E set(int index, E element)
백터의 index 위치에 주어진 객체를 저장한다.
주어진 위치에 저장되어 있던 객체는 소멸한다. (-> 덮어쓰기 개념)
- E elementAt(int index)
- E get(int index)
주어진 위치에 저장된 객체를 반환한다.
- Enumeration<E> elements()
백터의 모든 요소를 반환한다.
- int indexOf(Object o)
주어진 객체가 저장된 위치를 반환한다.
존재하지 않을 경우 음수를 반환한다.
- int indexOf(Object o, int index)
주어진 객체가 저장된 위치를 index 위치부터 찾아서 반환한다.
여기서 index 위치는 스캔을 시작하는 위치
- booelan contain(Object o)
백터가 주어진 객체를 포함하고 있는지의 여부를 반환한다.
- void ensureCapacity(int minCapacity)
백터의 용량을 주어진 크기보다 크도록 조절한다.
(주어진 크기를 수용할 수 있도록 조절한다.)
- E firstElement()
백터의 첫 번째 요소의 데이터를 반환한다.
- E lastElement()
백터의 마지막 요소의 데이터를 반환한다.
- void setSize(int newSize)
백터의 크기를 조절한다.
만약 주어진 크기가 현재 크기보다 작다면 나머지는 버린다.
반대로 주어진 크기가 현재 크기보다 크다면 빈 공간은 null 객체로 채우게 된다.
(객체를 참조하지 않음을 의미)
- int capacity()
현재 백터의 용량을 반환한다.
- int size()
현재 백터에 저장된 객체의 갯수(size)를 반환한다.
- int trimtoSize()
백터의 용량을 저장된 객체의 갯수에 맞도록 최소화한다.
*/
import java.util.Vector;
import java.util.Iterator;
public class Test158
{
// 정적 문자열 배열 선언 및 초기화
private static final String[] colors = {"검정", "노랑", "초록", "파랑", "빨강", "연두"};
public static void main(String[] args)
{
int i;
String str;
// Vector(백터) 자료구조 v 생성
Vector<Object> v = new Vector<>();
// v 라는 백터 자료구조에 colors 배열에 담겨있는 데이터 담아내기
// add()
for(i = 0; i < colors.length; i++)
{
v.add(colors[i]);
}
// addElement()
v.addElement("하양");
str = (String)v.firstElement();
System.out.println("첫 번째 요소 : " + str);
// 첫 번째 요소 : 검정
// get()
str = (String)v.get(1);
System.out.println("두 번째 요소 : " + str);
// 두 번째 요소 : 노랑
// get()
str = (String)v.get(0); // index번째 ㅇ소
System.out.println("첫 번째 요소 : " + str);
// 첫 번째 요소 : 검정
// elementAt()
str = (String)v.elementAt(1); // index번째 요소
System.out.println("두 번째 요소 : " + str);
// 두 번째 요소 : 노랑
// lastElement()
str = (String)v.lastElement(); // 마지막요소
System.out.println("마지막 요소 : " + str);
// 마지막 요소 : 연두
// ※ line121 v.addElement("하양"); 요소 추가 후 다시 확인
// 마지막 요소 : 하양 -> 마지막 요소가 바뀌었다.
// ※ 백터 자료구조에 요소 추가 시(-> add() / addElement())
// 인덱스 마지막(가장 끝)의 위치에 추가되는 것을 확인할 수 있다.
// 전체 요소 출력
// Iterator(이터레이터 or 아이터레이더)
// hasNext() : 다음 데이터 요소가 있는지 없는지의 여부를 확인
// next() : 다음 데이터 요소를 직접적으로 반환
Iterator<Object> it = v.iterator(); // 메소드 이름이 iterator() -> iterator 타입을 반환한다.
while (it.hasNext()) // 다음 값을 들여다보고 있으면 true
{
str = (String)it.next(); // 다음 값을 반환
System.out.print(str + " ");
}
System.out.println();
// 검정 노랑 초록 파랑 빨강 연두 하양
/* 이런 형태로 처리하기가 용이하다
▼
-------------------------------------
검정 노랑 초록 파랑 빨강 연두 하양
-------------------------------------
*/
}
}Vector(159)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
// Vector v = new Vector(); <기본 생성자 호출 시>
// 비어있는 Vector 자료구조 v 생성
// Vector v = new Vector(8); <매개 변수로 8를 넣어주면>
// 8개의 초기 elements 를 가진 Vector 자료구조 v 생성
// 이 자료구조를 활용하는 과정에서 8개가 모드 채워지게 되면
// (모두 사용되어 모자라게 되면) 자동으로 확장된다.
// Vector v = new Vector(3, 5) < 2개의 매개 변수를 넣어주면>
// 3개의 초기 elements 를 가진 Vector 자료구조 v 생성
// 이 자료구조를 활용하는 과정에서 3개가 모두 채워지게 되면(모두 사용되어 모자라게 되면)
// 자동으로 5개 증가(확장 된다.)
// ※ 백터는 데이터 요소로 정수형, 실수형, 문자열... 등을 담아내는 것이 가능하다.
// 그렇기 때문에 데이터의 안정성을 신경쓰면서 써야 한다.
// MyVector 클래스 설계 -> Vector 클래스 상속
import java.util.Vector;
import java.util.Iterator;
class MyVector extends Vector<Object>
{
// 생성자 -> 사용자 정의 생성자
MyVector()
{
// Vector (슈퍼 클래스) 생성자 호출
// super(); -> Vector();
super(1, 1);
// 첫 번째 인자 : 주어진 용량
// 두 번째 인자 : 증가량
}
void addInt(int i)
{
addElement(new Integer(i));
}
void addFloat(float f)
{
addElement(new Float(f));
}
void addString(String s)
{
addElement(s);
}
void addCharArray(char[] a)
{
addElement(a);
}
void addObject(Record rec)
{
addElement(rec);
}
/*
void write()
{
Iterator<Object> it = iterator();
Object a;
while (it.hasNext())
{
a = it.next();
System.out.print(a + " ");
}
System.out.println();
// 5 3.14 안녕하세요 [C@15db9742
*/ void write()
{
/*
Iterator<Object> it = iterator(); // this. super. 모두 가능 (이미 상속 받아왔기 때문에)
while(it.hasNext())
{
System.out.println(it.next());
}
5
3.14
안녕하세요
[C@15db9742 <- 배열 객체를 그대로 출력 구문에 넣은 현상이 발생한다.
*/
/*
Object o;
int length = size();
System.out.println("백터 요소의 갯수 : " + length);
// 백터 요소의 갯수 : 4
for(int i = 0; i < length; i++)
{
o = elementAt(i);
System.out.println(o);
}
*/
/*
5
3.14
안녕하세요
[C@15db9742 <- 똑같은 현상
*/
// instanceof 연산자 check
// 처리해야 하는 대상의 객체 타입 확인
Object o;
int length = size();
System.out.println("백터 요소의 갯수 : " + length);
for(int i = 0; i < length; i++)
{
o = elementAt(i);
/*
if(o instanceof char[])
{
System.out.println("문자배열");
}
else
{
System.out.println("다른형태");
}
백터 요소의 갯수 : 4
다른형태
다른형태
다른형태
문자배열
*/
if(o instanceof char[])
{
System.out.println("문자배열 : " + String.copyValueOf((char[])o));
/*
for(int j = 0; j < ((char[])o).length; j++)
{
System.out.println( ((char[])o)[j]);
}
*/
}
else if(o instanceof String)
{
System.out.println("문자열 : " + o.toString());
}
else if(o instanceof Integer)
{
System.out.println("정수형 : " + o);
}
else if(o instanceof Float)
{
System.out.println("실수형 : " + o);
}
else
{
System.out.println("타입 확인 요망~");
}
/*
백터 요소의 갯수 : 4
정수형 : 5
실수형 : 3.14
문자열 : 안녕하세요
문자배열 : study
*/
}
}//write end
}// class MyVector end
public class Test159
{
public static void main(String[] args)
{
// MyVector 클래스 기반 인스턴스 생성
MyVector v = new MyVector();
// 주요 변수 선언 및 초기화
int digit = 5;
float real = 3.14f;
String s = new String("안녕하세요");
char[] letters = {'s', 't', 'u', 'd', 'y'};
v.addInt(digit); // 백터 자료구조에 정수 저장
v.addFloat(real); // 백터 자료구조에 실수 저장
v.addString(s); // 백터 자료구조에 문자열 저장
v.addCharArray(letters); // 백터 자료구조에 문자 배열 저장
v.write();
}
}컬렉션 정렬(160)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
import java.util.Vector;
import java.util.Collections;
public class Test160
{
// 정적 문자열 배열 선언 및 초기화
private static final String[] colors = {"검정", "노랑", "초록", "파랑", "빨강", "연두"};
public static void main(String[] args)
{
// 백터 자료구조 생성
Vector<String> v = new Vector<>();
// 백터 자료구조 v에 colors 배열 데이터를 요소로 추가
for(String color : colors)
{
v.add(color);
}
System.out.println("첫 번째 요소 : " + v.firstElement());
System.out.println("두 번째 요소 : " + v.get(1));
System.out.println("마지막 요소 : " + v.lastElement());
System.out.println("요소의 갯수 : " + v.size());
// 첫 번째 요소 : 검정
// 두 번째 요소 : 노랑
// 마지막 요소 : 연두
// 요소의 갯수 : 6
// ○ 첫 번째 요소를 "하양"으로 변경 -> set()
// 어떠한 특정한 요소를 set하면 삽입(추가)가 아니라 변경임!!!!
v.set(0, "하양"); // 변경위치, 요소
System.out.println("첫 번째 요소 : " + v.firstElement());
System.out.println("두 번째 요소 : " + v.get(1));
System.out.println("요소의 갯수 : " + v.size());
// 첫 번째 요소 : 하양
// 두 번째 요소 : 노랑
// 요소의 갯수 : 6
// ○ 첫 번째 요소에 "주황"을 추.가. -> insertElementAt()
v.insertElementAt("주황", 0); // 요소, 삽입위치
// ○ 전체 출력
System.out.print("전체 출력 : ");
for(String str : v)
System.out.print(str + " ");
System.out.println();
// 전체 출력 : 주황 하양 노랑 초록 파랑 빨강 연두
// ○ 오름차순 정렬
Collections.sort(v);
// ○ 오름차순 정렬 후 전체 출력
System.out.print("오름차순 정렬 후 전체 출력 : ");
for(String str : v)
System.out.print(str + " ");
System.out.println();
// 오름차순 정렬 후 전체 출력 : 노랑 빨강 연두 주황 초록 파랑 하양 <- 가나다 순으로 정렬됨
// ○ 검색
// Collections.binarySearch();
// 검색 기능 수행
// 단, 오름차순 정렬이 수행되어 있는 자료에 대해서만 사용이 가능하다.
// 검색 결과가 존재하지 않을 경우 음수를 반환한다.
int idxBlue = Collections.binarySearch(v, "파랑"); // 값(value)를 찾는 것이기 때문에 index가 반환된다
System.out.printf("파랑 : %d 번째 인덱스에 위치하고 있다.\n", idxBlue);
System.out.println();
// 파랑 : 5 번째 인덱스에 위치하고 있다.
int idxPink = Collections.binarySearch(v, "분홍");
System.out.printf("분홍 : %d 번째 인덱스에 위치하고 있다.\n", idxPink);
// 분홍 : -2 번째 인덱스에 위치하고 있다. -> 분홍은 v에 존재하지 않는다.
// ○ 내림차순 정렬
Collections.sort(v, Collections.reverseOrder());
// ○ 내림차순 정렬 후 전체 출력
System.out.print("내림차순 정렬 후 전체 출력 : ");
for(String str : v)
System.out.print(str + " ");
System.out.println();
// 내림차순 정렬 후 전체 출력 : 하양 파랑 초록 주황 연두 빨강 노랑
// ※ 내림차순 정렬 후 검색 테스트
idxBlue = Collections.binarySearch(v, "파랑");
System.out.printf("파랑 : %d 번째 인덱스에 위치하고 있다.\n", idxBlue);
System.out.println();
// 파랑 : -8 번째 인덱스에 위치하고 있다.
// ※ 내림차순 정렬 후 검색 테스트
idxBlue = Collections.binarySearch(v, "파랑", Collections.reverseOrder());
System.out.printf("파랑 : %d 번째 인덱스에 위치하고 있다.\n", idxBlue);
System.out.println();
// 파랑 : 1 번째 인덱스에 위치하고 있다.
}
}검색 및 삭제(161)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
import java.util.Vector;
import java.util.Collections;
// 검색 및 삭제
public class Test161
{
// 정적 문자열 배열 선언 및 초기화
private static final String[] colors = {"검정", "노랑", "초록", "파랑", "빨강", "연두"};
public static void main(String[] args)
{
// 백터 자료구조 생성
Vector<String> v = new Vector<>();
// 백터 자료구조 v 에 colors 배열 데이터를 요소로 추가
for(String color : colors)
v.add(color);
// 백터 자료구조 v 의 전체 요소 출력
System.out.print("전체 요소 출력 : ");
for(String str : v)
System.out.print(str + " ");
System.out.println();
// 전체 요소 출력 : 검정 노랑 초록 파랑 빨강 연두
String s1 = "분홍";
// indexOf(); // 값이 어디에 담겨져 있는지 확인
int i = v.indexOf(s1);
System.out.println(s1 + " -> index 위치 : " + i);
System.out.println();
// 분홍 -> index 위치 : -1 분홍이 없으므로 -1 반환
String s2 = "노랑";
// v.contains(s)
// 백터 자료구조 v 에 찾고자 하는 s 가 포함되어 있는지의 여부 확인
// -> 포함되어 있다면 index 위치 확인
if(v.contains(s2))
{
i = v.indexOf(s2);
System.out.println(s2 + "-> index 위치 : " + i);
// 1. 존재하는지의 여부를 확인하고
// 2. 존재한다면 어디에 있는지 확인하고
// 3. 확인한 위치의 요소를 제거해라(삭제해라)
v.remove(i); // 인덱스를 삭제해라
}
System.out.println();
// 노랑-> index 위치 : 1
// 찾아서 삭제한 후 전제 요소 출력
System.out.print("삭제 후 전체요소 출력 : ");
for(String str : v)
System.out.print(str + " ");
System.out.println();
// 삭제 후 전체요소 출력 : 검정 초록 파랑 빨강 연두
System.out.println(v);
// [검정, 초록, 파랑, 빨강, 연두]
// 점검 확인용 더미 데이터는 실제 요소(데이터)가 아니기 때문에
// 이를 활용하여 연산을 진행하고 처리해서는 안된다
}
}컬렉션(162)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
/*
자료구조 객체 선언 및 생성 시
사용자 정의 클래스 활용
-> 자료형
*/
import java.util.Vector;
// 클래스 -> 사용자 정의 자료형으로 활용
class MyData
{
// 주요 속성 구성 -> 주요 변수 선언(멤버 변수)
private String name; // 이름
private int age; // 나이
// getter -> getXxx()
// setter -> setXxx()
// getter / setter 구성
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
// 생성자 -> 사용자 정의 생성자(매개변수 2개인 생성자)
public MyData(String name, int age)
{
this.name = name;
this.age = age;
}
// ※ 사용자 정의 생성자가 구성될 경우
// default 생성자가 자동으로 삽입되지 않기 때문에 default 생성자 형태의 생성자를
// 사용자 정의 생성자로 추가 구성하게 되는 것이 일반적인 클래스 설계 과정
// (반드시 설계해야 한다는 문법적인 규칙은 없다.)
// 생성자 -> 사용자 정의 생성자(매개변수 없는 생성자)
public MyData()
{
// this("", 0);
name = "";
age = 0;
}
@Override
public String toString()
{
return "이름:" + name + "," + " " + "나이:"+ age;
}
}
public class Test162
{
public static void main(String[] args)
{
// 백터 자료구조 생성
Vector<MyData> v = new Vector<MyData>(); //MyData 타입만 들어갈 수 있는 v 라는 Vector
// 백터 자료구조 v에
// 가가가 74세 / 나나나 7세 / 다다다 3세 담아내기
v.add(new MyData("가가가", 74));
v.add(new MyData("나나나", 7));
v.add(new MyData("다다다", 3));
/*
MyData data1 = new MyData();
data1.setName("가가가");
data1.setAge(74);
MyData data2 = new MyData();
data2.setName("나나나");
data2.setAge(7);
MyData data3 = new MyData();
data3.setName("다다다");
data3.setAge(3);
v.add(data1);
v.add(data2);
v.add(data3);
for(MyData a : v)
System.out.println(a + " ");
*/
// 백터 자료구조 v 에 담긴 내용(요소) 전체 출력하기
// 실행 예)
// 이름:김수환, 나이:73세
// 이름:김지민, 나이:7세
// 이름:노은하, 나이:3세
/*
for(MyData a : v)
System.out.println(a + " ");
for(int i = 0; i < v.size(); i++)
System.out.println("이름:" + v.get(i).getName() + ", " + "나이:" + v.get(i).getAge());
System.out.printf("이름:%s, 나이:%d세\n", v.elementAt(i).getName, v.elementAt(i).getAge);
백터.i 번째 MyData.getName
*/
/*
for(MyData obj : v)
{
System.out.printf("이름:%s, 나이:%d세\n", obj.getName(), obj.getAge());
}
System.out.println();
*/
for(Object obj : v)
{
System.out.printf("이름:%s, 나이:%d세\n", (MyData(obj)).getName(), (MyData(obj)).getAge());
}
System.out.println();
}
}자료구조를 이용한 프로그램 구현(163)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
// Test163 클래스를 완성하여 다음 기능을 가진 프로그램을 구현한다.
/*
실행 예)
[ 메뉴 선택 ]=============
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
==========================
>> 메뉴 선택 : (1~6) : 1
1번째 요소 입력 : 가가가
1번째 요소 입력 성공
요소 입력 계속(Y/N)? : y
2번째 요소 입력 : 나나나
1번째 요소 입력 성공
요소 입력 계속(Y/N)? : n
[ 메뉴 선택 ]=============
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
==========================
>> 메뉴 선택 : (1~6) : 2
[백터 전체 출력]
가가가
나나나
백터 전체 출력 완료
[ 메뉴 선택 ]=============
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
==========================
>> 메뉴 선택 : (1~6) : 3
검색할 요소 입력 : 나나나
[검색 결과 출력]
항목이 존재합니다.
[ 메뉴 선택 ]=============
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
==========================
>> 메뉴 선택 : (1~6) : 3
검색할 요소 입력 : 다다다
[검색 결과 출력]
항목이 존재하지 않습니다.
[ 메뉴 선택 ]=============
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
==========================
>> 메뉴 선택 : (1~6) : 4
삭제할 요소 입력 : 라라라
[삭제 결과 출력]
항목이 존재하지 않아 삭제할 수 없습니다.
[ 메뉴 선택 ]=============
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
==========================
>> 메뉴 선택 : (1~6) : 4
삭제할 요소 입력 : 가가가
[삭제 결과 출력]
가가가 항목이 삭제되었습니다.
[ 메뉴 선택 ]=============
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
==========================
>> 메뉴 선택 : (1~6) : 5
변경할 요소 입력 : 바바바
[변경 결과 출력]
변경할 대상이 존재하지 않습니다.
[ 메뉴 선택 ]=============
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
==========================
>> 메뉴 선택 : (1~6) : 5
변경할 요소 입력 : 나나나
수정할 내용 입력 : 사사사
[변경 결과 출력]
변경이 완료되었습니다.
[ 메뉴 선택 ]=============
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
==========================
>> 메뉴 선택 : (1~6) : 2
[백터 전체 출력]
사사사
백터 전체 출력 완료
[ 메뉴 선택 ]=============
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
==========================
>> 메뉴 선택 : (1~6) : 6
프로그램 종료
계속하려면...
*/
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Vector;
import java.util.Enumeration;
class Menus // 완성
{
public static final int E_ADD = 1; // 요소 추가
public static final int E_DESP = 2; // 요소 출력
public static final int E_FIND = 3; // 요소 검색
public static final int E_DEL = 4; // 요소 삭제
public static final int E_CHA = 5; // 요소 변경
public static final int E_EXIT = 6; // 종료
}
public class Test163
{
// 주요 속성 구성 -> 완료
private static final Vector<Object> vt; // 자료구조
private static BufferedReader br; // 입력 시 활용
private static Integer sel; // 선택 값
private static String con; // 계속 진행
// static 초기화 블럭
static
{
// Vector 자료구조 생성
vt = new Vector<Object>();
// BufferedReader 객체 생성
br = new BufferedReader(new InputStreamReader(System.in));
// 사용자 입력값 초기화
sel = 1;
con = "Y";
}
// 메뉴 출력 메소드
public static void menuDisp()
{
System.out.println("\n [ 메뉴 선택 ]=============");
System.out.println(" 1. 요소 추가");
System.out.println(" 2. 요소 출력");
System.out.println(" 3. 요소 검색");
System.out.println(" 4. 요소 삭제");
System.out.println(" 5. 요소 변경");
System.out.println(" 6. 종료");
System.out.println(" ==========================");
System.out.print(">> 메뉴 선택 : (1~6) : ");
}
// 메뉴 선택 메소드
public static void munuSelect() throws IOException, NumberFormatException
{
try
{
sel = Integer.parseInt(br.readLine());
}
catch (NumberFormatException e)
{
System.out.println(e.toString());
System.out.println(">> 숫자 형태의 데이터를 입력해야 합니다");
sel = 0;
}
}
// 선택된 메뉴 실행에 따른 기능 호출 메소드
public static void menuRun() throws IOException
{
switch(sel)
{
case Menus.E_ADD : addElement(); break;
case Menus.E_DESP : dispElement(); break;
case Menus.E_FIND : findElement(); break;
case Menus.E_DEL : delElement(); break;
case Menus.E_CHA : chaElement(); break;
case Menus.E_EXIT : exit(); break;
default : System.out.print("잘못입력했습니다.");
}
}
// 자료구조에 요소 추가(입력) 메소드
public static void addElement() throws IOException
{
int n = vt.size() + 1;
do
{
System.out.printf("%d번째 요소 입력 : ", n);
String name = br.readLine();
vt.add((String)name);
System.out.printf("%d번째 요소 입력 성공\n", n);
n++;
System.out.print("요소 입력 계속(Y/N)? : ");
con = br.readLine();
}
while (con.equals("Y") || con.equals("y"));
/*
while (con.equals("Y") || con.equals("y"))
{
System.out.printf("%d번째 요소 입력 : ", n);
String name = br.readLine();
vt.add((String)name);
System.out.printf("%d번째 요소 입력 성공\n", n);
n++;
System.out.print("요소 입력 계속(Y/N)? : ");
con = br.readLine();
}
*/
/*
do
{
System.out.printf("\n\t%d번째 요소 입력 : ", vt.size() + 1);
String element = br.readLine();
boolean b = vt.add(element);
if(b)
{
System.out.printf("\n\t%d번째 요소 입력 성공~\n", vt.seze());
}
System.out.print("\n\t요소 입력 계속(Y/N)? : ");
con = br.readLine().toUpperCase();
}
while (con.equals("Y"));
*/
}
// 자료구조 전체 요소 출력 메소드
public static void dispElement()
{
/*
for(int i = 0; i < vt.size(); i++)
{
System.out.printf("%s\n", (String)vt.get(i));
}
*/
for(Enumeration e = vt.elements(); e.hasMoreElements();)
{
System.out.printf("\t%10s\n", e.nextElement());
}
System.out.println("\t백터 전체 출력 완료");
}
// 자료구조 내 요소 검색 메소드
public static void findElement() throws IOException
{
System.out.print("검색할 요소 입력 : ");
String element = br.readLine();
if(vt.contains(element))
{
System.out.println("\n[검색 결과 출력]");
System.out.println("항목이 존재합니다.");
// 추가
int i = vt.indexOf(element);
System.out.println("\t(" + element + "위치 : " + i + ")");
}
else
{
System.out.println("\n[검색 결과 출력]");
System.out.println("항목이 존재하지 않습니다.");
}
}
// 자료구조 내 요소 삭제 메소드
public static void delElement() throws IOException
{
System.out.print("삭제할 요소 입력 : ");
String removeE = br.readLine();
if(vt.contains(removeE))
{
vt.remove(removeE);
System.out.println("[삭제 결과 출력]");
System.out.printf("%s 항목이 삭제되었습니다.", removeE);
}
else
{
System.out.println("[삭제 결과 출력]");
System.out.printf("항목이 존재하지 않아 삭제할 수 없습니다.");
}
}
// 자료구조 내 요소 수정(변경) 메소드
public static void chaElement() throws IOException
{
System.out.print("변경할 요소 입력 : ");
String changeE = br.readLine();
if(!vt.contains(changeE))
{
System.out.println("[변경 결과 출력]");
System.out.println("변경할 대상이 존재하지 않습니다.");
}
else
{
System.out.print("수정할 내용 입력 : ");
String changeTo = br.readLine();
vt.set(vt.indexOf(changeE),changeTo);
System.out.println("[변경 결과 출력]");
System.out.println("변경이 완료되었습니다.");
}
}
// 프로그램 종료 메소드 -> 완성
public static void exit()
{
System.out.println("\n프로그램 종료");
System.exit(-1);
}
// main() 메소드 -> 완성
public static void main(String[] args) throws IOException, NumberFormatException
{
do
{
menuDisp();
munuSelect();
menuRun();
}
while (true);
}
}Enumeration 과 Iterator 인터페이스(164)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
/*
○ Enumeration 과 Iterator 인터페이스
Collection Framework 에는
Enumeration 과 Iterator 라는 인터페이스가 있다. 사전적인 의미로는 반복, 순환 이라는
의미를 가지고 있으며 어떤 객체들의 모임이 있을 때, 이 객체들을 어떤 순서에 의해
하나씩 접근하여 사용하기 위한 인터페이스라고 할 수 있다.
- java.util.Enumeration<E> 인터페이스
: 이 인터페이스는 단지 두 개의 메소드만을 제공하며 hasMoreElements() <- 추가 요소를 가지고 있니?
메소드를 통해 인터페이스 안에 다음요소가 있는지에 대한 질의를 한다. 만약 true가 반환되었다면
다음 인덱스에 요소가 존재한다는 의미이며 nextElement() <- 다음요소를 가지고 와
메소드로 다음에 접근하여 사용하면 되는 것이다.
es) // v라는 백터 자료구조에 저장된 모든 요소 출력
for(Enumeratino e = v.elements(); e.hasMoreElements();)
{
System.out.println(e.nextElement());
}
- java.util.Iterator<E> 인터페이스
: Enumeration 과의 차이점은 단지 remove() 메소드가 추가된 것 뿐이다.
Iterator 가 가지고 있는 hasNext() 와 next() 메소드는 이름만 약간 다를 뿐 Enumeration
인터페이스가 가지고 있는 hasNextElements() 와 그리고 nextElement() 와 정확히 일치하는
기능을 수행한다. Enumeration 대신 Iterator 를 JDK 1.2 부터 추가하여 사용하게 된 이유는
Enumeration 인터페이스는 집합 내에서 요소를 제거할 방법이 없기 때문에 이를 보완하기 위해
나온 것이 Iterator 인터페이스이다.
*/
import java.util.Vector;
import java.util.Enumeration;
import java.util.Iterator;
public class Test164
{
public static void main(String[] args)
{
// 백터 자료구조 인스턴스 생성
Vector<String> v = new Vector<>();
// 백터 자료구조 v 에 요소 추가
v.add("Java");
v.add("Oracle");
v.add("Jsp");
v.add("Servlet");
v.add("Spring");
// 1. Enumeration
// - hasMoreElements()
// - nextElement()
Enumeration<String> e = v.elements();
while (e.hasMoreElements())
{
System.out.println(e.nextElement());
}
// Java
// Oracle
// Jsp
// Servlet
// Spring
System.out.println("-------------------------------");
// 2. Iterator
// - hasNext()
// - next()
Iterator<String> it = v.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
// Java
// Oracle
// Jsp
// Servlet
// Spring
}
}ArrayList(165)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
// List -> Vector, ArrayList, LinkedList, ...
// · 순서 있음
// · 배열과 유사
// · 중복 허용
/*
○ ArrayList 클래스
- ArrayList 와 Vector 클래스는
List 를 크기 변경이 가능한 배열로 구상한 것으로 차이점은 Vector 클래스의 객체는
기본적으로 동기화 되지만, ArrayList 는 그렇지 않다는 점이다.
- 비동기화 컬렉션은 동기화된 컬렉션보다 더 나은 성능을 제공하며 스레드들이 컬렉션을
공유할 필요가 없는 프로그램에서는 일반적으로 ArrayList 를 Vector 보다 더 선호하며,
ArrayList 는 동기화를 고려하지 않은 Vector 처럼 동작함으로써 스레드 동기화에 따르는
부담을 가지기 않기 때문에 Vector 보다 더 빠르게 실행된다.
- null 을 포함한 모든 요소를 허용하며 List 인터페이스를 구현하는 것 외에 리스트에 격납
하기 위해 내부적으로 사용되는 배열의 사이즈를 조작하는 메소드를 제공한다.
*/
import java.util.ArrayList;
import java.util.Vector;
import java.util.List;
import java.util.ListIterator;
public class Test165
{
public static void main(String[] args)
{
// ArrayList 자료구조 생성
// ArrayList<String> list = new ArrayList<>();
// List<String> list new List<String>();
// List는 인터페이스라 직접 인스턴스 생성 불가
// Vector<String> list = new Vector<>();
// List<String> list = new Vector<>();
List<String> list1 = new ArrayList<String>();
// list1 자료구조에 요소 추가 -> add();
list1.add("오팬하이머");
list1.add("엘리멘탈");
list1.add("알라딘");
List<String> list2 = new ArrayList<String>(list1); // 1. ArrayList 생성자에 list1을 넣어주면
// list2 자료구조에 요소 추가 -> add()
list2.add("스파이더맨"); // 3. list2 에 요소를 추가하면
List<String> list3 = new ArrayList<String>();
// list3 에 list2 의 전체 요소 추가 -> addAll()
list3.addAll(list2);
// 알라딘 앞에 탑건 추가
// [오팬하이머, 엘리멘탈, 알라딘, 스파이더맨]
// [오팬하이머, 엘리멘탈, 탑건, 알라딘, 스파이더맨]
// 알라딘 찾기 -> indexOf() -> 위치 인덱스 반환
int n = list3.indexOf("알라딘");
// 테스트
//System.out.println("n : " + n); -> n : 2
// 알라딘 찾은 인덱스 위치에 탑건 삽입 -> add()
list3.add(n, "탑건");
// 출력 -> 더미데이터 확인
System.out.println("========================================");
System.out.println(list1);
// [오팬하이머, 엘리멘탈, 알라딘]
System.out.println(list2);
// []
// [오팬하이머, 엘리멘탈, 알라딘] 2. list1 에 있던 값이 list2로 넘어간다
// [오팬하이머, 엘리멘탈, 알라딘, 스파이더맨] 3. 추가한 값이 나옴
System.out.println(list3);
// [오팬하이머, 엘리멘탈, 알라딘, 스파이더맨]
// [오팬하이머, 엘리멘탈, 탑건, 알라딘, 스파이더맨] <- add(n, "탑건") 해주고 난 후
// 출력 -> listIterator() 메소드를 활용해서 출력
System.out.println("========================================");
ListIterator<String> li = list3.listIterator();
while(li.hasNext())
{
System.out.print(li.next() + " ");
}
System.out.println();
// 오팬하이머 엘리멘탈 탑건 알라딘 스파이더맨
// 출력을 역순으로 접근해보자
while (li.hasPrevious()) //hasPrevious 에서 0 번째의 이전(Previous)은 li의 크기 n 번째이다
{
System.out.print(li.previous() + " ");
}
System.out.println();
// 스파이더맨 알라딘 탑건 엘리멘탈 오팬하이머
}
}list(166)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
/*
○ list
- 순서가 있음, 배열과 유사, 중복을 허용
- 주요 구현 클래스
·Vector (동기화 지원)
·ArrayList (동기화 지원 X)
·LinkedList (체인, 링크, 결합, 큐)
*/
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class Test166
{
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();
list.add("서울");
list.add("부산");
list.add("인천");
list.add("대구");
list.add("광주");
list.add("대전");
list.add("울산");
list.add("세종");
// 확인 -> 더미 확인
System.out.println(list);
// [서울, 부산, 인천, 대구, 광주, 대전, 울산, 세종]
System.out.println("전체 갯수 : " + list.size());
// 전체 갯수 : 8
// 첫 번째 요소만 출력
System.out.println("첫 번째 요소 : " + list.get(0));
// 첫 번째 요소 : 서울
// 마지막 요소만 출력
System.out.println("마지막 요소 : " + list.get(list.size() - 1));
// 마지막 요소 : 세종
// 처음 위치에 "한국" 추가
list.add(0, "한국");
// 더미 확인
System.out.println(list);
// [한국, 서울, 부산, 인천, 대구, 광주, 대전, 울산, 세종]
// 처음 위치의 데이터(요소)를 "대한민국"으로 변경
list.set(0, "대한민국");
System.out.println(list);
// [대한민국, 서울, 부산, 인천, 대구, 광주, 대전, 울산, 세종]
// "서울" 존재여부 확인
if (list.contains("서울"))
{
System.out.println("서울의 인덱스 출력");
System.out.println(list.indexOf("서울")); // 인덱스 위치 출력
}
else
System.out.println("존재하지 않음");
// "대한민국" 지우기
list.remove("대한민국");
System.out.println(list);
// [서울, 부산, 인천, 대구, 광주, 대전, 울산, 세종]
// list의 전체 요소 출력
System.out.println("전체 출력... 1");
Iterator<String> it = list.iterator();
while (it.hasNext())
System.out.print(it.next() + " ");
System.out.println();
/*
while(it.hasPrevious())
System.out.print(it.previous()); ※ Iterator 에는 hasPrevious가 없다!!
System.out.println(); list.Iterator 사용해야 hasPrevious 사용 가능
*/
for(int i = 0; i < list.size(); i++)
System.out.print(list.get(i) + " ");
System.out.println();
for(int i = list.size(); i >=0; i--) // 역순
System.out.print(list.get(i) + " ");
System.out.println();
for(String s : list)
System.out.print(s + " ");
System.out.println();
ListIterator<String> li = list.listIterator();
while(li.hasNext())
System.out.print(li.next() + " ");
while (li.hasPrevious())
{
String s = li.previous();
System.out.print(s + " ");
}
System.out.println();
}
}리스트와 배열 서로 바꾸기(167)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
/*
list -> String[] list.toArray()
String[] -> list Arrays.asList()
*/
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
public class Test167
{
public static void main(String[] args)
{
List<String> mList = new ArrayList<String>();
mList.add("1");
mList.add("2");
mList.add("3");
// list 구조를 String배열로 전환하고자한다. String.toArray
// mlist.toArray(new String[3]);
String[] strArray = mList.toArray(new String[mList.size()]);
for(String s: strArray)
{
System.out.print(s + " ");
}
System.out.println();
// 1 2 3
// check
// String[] -> List
// Arrays.asList();
List<String> mNewList = Arrays.asList(strArray);
// ※ Arrays.asList() 의 반환 자료형은 List
for(String s : mNewList)
{
System.out.print(s + " ");
}
System.out.println();
// 1 2 3
}
}Set(168)
/*================================
■■■ 컬렉션(Collection) ■■■
=================================*/
/*
○ Set -> HashSet, TreeSet
·순서 없음
·중복 허용하지 않는 구조(기본)
○ HashSet<E> 클래스
java.util.HashSet<E> 클래스는
Set 인터페이스를 구현하는 클래스로 순서의 개념이 아니라 집합의 개념으로 이해해야 하는
자료구조이다 이로 인해 데이터의 중복을 허용하지 않는다. 또한, 동기화를 지원하지 않는다.
*/
import java.util.Set;
import java.util.HashSet;
public class Test168
{
public static void main(String[] args)
{
// Set 자료구조 생성
// Set ob = new Set(); // Set은 인터페이스라 이런식으로 생성 불가
Set<String> dog = new HashSet<String>();
// dog 라는 Set 자료구조에 요소 추가
dog.add("리트리버");
dog.add("푸들");
dog.add("말티즈");
dog.add("불독");
dog.add("진돗개");
// 기존 데이터 Set 출력
System.out.print("기존 데이터 Set : ");
for(String s : dog)
System.out.print(s + " ");
System.out.println();
// 기존 데이터 Set : 리트리버 진돗개 푸들 불독 말티즈 -> 추가한 순서대로 나오지 않는다
// 순서가 의미 없는 자료구조이기 때문에
// 데이터 입력 순서 -> 자료구조의 요소 격납 순서
// 이들이 서로 관계 없이 구성되어 있는 것을 확인할 수 있다.
// 데이터(요소) 추가
dog.add("진돗개");
dog.add("진돗개");
dog.add("불독");
dog.add("시베리안 허스키");
dog.add("비글");
dog.add("리트리버");
dog.add("푸들");
dog.add("말티즈");
// 추가 후 데이터 Set 출력
System.out.print("추가 후 데이터 : Set : ");
for(String s : dog)
System.out.print(s + " ");
System.out.println();
// 추가 후 데이터 : Set : 리트리버 진돗개 푸들 시베리안 허스키 불독 말티즈 비글 <- 중복된 값을 추가하면 추가되지 않는다.
// ※ 데이터가 추가되는 순서와 상관없이 목록이 구성되어 있으며 같은 데이터가 여러번 반복
// 추가될 경우 이들 중 하나만 유효한 데이터로 구성되어 있는 것을 확인할 수 있다.
// (아무리 추가해도 한 번만 확인 출력됨)
// ※ 또한, 자료구조의 특성 상
// 중복 데이터를 허용하지 않는다고 해서 중복된 데이터를 추가할 경우 에러가
// 발생한다는 의미는 아니라는 것도 확인할 수 있다.
}
}