Java์์๋ ์ผ๋ฐ์ ์ผ๋ก ํด๋์ค์ ์บก์ํ๋ ๊ธฐ๋ฅ(์์ /์๋)๊ณผ ๋ฐ์ดํฐ๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด ํด๋์ค์์ ๊ฐ์ฒด๋ฅผ ์์ฑ
: ์บก์ํ?? - private : ์ผ๋ก ์ ์ธ๋์ด ์ธ๋ถ์์ ์ง์ ์ ์ธ ์ ๊ทผ์ด ๋ถ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค. ๋์ ์, ํด๋์ค๋ ์ธ๋ถ์์ ์ ๊ทผํ ์ ์๋ public ๋ฉ์๋(๋๋ getter์ setter)๋ฅผ ์ ๊ณตํ์ฌ ๋ฐ์ดํฐ์ ์ ๊ทผํ๊ฑฐ๋ ์กฐ์ํ ์ ์๋๋ก ํฉ๋๋ค.
์ปฌ๋ ์ (Collection) :
- Java ํ๋ก๊ทธ๋๋ฐ์์ ๋ค์ํ ํํ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ,๊ทธ๋ฃนํํ๊ณ ๊ด๋ฆฌํ๋ ๊ตฌ์กฐ (Java์์ ๋งค์ฐ ์ค์)
List (๋ชฉ๋ก):
์์๊ฐ ์๋ ๋ฐ์ดํฐ์ ์งํฉ
๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ ์์๋๋ก ์ ์ฅํ๋ฉฐ, ์ค๋ณต๋ ๊ฐ ํ์ฉ
์์: ArrayList( ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๊ณ ์ญ์ ํ๋ ๋ฐ ํจ์จ์ ), LinkedListSet (์งํฉ):
Set์ ์ค๋ณต๋ ๊ฐ์ ํ์ฉํ์ง ์๋ ๋ฐ์ดํฐ์ ์งํฉ์ ๋ํ๋ ๋๋ค. ์์๊ฐ ์ ํด์ ธ ์์ง ์์ต๋๋ค.
์์: HashSet, TreeSetMap (๋งต):
ํค-๊ฐ ์์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ฉฐ, ๊ฐ ํค๋ ๊ณ ์
(๊ฒ์๊ณผ ์์ ์ ํนํ)
์์: HashMap, TreeMapQueue (ํ):
Queue๋ ์ ์ ์ ์ถ(FIFO, First-In-First-Out) ๊ตฌ์กฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ
์ฃผ๋ก ์์ ๋๊ธฐ์ด ๋ฑ์ ์ฌ์ฉ
Stack์ ํ์ ์ ์ถ(LIFO, Last-In-First-Out) ๊ตฌ์กฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ ์ฃผ๋ก ์ญ์ถ์ (backtracking)์ด๋ ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ ๋ฑ์ ์ฌ์ฉ๋ฉ๋๋ค.
์ปฌ๋ ์ ํ๋ ์์ํฌ(Collection Framework)๋?
๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ์กฐ์ํ๊ณ ๊ตฌ์กฐํํ ์ ์๋๋ก ์ฌ์ฉํ๋
์ปฌ๋ ์ ํ๋ ์์ํฌ์ ์ด๊ธฐ ์ฉ๋(capacity) :
ex) ArrayList(ํด๋์ค) : ๋ด๋ถ ๋ฐฐ์ด์ ์ฌ์ฉํด์ ์์ ์ ์ฅ
-> ๋ฐฐ์ด์ ์ด๊ธฐ ์ฉ๋ : 10 (๋ณ๊ฒฝ ๊ฐ๋ฅ)
๋ด๋ถ์ ์ผ๋ก ํฌ๊ธฐ ์กฐ์ ๋ฉ์ปค๋์ฆ์ด ์์ด์ ๋ฐ์ดํฐ์ ์ํฉ์ ๋ฐ๋ผ ์ถ๊ฐ, ์ ๊ฑฐ ๋ฑ ํ์์ ๋ฐ๋ผ ํฌ๊ธฐ ์กฐ์ ํจ
ex) ArrayList(ํด๋์ค) : ๋ฐฐ์ด ํฌ๊ธฐ๊ฐ ๋ถ์กฑํ๋ฉด ์๋์๋ก ๋ ํฐ ๋ฐฐ์ด๋ก ๋ณต์ฌ / ์์ ์ ๊ฑฐํ๊ณ ์ถ์ผ๋ฉด ์๋์ผ๋ก ํฌ๊ธฐ ์ค์
์ธํฐํ์ด์ค (Interfaces):
Collection: ๋ชจ๋ ์ปฌ๋ ์
์ธํฐํ์ด์ค์ ์ต์์ ์ธํฐํ์ด์ค๋ก, ๊ธฐ๋ณธ์ ์ธ ์ปฌ๋ ์
๋์์ ์ ์ํฉ๋๋ค.
Set: ์ค๋ณต์ ํ์ฉํ์ง ์๋ ์์๋ค์ ์งํฉ์ ํํํฉ๋๋ค.
List: ์์๊ฐ ์๋ ์์๋ค์ ๋ชฉ๋ก์ ํํํฉ๋๋ค.
Queue: ์ ์
์ ์ถ(FIFO) ๊ตฌ์กฐ์ ์์๋ฅผ ์ฒ๋ฆฌํ๋๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
Map: ํค-๊ฐ ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ฉฐ, ๊ฐ ํค๋ ๊ณ ์ ํด์ผ ํฉ๋๋ค.
ํด๋์ค (Classes):
์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ๊ตฌ์ฒด์ ์ธ ํด๋์ค๋ค์ด ์ ๊ณต๋ฉ๋๋ค.
์์: ArrayList, LinkedList, HashSet, HashMap ๋ฑ.
์๊ณ ๋ฆฌ์ฆ (Algorithms):
๊ฒ์, ์ ๋ ฌ, ๋ณต์ฌ ๋ฑ ๋ค์ํ ์๊ณ ๋ฆฌ์ฆ์ด ์ ๊ณต๋์ด ํจ์จ์ ์ธ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์ง์ํฉ๋๋ค.
์์: Collections.sort(), Collections.binarySearch() ๋ฑ.
๋๊ธฐํ (Synchronization):
๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์์ ์์ ํ๊ฒ ์ปฌ๋ ์
์ ์ฌ์ฉํ ์ ์๋๋ก ๋๊ธฐํ๋ ์ปฌ๋ ์
๋ ์ ๊ณต๋ฉ๋๋ค.
์์: Collections.synchronizedList(), Collections.synchronizedMap() ๋ฑ.
Utility ๋ฉ์๋ (Utility Methods):
Collections ํด๋์ค๋ฅผ ํตํด ์ ์ฉํ ๋ฉ์๋๋ค์ด ์ ๊ณต๋์ด ๋ฐ์ดํฐ ์กฐ์์ ๊ฐํธํ๊ฒ ํ ์ ์์ต๋๋ค.
์์: Collections.addAll(), Collections.max(), Collections.shuffle() ๋ฑ.
์ธํฐํ์ด์ค (์ ์ฅ๊ณต๊ฐ์ผ๋ก๋ ์ฌ์ฉ)
Collection :
โ ๋ฐ์ดํฐ ์์งํด์ ๋ชจ์๋๋ ๊ฒ
โก ๋ฐฐ์ด์ด๋ ๋๊ฐ์ง๋ง, ์ปฌ๋ ์ ํ๋ ์์ํฌ์ ์ด๊ธฐ ์ฉ๋(capacity) : ๊ธฐ๋ณธ default ์ฉ๋ = 10๊ฐ / ๋ฐ์ดํฐ๊ฐ ์์์ ๋์ด๋๊ณ , ์ค์ด๋๊ฑด ๋ช ๋ น์ด๋ฅผ ํตํด ๊ฐ๋ฅ
ex) List, Vector, Set, Map, LinkedList, HashSet, TreeSet, Hashtable
-------------------------------------------------------------------------------
list(์ธํฐํ์ด์ค) - Vector (ํด๋์ค) : ๋๊ธฐํ ์ง์ โ ArrayLsit๋ณด๋ค ๋๋ฆผ
list(์ธํฐํ์ด์ค) - ArrayLsit (ํด๋์ค) : ๋๊ธฐํ ์ง์ X โ Vector๋ณด๋ค ๋น ๋ฆ
-------------------------------------------------------------------------------Iterator :
Collection ๊ฐ์ฒด๋ฅผ ๋์๋ค๋๋ฉด์ ์ ๊ทผํ๊ณ , Collection์ ๋ด์ฉ์ ์์๋๋ก ์ฝ์ ์ ์์lterator <String> it = lists.iterator( ); while( it.hasNext() ) { String s = it.next( ); System.out.println(s);
โ Collection Framework(๋ฐฉ๋ฒ๋ค)์์ ๋ง์ด ์ฌ์ฉ
โก Iterator ๋ฉ์๋ :
- hasNext( ) : ๋ค์๊ฑฐ๋ฅผ ํ์ธํ๋ ๋ฉ์๋
- boolean hasNext( ) : ๋ค์ ์กด์ฌํ์ธ (o - true / x - false)
- void remove( ) : ๋์๋ค๋๋ ์์๋ฅผ ์ญ์ , ์ผ๋ถ๋ ์ง์ ๋ถ๊ฐํ ์๋ ์์
-------------------------------------------------------------------------------list :
โ Collection Framework์์ ์ ๊ณตํ๋ Interface
โก ๋ฐฐ์ด์ ์ผ์ข ์ธ๋ฐ, ์์๊ฐ ์๋ ๋ฐ์ดํฐ์ ์งํฉ
โข ์์ ์ ์ง (Ordering) : ์ฝ์ ๋ ์์๋๋ก ์ ์งํจ โ index๋ฅผ ํตํด ์ ๊ทผํ ์ ์์
โฃ ์ค๋ณต ํ์ฉ : ๋์ผํ ์์๋ฅผ ์ค๋ณตํด์ ์ ์ฅ ๊ฐ๋ฅ
โค list ๋ฉ์๋ :
- boolen add(E element) : ๋ฆฌ์คํธ์ ์์ ์ถ๊ฐ
- void add(int index, E element) : index์ ์์ ์ฝ์
- get(int index): indext ๋ฐํ
- int size( ) : ๋ฆฌ์คํธ ํฌ๊ธฐ ๋ฐํ
- boolean remove(Object o) : ๋ฆฌ์คํธ์์ ์ ๊ฑฐ
- E remove (int index) : ์ง์ ๋ index์ ๋ฆฌ์คํธ์์ ์ ๊ฑฐํ๊ณ , ๋ฐํํจ
- void clear( ) : ๋ฆฌ์คํธ ๋ชจ๋ ์์ ์ ๊ฑฐ
โฅ list๋ฅผ ์ด๋ฏธ ๋ง๋ ์ฃผ์ ํด๋์ค : ArrayList / Vector / LinkedList...
toString :
- ์๋ฐ์์ ๋ชจ๋ ํด๋์ค๊ฐ ์์๋ฐ๋ ๋ฉ์๋
- ๊ฐ์ฒด์ ํด๋์ค ์ด๋ฆ / ํด์์ฝ๋์ ๋ฌธ์์ด๋ก ๋ฐํ
- ๋ด๊ฐ ๋ง๋ ํด๋์ค์์ toString( )์ ์ค๋ฒ๋ผ์ด๋ฉํด์ ๊ฐ์ฒด ๋ด๋ถ์ํ๋ฅผ ๋ฌธ์์ด๋ก ๋ฐํํ๋๋ก ๊ตฌํํ ์ ์์
String.format :
- ์ง์ ๋ ํ์์ ๋ง์ถฐ์ ๋ฌธ์์ด ์์ฑ๊ฐ๋ฅ
- 'format' = ์ถ๋ ฅํ ๋ฌธ์์ด ํ์ ์ง์
: %๊ธฐํธ์ ๋ค์ํ ํ์์ง์ ์(์ถ๋ ฅํ ๊ฐ์ ํ์ ์ ๋ฐ๋ผ ์ง์ )๋ก ๊ตฌ์ฑ
: ์ ๋ด์๋จ๋ค๊ฐ ์์๊ฒ ๊พธ๋ฉฐ์ ๋ฆฌํด๊ฐ์ผ๋ก ๋ฐํํด๋ฌ๋ผ๋ ๋ป
Test1-1
๐ป ์ ๋ ฅ
public interface Score {
public int input();
public void print();
}
์ ์ ์
๋ ฅ?32
32์ ์ง์์
๋๋ค.
๐ Note Code
Test1-2
๐ป ์ ๋ ฅ
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
public class ScoreImpl implements Score {
private List<ScoreVO> lists = new ArrayList<ScoreVO>();
//list = ๋ฐฐ์ด๋ง๋๋ ์ธํฐํ์ด์ค - arraylist = ํด๋์ค
// ์๋ input()๋ฉ์๋์ ์๋ฃ๊ณ private๋ก ํด์ ์ง์๊ณต์ ํ๋ ์ด์ : ๋ฉ์๋์์ ๋ฃ์ผ๋ฉด new๊ฐ์ฒด๊ฐ ๊ณ์ ๋ง๋ค์ด์ ธ์ ๊ฐ์ ๋ค๋ฅธ ์ฃผ์๊ฐ ๋จ
@Override
public int input() {
int result = 0;
Scanner sc = new Scanner(System.in);
ScoreVO vo = new ScoreVO(); //input ์คํ ํ ๋๋ง๋ค ํ๋ฒ ์ซ ์ ์ ๋ค ๋ฐ์๋ด๋๊น forํ์์์
System.out.print("ํ๋ฒ?");
vo.setHak(sc.next()); // set์ ์ํด ๊ฐ์ด ๋ค์ด๊ฐ
System.out.print("์ด๋ฆ?");
vo.setName(sc.next());
System.out.print("๊ตญ์ด?");
vo.setKor(sc.nextInt());
System.out.print("์์ด?");
vo.setEng(sc.nextInt());
System.out.print("์ํ?");
vo.setMat(sc.nextInt());
lists.add(vo);
return result;
}
@Override
public void print() {
Iterator<ScoreVO> it = lists.iterator(); //vo์ ๋ฐ์ดํฐ ํ์
= scorevo
//vo = 5๊ฐ ๋ณ์,getter,setter,print
while(it.hasNext()) {
ScoreVO vo = it.next();
System.out.println(vo); //toString์์จ๋ ์ถ๋ ฅ๊ฐ๋ฅ
//System.out.println(vo.toString());
}
}
}
Test1-3
๐ป ์ ๋ ฅ
public class ScoreVO {// Value Object : ์ฌ๊ธฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๊บผ์ผ
//VO๋ฅผ ์ฐ๋ฉด ๋ฐ์ดํฐ์ ์ฅ์
//VO์์ฐ๊ณ DB์ ์ฐ๋ํ๋ฉด -?DTO
private String hak, name;
private int kor;
private int eng;
private int mat;
public String getHak() {
return hak;
}
public void setHak(String hak) {
this.hak = hak;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getKor() {
return kor;
}
public void setKor(int kor) {
this.kor = kor;
}
public int getEng() {
return eng;
}
public void setEng(int eng) {
this.eng = eng;
}
public int getMat() {
return mat;
}
public void setMat(int mat) {
this.mat = mat;
}
@Override //ScoreVO์ ๋ถ๋ชจ - object
public String toString() { //๋ชจ๋ ํ์
์ ๋ค ๋ฌธ์๋ก ๋ณด์ฌ์ค
String str;
//์คํธ๋งํฌ๋งท ? ์ ๋ด์๋จ๋ค๊ฐ ์์๊ฒ ๊พธ๋ฉฐ์ ๋ฆฌํด๊ฐ์ผ๋ก ์ค
str = String.format("%5s %6s %4d %4d %4d %4d %4d",hak,name,
kor,eng,mat,(kor+eng+mat),(kor+eng+mat)/3);
return str;
}
// get/set
}
Test1-5
๐ป ์ ๋ ฅ
import java.util.Scanner;
public class ScoreMain {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//input,print๊ฐ ํด๋์ค๋ผ์ ๊ฐ์ฒด ์์ฑ
//์ธํฐํ์ด์ค - ํด๋์ค
Score ob = new ScoreImpl();
// Score ob = new ScoreImpl();
int ch;
while (true) {
do {
System.out.print("1.์
๋ ฅ? 2.์ถ๋ ฅ 3.์ข
๋ฃ?");
ch = sc.nextInt(); // ์ฌ์ฉํํ
๋ฐ์ ๊ฐ์ ch์ ๋ฐ์๊ฑฐ์ผ
} while (ch < 1); //ch>3์ ์์ด ์ด์ ๋ ์๋ switch๋ฌธ์์ default๊ฐ์ 3๋ฒ ์ดํ์๋ ๋ค ์ข
๋ฃํ ๊ฑฐ๊ธฐ๋๋ฌธ์
switch (ch) {
case 1:
ob.input();
break;
case 2:
ob.print();
break;
default:
System.exit(0);//์๋๋ return์ธ๋ฐ, ์ข
๋ฃ์ํค๊ณ ์ถ์ผ๋๊น - ์๋ฐํ๋ก๊ทธ๋จ ๊ฐ์ ์ข
๋ฃ ๋ช
๋ น์ด
}
}
}
}
1.์
๋ ฅ? 2.์ถ๋ ฅ 3.์ข
๋ฃ?1
ํ๋ฒ?2015
์ด๋ฆ?์์ง
๊ตญ์ด?10
์์ด?20
์ํ?30
1.์
๋ ฅ? 2.์ถ๋ ฅ 3.์ข
๋ฃ?2
2015 ์์ง 10 20 30 60 20
1.์
๋ ฅ? 2.์ถ๋ ฅ 3.์ข
๋ฃ?1
ํ๋ฒ?2015
์ด๋ฆ?์์ธ
๊ตญ์ด?50
์์ด?60
์ํ?70
1.์
๋ ฅ? 2.์ถ๋ ฅ 3.์ข
๋ฃ?2
2015 ์์ง 10 20 30 60 20
2015 ์์ธ 50 60 70 180 60
1.์
๋ ฅ? 2.์ถ๋ ฅ 3.์ข
๋ฃ?