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.μ’
λ£?