API - Object, System, Class, Math, Wrapper
์๋ฐ์์ ์ ๊ณตํ๋ API(Application Programming Interface)์ ๋ํด์ ์์๋ณด์.
API๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ(library)๋ผ๊ณ ๋ถ๋ฅด๊ธฐ๋ ํ๋๋ฐ, ํ๋ก๊ทธ๋จ ๊ฐ๋ฐ์ ์์ฃผ ์ฌ์ฉ๋๋ ํด๋์ค ๋ฐ ์ธํฐํ์ด์ค์ ๋ชจ์์ ๋งํ๋ค. ์ด API๋ <JDK์ค์น๊ฒฝ๋ก>/jre/lib/rt.jar
์ ์ ์ฅ๋์ด์๋ค.
API ๋ํ๋จผํธ๋ ์ฝ๊ฒ API๋ฅผ ์ฐพ์ ์ด์ฉํ ์ ์๋๋ก ๋ฌธ์ํํ ๊ฒ์ ๋งํ๋ค.
java.lang ํจํค์ง
์๋ฐ ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ฐ๋ฐํ ๋ ๊ณตํต์ ์ผ๋ก ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ ํจํค์ง ์ค ํ๋์ด๋ค. java.lang์ ์๋ฐ ํ๋ก๊ทธ๋จ์ ๊ธฐ๋ณธ์ ์ธ ํด๋์ค๋ฅผ ๋ด๊ณ ์๋ ํจํค์ง์ด๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ import๋ฅผ ํ์ง ์๊ณ java.lang ์ํ ํด๋์ค์ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ ์ ์๋ค. (ex) System๊ณผ String
ํด๋์ค
์ฉ๋
Object
์๋ฐ ํด๋์ค์ ์ต์์ ํด๋์ค๋ก ์ฌ์ฉ
System
- ํ์ค ์ ๋ ฅ ์ฅ์น(ํค๋ณด๋)๋ก๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ์ ๋ ์ฌ์ฉ - ํ์ค ์ถ๋ ฅ ์ฅ์น(๋ชจ๋ํฐ)๋ก ์ถ๋ ฅํ๊ธฐ ์ํด ์ฌ์ฉ - ์๋ฐ ๊ฐ์ ๊ธฐ๊ณ๋ฅผ ์ข ๋ฃ์ํฌ ๋ ์ฌ์ฉ - ์ฐ๋ ๊ธฐ ์์ง๊ธฐ๋ฅผ ์คํ ์์ฒญํ ๋ ์ฌ์ฉ
Class
ํด๋์ค๋ฅผ ๋ฉ๋ชจ๋ฆฌ๋ก ๋ก๋ฉํ ๋ ์ฌ์ฉ
Math
์ํ ํจ์๋ฅผ ์ด์ฉํ ๋ ์ฌ์ฉ
Wrapper (Byte, Short, Character, Integer, Float, Double, Boolean, Long)
- ๊ธฐ๋ณธ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๋ ๊ฐ์ฒด๋ฅผ ๋ง๋ค ๋ ์ฌ์ฉ - ๋ฌธ์์ด์ ๊ธฐ๋ณธ ํ์ ์ผ๋ก ๋ณํํ ๋ ์ฌ์ฉ - ์ ๋ ฅ๊ฐ ๊ฒ์ฌ์ ์ฌ์ฉ
Object ํด๋์ค
ํด๋์ค ์ ์ธ์ extends
ํค์๋๋ก ๋ค๋ฅธ ํด๋์ค๋ฅผ ์์ํ์ง ์์ผ๋ฉด ์์์ ์ผ๋ก java.lang.Object ํด๋์ค๋ฅผ ์์ํ๊ฒ ๋๋ค. ์ฆ, ์๋ฐ์ ๋ชจ๋ ํด๋์ค๋ Object ํด๋์ค์ ์์์ด๊ฑฐ๋ ์์ ํด๋์ค์ด๋ค. Object๋ ์๋ฐ์ ์ต์์ ๋ถ๋ชจ ํด๋์ค์ ํด๋น๋๋ค.

๊ฐ์ฒด ๋น๊ต(equals())
public boolean equals(Object obj){...}
๋งค๊ฐ ํ์ ์ด Object์ด๋ฏ๋ก ๋ชจ๋ ๊ฐ์ฒด๊ฐ ๋์ ๋ ์ ์์์ ์ ์ ์๋ค.(์๋ ํ์ ๋ณํ) ๋ ๊ฐ์ฒด๊ฐ ๋์ผํ ๊ฐ์ฒด๋ผ๋ฉด true, ์๋๋ผ๋ฉด false๋ฅผ ๋ฆฌํดํ๋ค. ์ฌ๊ธฐ์ equals๋ ๋ ผ๋ฆฌ์ ์ผ๋ก ๋๋ฑํ๋ฉด true๋ฅผ ๋ฆฌํดํ๋ค. ์ฌ๊ธฐ์ ๋ ผ๋ฆฌ์ ์ผ๋ก ๋๋ฑํ๋ค๋ ๊ฒ์ ๊ฐ์ ๊ฐ์ฒด์ด๊ฑด ๋ค๋ฅธ ๊ฐ์ฒด์ด๊ฑด ์๊ด์์ด ๊ฐ์ฒด๊ฐ ์ ์ฅํ๊ณ ์๋ ๋ฐ์ดํฐ๊ฐ ๋์ผํจ์ ๋ปํ๋ค. ์ด ๋ฉ์๋๋ ์ง์ ์ฌ์ฉ๋์ง ์๊ณ ํ์ ํด๋์ค์์ ์ฌ์ ์ํ์ฌ ๋ ผ๋ฆฌ์ ์ผ๋ก ๋๋ฑ ๋น๊ตํ ๋ ์ด์ฉ๋๋ค.
equals() ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ ๋๋ ๋งค๊ฐ๊ฐ(๋น๊ต ๊ฐ์ฒด)์ด ๊ธฐ์ค ๊ฐ์ฒด์ ๋์ผํ ํ์
์ ๊ฐ์ฒด์ธ์ง ๋จผ์ ํ์ธํด์ผํ๋ค.(instanceof
) ๋น๊ต ๊ฐ์ฒด๊ฐ ๋ค๋ฅธ ํ์
์ด๋ผ๋ฉด false๋ฅผ ๋ฆฌํดํ๋ค.
public class Member{
public String id;
public Member(String id){
this.id = id;
}
@Override
public boolean equals(Object obj){
if(obj instanceof Member){
Member member = (Member)obj;
if(id.equals(memeber.id)){
return true;
}
}
return false;
}
}
๊ฐ์ฒด ํด์์ฝ๋(hashCode())
๊ฐ์ฒด ํด์์ฝ๋๋ ๊ฐ์ฒด๋ฅผ ์๋ณํ ํ๋์ ์ ์๊ฐ์ ๋งํ๋ค. ๊ฐ์ฒด์ ๋ฉ๋ชจ๋ฆฌ ๋ฒ์ง๋ฅผ ์ด์ฉํด์ ํด์์ฝ๋๋ฅผ ๋ง๋ค์ด ๋ฆฌํดํ๊ธฐ ๋๋ฌธ์ ๊ฐ์ฒด๋ง๋ค ๋ค๋ฅธ ๊ฐ์ ๊ฐ์ง๊ณ ์๋ค. ๋ ผ๋ฆฌ์ ๋๋ฑ ๋น๊ต์ hashCode()๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉ ํ ํ์์ฑ์ด ์๋ค.
hashCod() ๋ฆฌํด๊ฐ ๋น๊ต
๊ฐ์ : equals() ๋ฆฌํด๊ฐ ๋น๊ต
๊ฐ์ : ๋๋ฑ ๊ฐ์ฒด
๋ค๋ฆ : ๋ค๋ฅธ ๊ฐ์ฒด
๋ค๋ฆ : ๋ค๋ฅธ ๊ฐ์ฒด
๊ฐ์ฒด ๋ฌธ์ ์ ๋ณด(toString())
๊ฐ์ฒด์ ๋ฌธ์ ์ ๋ณด๋ฅผ ๋ฆฌํดํ๋ค. ๊ฐ์ฒด์ ๋ฌธ์ ์ ๋ณด๋ ๊ฐ์ฒด๋ฅผ ๋ฌธ์์ด๋ก ํํํ ๊ฐ์ ๋งํ๋ค. ๊ธฐ๋ณธ์ ์ผ๋ก Object ํด๋์ค์ toString()์ "ํด๋์ค๋ช @16์ง์ํด์์ฝ๋"๋ก ๊ตฌ์ฑ๋ ๋ฌธ์์ ๋ณด๋ฅผ ๋ฆฌํดํ๋ค.
Object obj = new Object();
System.out.println(obj.toString());
//java.lang.Object@de6ced
์ด ๋ฆฌํด๊ฐ์ ๋ณ ๊ฐ์ด์น๊ฐ ์๋ ์ ๋ณด์ด๋ฏ๋ก Object ํ์ ํด๋์ค๋ toString() ๋ฉ์๋๋ฅผ ์ฌ์ ์(์ค๋ฒ๋ผ์ด๋ฉ) ํ์ฌ ๊ฐ๊ฒฐํ๊ณ ์ ์ตํ ์ ๋ณด๋ฅผ ๋ฆฌํดํ๋๋ก ๋์ด์๋ค.
java.util.Date : ํ์ฌ ์์คํ ์ ๋ ์ง์ ์๊ฐ ์ ๋ณด๋ฅผ ๋ฆฌํด
String : ์ ์ฅํ๊ณ ์๋ ๋ฌธ์์ด ๋ฆฌํด
๊ฐ์ฒด ๋ณต์ (clone())
๊ฐ์ฒด ๋ณต์ ๋ ์๋ณธ ๊ฐ์ฒด์ ํ๋๊ฐ๊ณผ ๋์ผํ ๊ฐ์ ๊ฐ์ง๋ ์๋ก์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ ๊ฒ์ ๋งํ๋ค. ๊ฐ์ฒด๋ฅผ ๋ณต์ ํ๋ ์ด์ ๋ ์๋ณธ ๊ฐ์ฒด๋ฅผ ์์ ํ๊ฒ ๋ณดํธํ๊ธฐ ์ํด์์ด๋ค. ์ ๋ขฐํ์ง ์๋ ์์ญ์ผ๋ก ์๋ณธ ๊ฐ์ฒด๋ฅผ ๋๊ฒจ ์์ ํ ๊ฒฝ์ฐ ์๋ณธ ๊ฐ์ฒด์ ๋ฐ์ดํฐ๊ฐ ํผ์๋ ์ ์๋ค. ๊ทธ๋ฌ๋ฏ๋ก ๋ณต์ ๋ ๊ฐ์ฒด์ ๋ฐ์ดํฐ๊ฐ ํผ์๋๋๋ผ๋ ์๋ณธ ๊ฐ์ฒด๋ ์๋ฌด๋ฐ ์ํฅ์ ๋ฐ์ง ์๊ธฐ ๋๋ฌธ์ ์์ ํ๊ฒ ๋ฐ์ดํฐ๋ฅผ ๋ณดํธํ ์ ์๊ฒ ๋๋ค.
์์ ๋ณต์ (this clone) : ๋จ์ํ ํ๋๊ฐ์ ๋ณต์ฌํด์ ๊ฐ์ฒด๋ฅผ ๋ณต์ ํ๋ ๊ฒ์ ๋งํ๋ค.
๊ธฐ๋ณธ ํ์ : ๊ฐ ๋ณต์ฌ
์ฐธ์กฐ ํ์ : ๊ฐ์ฒด์ ๋ฒ์ง ๋ณต์ฌ
Object์ clone()๋ฉ์๋๋ ์์ ๊ณผ ๋์ผํ ํ๋๊ฐ์ ๊ฐ์ง ์์ ๋ณต์ ๋ ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํ๋ค. ์ด ๋ฉ์๋๋ก ๋ณต์ ๋ฅผ ํ๋ ค๋ฉด ์๋ณธ ๊ฐ์ฒด๋ ๋ฐ๋์
java.lang.Cloneable
์ธํฐํ์ด์ค๋ฅผ ๊ฐ์ง๊ณ ์์ด์ผํ๋ค. ๋ฉ์๋ ์ ์ธ์ด ์์์๋ ๋ถ๊ตฌํ๊ณ Cloneable ์ธํฐํ์ด์ค๋ฅผ ๋ช ์์ ์ผ๋ก ๊ตฌํํ๋ ์ด์ ๋ ํด๋์ค ์ค๊ณ์๊ฐ ๋ณต์ ๋ฅผ ํ์ฉํ๋ค๋ ์๋์ ์ธ ํ์๋ฅผ ํ๊ธฐ ์ํด์์ด๋ค.Cloneable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ์ง ์์ผ๋ฉด
CloneNotSupportedException
์์ธ๊ฐ ๋ฐ์ํ์ฌ ๋ณต์ ๊ฐ ์คํจ๋๋ค. clone()์ ์์ธ์ฒ๋ฆฌ๊ฐ ํ์ํ ๋ฉ์๋ ์ด๋ฏ๋กtry-catch
๊ตฌ๋ฌธ์ด ํ์ํ๋ค.try{ Object obj = clone(); }catch(CloneNotSupportedException e){}
public class Member implements Cloneable{ public String id; public String name; public String passwd; public int age; public boolean adult; public Member(String id, String name, String passwd, int age, boolean adult){ this.id = id; this.name = name; this.passwd = passwd; this.age = age; this.adult = adult; } public Member getMember(){ Member cloned = null; try{ cloned = (Member)clone(); //clone()๋ฉ์๋์ ๋ฆฌํดํ์ ์ Object์ด๋ฏ๋ก Memberํ์ ์ผ๋ก casting }catch(CloneNotSupportedException e){} return cloned; } }
โ
๊น์ ๋ณต์ (deep clone) : ์์ ๋ณต์ ์ ์ฐธ์กฐ ํ์ ํ๋๋ ๋ฒ์ง๋ง ๋ณต์ ๋๊ธฐ ๋๋ฌธ์ ์๋ณธ ๊ฐ์ฒด์ ํ๋์ ๋ณต์ ๊ฐ์ฒด์ ํ๋๋ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ฒ ๋๋ค. ๋ง์ฝ ๋ณต์ ๊ฐ์ฒด์์ ์ฐธ์กฐ ๊ฐ์ฒด๋ฅผ ๋ณ๊ฒฝํ๋ฉด ์๋ณธ ๊ฐ์ฒด๋ ๋ณ๊ฒฝ๋ ๊ฐ์ฒด๋ฅผ ๊ฐ์ง๊ฒ ๋๋ค. ๊น์ ๋ณต์ ๋ ์ฐธ์กฐํ๊ณ ์๋ ๊ฐ์ฒด๋ ๋ณต์ ํ๋ ๊ฒ์ ๋งํ๋ค.
๊น์ ๋ณต์ ๋ฅผ ํ๋ ค๋ฉด Object clone()๋ฉ์๋๋ฅผ ์ฌ์ ์ํด์ ์ฐธ์กฐ ๊ฐ์ฒด๋ฅผ ๋ณต์ ํ๋ ์ฝ๋๋ฅผ ์ง์ ์์ฑํด์ผํ๋ค.
public class Member implements Cloneable{ public String name; public int age; // ์๋ ๋๊ฐ ์ฐธ์กฐ ํ์ ํ๋ public int[] scores; public Car car; public Member(String name, int age,int[] scores, Car car){ this.name = name; this.age = age; this.scores = scores; this.car = car; } @Override protected Object clone() throws CloneNotSupportedException{ Member cloned = (Member)super.clone(); cloned.scores = Arrays.copyOf(this.scores, this.scores.length); cloned.car = new Car(this.car.model); return cloned; } public Member getMember(){ Member cloned = null; try{ cloned = (Member)clone(); //clone()๋ฉ์๋์ ๋ฆฌํดํ์ ์ Object์ด๋ฏ๋ก Memberํ์ ์ผ๋ก casting }catch(CloneNotSupportedException e){ e.printStackTrace(); } return cloned; } }
๊ฐ์ฒด ์๋ฉธ์(finalize())
์ฐธ์กฐํ์ง ์๋ ๋ฐฐ์ด์ด๋ ๊ฐ์ฒด๋ Garbage Collector๊ฐ ํ ์์ญ์์ ์๋์ผ๋ก ์๋ฉธ์ํจ๋ค. Garbage Collector๋ ๊ฐ์ฒด๋ฅผ ์๋ฉธํ๊ธฐ ์ง์ ์ ๋ง์ง๋ง์ผ๋ก ๊ฐ์ฒด์ ์๋ฉธ์(finalize())๋ฅผ ์คํ์ํจ๋ค. finalize()๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์คํ ๋ด์ฉ์ด ์๋ค. ๋ง์ฝ ๊ฐ์ฒด๊ฐ ์๋ฉธ๋๊ธฐ ์ ์ ๋ง์ง๋ง์ผ๋ก ์ฌ์ฉํ๋ ์์(๋ฐ์ดํฐ ์ฐ๊ฒฐ, ํ์ผ ๋ฑ)์ ๋ซ๊ณ ์ถ๊ฑฐ๋, ์ค์ํ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ์ถ๋ค๋ฉด ์ฌ์ ์๋ฅผ ํ ์ ์๋ค.
public class Counter{
private int no;
public Counter(int no){
this.no = no;
}
@Override
protected void finalize() throws Throwable{
System.out.println(no + "๋ฒ ๊ฐ์ฒด์ finalize()๊ฐ ์คํ๋จ")
}
}
public class FinalizeEx{
public static void main(String[] args){
Counter counter = null;
for(int i=1;i<=50;i++){
counter = new Counter(i);
counter = null; //์ฐ๋ ๊ธฐ๋ก ๋ง๋ฌ
System.gc(); //Garbage Collector ์คํ ์์ฒญ
}
}
}
์คํ ๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด ๋ฌด์์๋ก ์๋ฉธ์ํค๋ ๊ฒ์ ๋ณผ ์ ์๋ค. ๊ทธ๋ฆฌ๊ณ ์ ๋ถ ์๋ฉธ์ํค๋ ๊ฒ์ด ์๋๋ผ ๋ฉ๋ชจ๋ฆฌ ์ํ๋ฅผ ๋ณด๊ณ ์ผ๋ถ๋ง ์๋ฉธ์ํจ๋ค.( ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ ๋, CPU๊ฐ ํ๊ฐํ ๋ JVM์ ์ํด์ ์๋ ์คํ)
finalize()๋ฉ์๋๊ฐ ํธ์ถ๋๋ ์์ ์ ๋ช ํํ์ง ์๋ค. ๋ง์ฝ ํ๋ก๊ทธ๋จ ์ข ๋ฃ์ ์ฆ์ ์์์ ํด์ ํ๊ฑฐ๋ ์ฆ์ ๋ฐ์ดํฐ๋ฅผ ์ต์ข ์ ์ฅํด์ผ ํ๋ค๋ฉด, ์ผ๋ฐ ๋ฉ์๋์์ ์์ฑํ๊ณ ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋ ๋ ๋ช ์์ ์ผ๋ก ๋ฉ์๋๋ฅผ ํธ์ถํ๋ ๊ฒ์ด ์ข๋ค.
System ํด๋์ค
์๋ฐ ํ๋ก๊ทธ๋จ์ ์ด์์ฒด์ ์์์ ๋ฐ๋ก ์คํ๋๋ ๊ฒ์ด ์๋๋ผ JVM์์์ ์คํ๋๋ค. ๋ฐ๋ผ์ ์ด์์ฒด์ ์ ๋ชจ๋ ๊ธฐ๋ฅ์ ์๋ฐ ์ฝ๋๋ก ์ง์ ์ ๊ทผํ๊ธฐ ์ด๋ ต๋ค. ํ์ง๋ง java.lang.System ํด๋์ค๋ฅผ ์ด์ฉํ๋ฉด ์ด์์ฒด์ ์ ์ผ๋ถ ๊ธฐ๋ฅ์ ์ด์ฉํ ์ ์๋ค.
์ฆ, ํ๋ก๊ทธ๋จ ์ข ๋ฃ, ํค๋ณด๋๋ก ์ ๋ ฅ, ๋ชจ๋ํฐ๋ก ์ถ๋ ฅ, ๋ฉ๋ชจ๋ฆฌ ์ ๋ฆฌ, ํ์ฌ์๊ฐ ์ฝ๊ธฐ, ์์คํ ํ๋กํผํฐ ์ฝ๊ธฐ, ํ๊ฒฝ ๋ณ์ ์ฝ๊ธฐ ๋ฑ์ด ๊ฐ๋ฅํ๋ค. System ํด๋์ค์ ๋ชจ๋ ํ๋์ ๋ฉ์๋๋ ์ ์ (static)์ผ๋ก ๊ตฌ์ฑ๋์ด์๋ค.
ํ๋ก๊ทธ๋จ ์ข
๋ฃ(exit())
๊ฒฝ์ฐ์ ๋ฐ๋ผ์ ๊ฐ์ ์ ์ผ๋ก JVM์ ์ข ๋ฃ์ํฌ ๋ ์ฌ์ฉํ๋ค. ์ฆ, ํ์ฌ ์คํํ๊ณ ์๋ ํ๋ก์ธ์ค๋ฅผ ๊ฐ์ ์ข ๋ฃ์ํค๋ ์ญํ ์ ํ๋ค.
exit()๋ฉ์๋๋ int ๋งค๊ฐ๊ฐ์ ์ง์ ํ๋๋ก ๋์ด์๋๋ฐ, ์ด ๊ฐ์ ์ข ๋ฃ ์ํ๊ฐ์ด๋ผ๊ณ ํ๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ ์ ์ข ๋ฃ์ผ ๊ฒฝ์ฐ 0, ๋น์ ์ ์ข ๋ฃ์ผ ๊ฒฝ์ฐ 0์ด์ธ์ ์๋ฅผ ์ค๋ค.
System.exit(0);
์ด๋ค ๊ฐ์ ์ฃผ๋๋ผ๋ ์ข ๋ฃ๊ฐ ๋๋๋ฐ, ๋ง์ฝ ํน์ ๊ฐ์ด ์ ๋ ฅ๋์์ ๊ฒฝ์ฐ์๋ง ์ข ๋ฃํ๊ณ ์ถ๋ค๋ฉด ์๋ฐ์ ๋ณด์ ๊ด๋ฆฌ์๋ฅผ ์ง์ ์ค์ ํด์ ์ข ๋ฃ ์ํ๊ฐ์ ํ์ธํ๋ฉด๋๋ค.
System.exit()๊ฐ ์คํ๋๋ฉด ๋ณด์ ๊ด๋ฆฌ์์ checkExit()
๋ฉ์๋๊ฐ ์๋ ํธ์ถ๋๋๋ฐ, ์ด ๋ฉ์๋์์ ์ข
๋ฃ ์ํ๊ฐ์ ์กฐ์ฌํด์ ํน์ ๊ฐ์ด ์
๋ ฅ๋์ง ์์ผ๋ฉด SecurityException์ ๋ฐ์์์ผ ์์ธ์ฒ๋ฆฌ๋ฅผ ํ ์ ์๋๋ก ํด์ค๋ค. checkExit()๊ฐ ์ ์์ ์ผ๋ก ์คํ๋๋ฉด JVM์ ์ข
๋ฃ๋๋ค.
//์์
System.setSecurityManager(new SecurityManager(){
@Override
public void checkExit(int status){
if(status != 5){
throw new SecurityException();
}
}
});
์ฐ๋ ๊ธฐ ์์ง๊ธฐ ์คํ(gc())
์๋ฐ๋ ๊ฐ๋ฐ์๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ง์ ์ฝ๋๋ก ๊ด๋ฆฌํ์ง ์๊ณ JVM์ด ์์์ ์๋์ผ๋ก ๊ด๋ฆฌํ๋ค. JVM์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ ๋์ CPU๊ฐ ํ๊ฐํ ๋์ Garbage Collector๋ฅผ ์คํ์์ผ ์ฌ์ฉํ์ง ์๋ ๊ฐ์ฒด๋ฅผ ์๋ ์ ๊ฑฐํ๋ค.
GC๋ ๊ฐ๋ฐ์๊ฐ ์ง์ ์ฝ๋๋ก ์คํ์ํฌ ์ ์๊ณ , JVM์๊ฒ ๊ฐ๋ฅํํ ๋นจ๋ฆฌ ์คํํด๋ฌ๋ผ๊ณ ์์ฒญํ ์ ์๋ค. ์ด๊ฒ์ด System.gc()๋ฉ์๋์ด๋ค.
์ฆ, System.gc() ๋ฉ์๋๊ฐ ํธ์ถ๋๋ฉด GC๊ฐ ๋ฐ๋ก ์คํ๋๋ ๊ฒ์ ์๋๊ณ , JVM์ ๋น ๋ฅธ ์๊ฐ ๋ด์ ์คํ์ํค๊ธฐ ์ํด ๋ ธ๋ ฅํ๋ค.
System.gc();
์ฐ๋ ๊ธฐ๊ฐ ์๊ธธ ๋๋ง๋ค GC๊ฐ ๋์ํ๋ค๋ฉด ์ ์ ์ํ๋์ด์ผ ํ ํ๋ก๊ทธ๋จ์ ์๋๊ฐ ๋จ์ด์ง๊ธฐ ๋๋ฌธ์ ์ฑ๋ฅ ์ธก๋ฉด์์ ์ข์ง์๋ค. ๊ทธ๋ฆฌ๊ณ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ถฉ๋ถํ๋ค๋ฉด ๊ตณ์ด GC๋ฅผ ์คํํ ํ์๊ฐ ์๋ค.
//์์
public class GcEx{
public static void main(String[] args){
Employee emp;
emp = new Employee(1);
emp = null; //์ฐ๋ ๊ธฐ๊ฐ๋จ
emp = new Employee(2);
emp = new Employee(3); // Employee(2)์ฐ๋ ๊ธฐ
System.out.println("emp๊ฐ ์ต์ข
์ ์ผ๋ก ์ฐธ์กฐํ๋ ์ฌ์๋ฒํธ : ");
System.out.println(emp.eno);
System.gc();
}
}
class Employee{
public int eno;
public Employee(int eno){
this.eno = eno;
system.out.prinlnt("Employee"+eno+" ๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ์์ฑ๋จ");
}
// ์๋ฉธ์
public void finalize(){
System.out.println("Employee"+eno+์ด ๋ฉ๋ชจ๋ฆฌ์์ ์ ๊ฑฐ๋จ);
}
}
ํ์ฌ ์๊ฐ ์ฝ๊ธฐ(currentTimeMillis(), nanoTime())
์ปดํจํฐ์ ์๊ณ๋ก๋ถํฐ ํ์ฌ ์๊ฐ์ ์ฝ์ด์ ๋ฐ๋ฆฌ์ธ์ปจ๋(1/1000์ด)๋จ์์ ๋๋ ธ์ธ์ปจ๋(1/10^9์ด)๋จ์์ long๊ฐ์ ๋ฆฌํดํ๋ค.
long time = System.currentTimeMillis();
long time = System.nanoTime();
๋ฆฌํด ๊ฐ์ ์ฃผ๋ก ํ๋ก๊ทธ๋จ ์คํ ์์ ์๊ฐ ์ธก์ ์ ์ฌ์ฉ๋๋ค. ํ๋ก๊ทธ๋จ ์์ ์ ์๊ฐ์ ์ฝ๊ณ , ํ๋ก๊ทธ๋จ์ด ๋๋ ๋ ์๊ฐ์ ์ฝ์ด์ ์ฐจ์ด๋ฅผ ๊ตฌํ๋ฉด ํ๋ก๊ทธ๋จ ์คํ ์์ ์๊ฐ์ด ๋์จ๋ค.
์์คํ
ํ๋กํผํฐ ์ฝ๊ธฐ(getProperty())
์์คํ ํ๋กํผํฐ๋ JVM์ด ์์๋ ๋ ์๋ ์ค์ ๋๋ ์์คํ ์ ์์ฑ๊ฐ์ ๋งํ๋ค. ์๋ฅผ ๋ค์ด ์ด์์ฒด์ ์ ์ข ๋ฅ, ์๋ฐ ํ๋ก๊ทธ๋จ์ ์คํ์ํจ ์ฌ์ฉ์ ์์ด๋, JVM ๋ฒ์ ๋ฑ๋ฑ์ด ์ฌ๊ธฐ์ ์ํ๋ค. ์์คํ ํ๋กํผํฐ๋ ํค(key)์ ๊ฐ(value)๋ก ๊ตฌ์ฑ๋์ด์๋ค.
key
์ค๋ช
value
java.version
์๋ฐ ๋ฒ์
1.8.0_20
java.home
์ฌ์ฉํ๋ JRE ํ์ผ ๊ฒฝ๋ก
<jdk ์ค์น๊ฒฝ๋ก>/jre
os.name
์ด์์ฒด์ ์ด๋ฆ
Mac OS X
file.separator
File separaotr("/" on UNIX)
null
user.name
์ฌ์ฉ์ ์ด๋ฆ
์ฌ์ฉ์ ๊ณ์
user.home
์ฌ์ฉ์ ํ ๋๋ ํ ๋ฆฌ
/Users/์ฌ์ฉ์๊ณ์
user.dir
์ฌ์ฉ์๊ฐ ํ์ฌ ์์ ์ค์ธ ๊ฒฝ๋ก
์์ ์ค์ธ ๊ฒฝ๋ก
์์คํ
ํ๋กํผํฐ๋ฅผ ์ฝ์ด์ค๊ธฐ ์ํด์ System.getProperty()
๋ฅผ ์ด์ฉํ๋ฉด๋๋ค. ์ด ๋ฉ์๋๋ ํค์ด๋ฆ์ ๋งค๊ฐ๊ฐ์ผ๋ก ๋ฐ๊ณ , ํด๋น ํค์ ๋ํ ๊ฐ์ ๋ฌธ์์ด๋ก ๋ฆฌํดํ๋ค.
String value = System.getProperty(String key);
System.getProperties()๋ ๋ชจ๋ (ํค, ๊ฐ)์์ ์ ์ฅํ๊ณ Properties ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํ๋ค. ์ด ๊ฐ์ฒด์ keySet() ๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด ํค๋ง์ผ๋ก ๊ตฌ์ฑ๋ set๊ฐ์ฒด๋ฅผ ์ป์ ์ ์๋ค.
Properties props = System.getProperties();
Set keys = props.keySet();
ํ๊ฒฝ ๋ณ์ ์ฝ๊ธฐ(getenv())
๋๋ถ๋ถ ์ด์์ฒด์ ๋ ์คํ๋๋ ํ๋ก๊ทธ๋จ๋ค์๊ฒ ์ ์ฉํ ์ ๋ณด๋ฅผ ์ ๊ณตํ ๋ชฉ์ ์ผ๋ก ํ๊ฒฝ ๋ณ์(Environment Variable)๋ฅผ ์ ๊ณตํ๋ค. ํ๊ฒฝ ๋ณ์๋ ํ๋ก๊ทธ๋จ์์ ๋ณ์๊ฐ ์๋๋ผ ์ด์์ฒด์ ์์ ์ด๋ฆ๊ณผ ๊ฐ์ผ๋ก ๊ด๋ฆฌ๋๋ ๋ฌธ์์ด ์ ๋ณด๋ค. ํ๊ฒฝ๋ณ์๋ ์ด์์ฒด์ ๊ฐ ์ค์น๋ ๋ ๊ธฐ๋ณธ์ ์ธ ๋ด์ฉ์ด ์ค์ ๋๊ณ , ์ฌ์ฉ์๊ฐ ์ง์ ์ค์ ํ๊ฑฐ๋ ์์ฉ ํ๋ก๊ทธ๋จ์ด ์ค์น๋ ๋ ์๋์ ์ผ๋ก ์ถ๊ฐ ์ค์ ๋๊ธฐ๋ ํ๋ค.
String value = System.getenv(String name);
//์์
public class SystemEnvEx{
public static void main(String[] args){
String javaHome = System.getenv("JAVA_HOME");
System.out.println(javaHome);
}
}
Class ํด๋์ค
ํด๋์ค์ ์ธํฐํ์ด์ค์ ๋ฉํ ๋ฐ์ดํฐ(ํด๋์ค ์ด๋ฆ, ์์ฑ์ ์ ๋ณด, ํ๋ ์ ๋ณด, ๋ฉ์๋ ์ ๋ณด)๋ฅผ ๊ด๋ฆฌํ๋ ํด๋์ค์ด๋ค.
Class ๊ฐ์ฒด ์ป๊ธฐ(getClass(), forName())
Object๋ ๋ชจ๋ ํด๋์ค์ ์ต์์ ํด๋์ค์ด๋ฏ๋ก ๋ชจ๋ ํด๋์ค์์ getClass() ๋ฉ์๋๋ฅผ ํธ์ถํ ์ ์๋ค.
Class c = obj.getClass();
getClass() ๋ฉ์๋๋ ํด๋น ํด๋์ค๋ก ๊ฐ์ฒด๋ฅผ ์์ฑํ์ ๋๋ง ์ฌ์ฉํ ์ ์๋๋ฐ, ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ธฐ ์ ์ ์ง์ Class ๊ฐ์ฒด๋ฅผ ์ป์ ์๋ ์๋ค. Class๋ ์์ฑ์๋ฅผ ๊ฐ์ถ๊ณ ์๊ธฐ ๋๋ฌธ์ new์ฐ์ฐ์๋ก ๊ฐ์ฒด๋ฅผ ๋ง๋ค ์ ์์ผ๋ฉฐ, ์ ์ (static) ๋ฉ์๋์ธ forName()์ ์ด์ฉํด์ผํ๋ค.
try{
Class c = Class.forName(String className);
}catch(ClassNotFoundException e){
}
forName() ๋ฉ์๋๋ ํด๋์ค ์ ์ฒด ์ด๋ฆ(ํจํค์ง๊ฐ ํฌํจ๋ ์ด๋ฆ)์ ๋งค๊ฐ๊ฐ์ผ๋ก ๋ฐ๊ณ Class ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํ๋ค.
//์์
public class ClassEx{
public static void main(String[] args){
Car car = new Car();
Class c = car.getClass();
System.out.println(c.getName());
System.out.println(c.getSimpleName());
System.out.println(c.getPackage().getName();
try{
Class c2 = Class.forName("sec06.exam_class.Car");
System.out.println(c2.getName());
System.out.println(c2.getSimpleName());
System.out.println(c.getPackage().getName());
}catch(ClassNotFoundException e){
e.printStackTrace();
}
}
}
Reflection(getDeclaredConstructors(), getDeclaredFields(), getDeclaredMethods())
Reflection์ Class ๊ฐ์ฒด๋ฅผ ์ด์ฉํด ํด๋์ค์ ์์ฑ์, ํ๋, ๋ฉ์๋ ์ ๋ณด๋ฅผ ์์๋ด๋ ๊ฒ์ ๋งํ๋ค.
Constructor[] constructors = c.getDeclaredConstructors();
Field fields = c.getDeclaredFields();
Method[] methods = c.getDeclaredMethods();
๊ฐ๊ฐ Constructor ๋ฐฐ์ด, Field ๋ฐฐ์ด, Method ๋ฐฐ์ด์ ๋ฆฌํดํ๋ค. Constructor, Field, Method ํด๋์ค๋ ๋ชจ๋ java.lang.reflect
ํจํค์ง์ ์์๋์ด ์๋ค. ์ฌ๊ธฐ์ getDeclaredFields()์ getDeclaredMethods()๋ ํด๋์ค์ ์ ์ธ๋ ๋ฉค๋ฒ๋ง ๊ฐ์ ธ์ค๊ณ ์์๋ ๋ฉค๋ฒ๋ ๊ฐ์ ธ์ค์ง ์๋๋ค. ์์๋ ๋ฉค๋ฒ๋ ๊ฐ์ ธ์ค๊ณ ์ถ๋ค๋ฉด getFields(), getMethods()๋ฅผ ์ด์ฉํด์ผํ๋ค. ๋จ, public ๋ฉค๋ฒ๋ง ๊ฐ์ ธ์จ๋ค.
//์์
public class ReflectEx{
public static void main(String[] args){
Class c = Class.forName("sec06.exam_reflect.Car");
System.out.println("ํด๋์ค์ด๋ฆ"+c.getName());
System.out.println("์์ฑ์ ์ ๋ณด");
Constructor constructors = c.getDeclaredConstructors();
for(Constructor constructor : constructors){
System.out.println(constructor.getName()+"(");
Class[] params = constructors.getParameterTypes();
printParameters(params);
System.out.println(")");
}
System.out.println("ํ๋ ์ ๋ณด");
Field[] fields = c.getDeclaredFields();
for(Field f: fields){
System.out.println(f.getType().getSimpleNmae()+" "+ f.getName());
}
System.out.println("๋ฉ์๋ ์ ๋ณด");
Method[] methods = c.getDeclaredMethods();
for(Method m : methods){
System.out.println(m.getName()+"(");
Class[] params = m.getParameterTypes();
printParameters(params);
System.out.println(")");
}
private static void printParameters(Class[] params){
for(int i=0;i<params.length;i++){
System.out.print(params[i].getName());
if(i<params.length-1){
System.out.print(", ");
}
}
}
}
}
์คํ ๊ฒฐ๊ณผ๋ Car ํด๋์ค๊ฐ ๊ฐ์ง๊ณ ์๋ ์ ์ฒด ๋ฉค๋ฒ๋ค์ด ๋ชจ๋ ์ถ๋ ฅ๋๋ค.
๋์ ๊ฐ์ฒด ์์ฑ(newInstance())
Class ๊ฐ์ฒด๋ฅผ ์ด์ฉํ๋ฉด new ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ง ์์๋ ๋์ ์ผ๋ก ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค. ์ด ๋ฐฉ๋ฒ์ ๋ฐํ์ ์์ ํด๋์ค ์ด๋ฆ์ด ๊ฒฐ์ ๋๋ ๊ฒฝ์ฐ์ ๋งค์ฐ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋๋ค.
try{
Class c = Class.forName("๋ฐํ์ ์ ๊ฒฐ์ ๋๋ ํด๋์ค ์ด๋ฆ");
Object obj = c.newInstance();
}catch(ClassNotFoundException e){
}catch(InstantiationException e){
}catch(IllegalAccessException e){
}
newInstance() ๋ฉ์๋๋ ๊ธฐ๋ณธ ์์ฑ์๋ฅผ ํธ์ถํด์ ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ธฐ ๋๋ฌธ์ ๋ฐ๋์ ํด๋์ค์ ๊ธฐ๋ณธ ์์ฑ์๊ฐ ์กด์ฌํด์ผํ๋ค. ๋ง์ฝ ๋งค๊ฐ๋ณ์๊ฐ ์๋ ์์ฑ์๋ฅผ ํธ์ถํ๊ณ ์ถ์ผ๋ฉด Constructor ๊ฐ์ฒด๋ฅผ์ป์ด newInstance()๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด๋๋ค.
InstantiationException์ ํด๋น ํด๋์ค๊ฐ ์ถ์ ํด๋์ค์ด๊ฑฐ๋ ์ธํฐํ์ด์ค์ผ ๊ฒฝ์ฐ์ ๋ฐ์ํ๊ณ , IllegalAccessException์ ํด๋์ค๋ ์์ฑ์๊ฐ ์ ๊ทผ ์ ํ์๋ก ์ธํด ์ ๊ทผํ ์ ์๋ ๊ฒฝ์ฐ์ ๋ฐ์ํ๋ค.
newInstance() ๋ฉ์๋์ ๋ฆฌํด ํ์ ์ Object์ด๋ฏ๋ก ์๋ ํด๋์ค ํ์ ์ผ๋ก ๋ณํํด์ผ๋ง ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์๋ค. ํ์ง๋ง ํด๋์ค ํ์ ์ ๋ชจ๋ฅด๋ ์ํ์ด๋ฏ๋ก ๊ฐ์ ํ์ ๋ณํ์ ํ ์ ์๋ค. ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์ ์ธํฐํ์ด์ค๊ฐ ํ์ํ๋ค.

public interface Action {
public void execute();
}
public class ReceiveAction implements Action {
@Override
public void execute() {
System.out.println("๋ฐ์ดํฐ๋ฅผ ๋ฐ์ต๋๋ค..");
}
}
public class SendAction implements Action {
@Override
public void execute() {
System.out.println("๋ฐ์ดํฐ๋ฅผ ๋ณด๋
๋๋ค.");
}
}
public class Main {
public static void main(String[] args) {
try {
// Class c = Class.forName("SendAction");
Class c = Class.forName("ReceiveAction");
Action action = (Action)c.newInstance();
action.execute();
}catch(ClassNotFoundException e){
e.printStackTrace();
}catch(InstantiationException e){
e.printStackTrace();
}catch(IllegalAccessException e){
e.printStackTrace();
}
}
}
forName()๋ฉ์๋ ๋งค๊ฐ๊ฐ์ผ๋ก ์ฃผ์ด์ง ํด๋์ค์ execute()๊ฐ ์คํ๋๋ ๊ฒ์ ์ ์ ์๋ค.
Wrapper(ํฌ์ฅ) ํด๋์ค
์๋ฐ๋ ๊ธฐ๋ณธ ํ์ (byte, char, short, int ,long, float, double, boolean)์ ๊ฐ์ ๊ฐ๋ ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค. ์ด๋ฐ ๊ฐ์ฒด๋ฅผ Wrapper ๊ฐ์ฒด๋ผ ํ๋ค. ๊ทธ ์ด์ ๋ ๊ธฐ๋ณธ ํ์ ์ ๊ฐ์ ๋ด๋ถ์ ๋๊ณ ํฌ์ฅํ๊ธฐ ๋๋ฌธ์ด๋ค. ํฌ์ฅ ๊ฐ์ฒด์ ํน์ง์ ํฌ์ฅํ๊ณ ์๋ ๊ธฐ๋ณธ ํ์ ๊ฐ์ ์ธ๋ถ์์ ๋ณ๊ฒฝํ ์ ์๋ค. ๋ง์ฝ ๋ด๋ถ ๊ฐ์ ๋ณ๊ฒฝํ๊ณ ์ถ๋ค๋ฉด ์๋ก์ด ํฌ์ฅ ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด์ผํ๋ค.
๊ธฐ๋ณธํ์
ํฌ์ฅํด๋์ค
byte
Byte
char
Character
short
Short
int
Integer
float
Float
double
Double
boolean
Boolean
Boxing๊ณผ Unboxing
๊ธฐ๋ณธ ํ์ ์ ๊ฐ์ ํฌ์ฅ ๊ฐ์ฒด๋ก ๋ง๋๋ ๊ณผ์ ์ Boxing์ด๋ผ๊ณ ํ๊ณ , ๋ฐ๋๋ก ํฌ์ฅ ๊ฐ์ฒด์์ ๊ธฐ๋ณธ ํ์ ์ ๊ฐ์ ์ป์ด๋ด๋ ๊ณผ์ ์ Unboxing์ด๋ผ๊ณ ํ๋ค.
๊ธฐ๋ณธ ํ์ ์ ๊ฐ์ ์ค ๊ฒฝ์ฐ
๋ฌธ์์ด์ ์ค ๊ฒฝ์ฐ
Byte obj = new Byte(10);
Byte obj = new Byte("10");
Character obj = new Character('๊ฐ');
์์
Short obj = new Short(100);
Short obj = new Short("100");
Integer obj = new Integer(1000);
Integer obj = new Integer("1000");
Long obj = new Long(10000);
Long obj = new Long("10000");
Float obj = new Float(2.5F);
Float obj = new Float("2.5F");
Double obj = new Double(3.5);
Double obj = new Double("3.5");
Boolean obj = new Boolean(true);
Boolean obj = new Boolean("true");
์์ ํ๋ boxingํ๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค๋ค. ์์ฑ์๋ฅผ ์ด์ฉํ์ง ์์๋ ๋ค์๊ณผ ๊ฐ์ด valueOf()๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์๋ ์๋ค.
Integer obj = Integer.valueOf(1000);
Integer obj = Integer.valueOf("1000");
์ด๋ ๊ฒ boxing๋ ํฌ์ฅ ๊ฐ์ฒด์์ ๋ค์ ๊ธฐ๋ณธ ํ์ ์ ๊ฐ์ ์ป์ด ๋ด๊ธฐ ์ํด์๋ "๊ธฐ๋ณธํ์ ๋ช + Value()"๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด๋๋ค.
byte num=obj.byteValue();
char ch=obj.charValue();
...
//์์
//boxing
Integer obj1 = new Integer(100);
Integer obj2 = new Integer(200);
Integer obj3 = Integer.valueOf("300");
//unboxing
int value1 = obj1.intValue();
int value2 = obj2.intValue();
int value3 = obj3.intValue();
์๋ boxing & unboxing
๊ธฐ๋ณธ ํ์ ๊ฐ์ ์ง์ boxing, unboxingํ์ง ์์๋ ์๋์ผ๋ก boxing๊ณผ unboxing์ด ์ผ์ด๋๋ ๊ฒฝ์ฐ๊ฐ ์๋ค.
์๋ boxing์ ํฌ์ฅ ํด๋์ค ํ์ ์ ๊ธฐ๋ณธ๊ฐ์ด ๋์ ๋ ๊ฒฝ์ฐ์ด๋ค.
Integer obj = 100;
์๋ unboxing์ ๊ธฐ๋ณธ ํ์ ์ ํฌ์ฅ ๊ฐ์ฒด๊ฐ ๋์ ๋ ๊ฒฝ์ฐ์ ๋ฐ์ํ๋ค.
Integer obj = new Integer(200);
int value = obj;
๋ฌธ์์ด์ ๊ธฐ๋ณธ ํ์
๊ฐ์ผ๋ก ๋ณํ
ํฌ์ฅ ํด๋์ค์ ์ฃผ์ ์ฉ๋๋ ๊ธฐ๋ณธ ํ์ ์ ๊ฐ์ ๋ฐ์ฑํด์ ํฌ์ฅ ๊ฐ์ฒด๋ก ๋ง๋๋ ๊ฒ์ด์ง๋ง, ๋ฌธ์์ด์ ๊ธฐ๋ณธ ํ์ ๊ฐ์ผ๋ก ๋ณํํ ๋๋ ๋ง์ด ์ฌ์ฉ๋๋ค. ๋๋ถ๋ถ์ ํฌ์ฅ ํด๋์ค์๋ "parse+๊ธฐ๋ณธํ์ " ๋ช ์ผ๋ก ๋์ด์๋ ์ ์ (static) ๋ฉ์๋๊ฐ ์๋ค. ์ด ๋ฉ์๋๋ ๋ฌธ์์ด์ ๋งค๊ฐ๊ฐ์ผ๋ก ๋ฐ์ ๊ธฐ๋ณธ ํ์ ๊ฐ์ผ๋ก ๋ณํํ๋ค.
byte num = Byte.parseByte("10");
short num = Short.parseShort("10");
// int, long, float, double, boolean
ํฌ์ฅ ๊ฐ ๋น๊ต
ํฌ์ฅ ๊ฐ์ฒด๋ ๋ด๋ถ์ ๊ฐ์ ๋น๊ตํ๊ธฐ ์ํด ==
์ !=
์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ ์ ์๋ค. ์ด ์ฐ์ฐ์๋ ๋ด๋ถ์ ๊ฐ์ ๋น๊ตํ๋ ๊ฒ์ด ์๋๋ผ ํฌ์ฅ ๊ฐ์ฒด์ ์ฐธ์กฐ๋ฅผ ๋น๊ตํ๊ธฐ ๋๋ฌธ์ด๋ค.
Integer obj1 = 300;
Integer obj2 = 300;
System.out.println(obj1==obj2);
//=>false
๋ด๋ถ์ ๊ฐ๋ง ๋น๊ตํ๋ ค๋ฉด Unboxingํ ๊ฐ์ ์ป์ด ๋น๊ตํด์ผํ๋ค. ๊ทธ๋ฌ๋ boxing๋ ๊ฐ์ด ๋ค์ ํ์ ๋์ ์๋ ๊ฐ์ด๋ผ๋ฉด ==
์ !=
์ฐ์ฐ์๋ก ๋ด๋ถ์ ๊ฐ์ ๋ฐ๋ก ๋น๊ตํ ์ ์๋ค. ๊ทธ ์ด์ธ์๋ unboxingํ ํ์ ๋น๊ตํด์ผํ๋ค.
ํ์
๊ฐ์ ๋ฒ์
boolean
true,false
char
\u0000~\u007f
byte, short, int
-128~127
ํฌ์ฅ ๊ฐ์ฒด์ ์ ํํ ์ด๋ค ๊ฐ์ด ์ ์ฅ๋ ์ง ๋ชจ๋ฅด๋ ์ํฉ์ด๋ฉด ๋น๊ต ์ฐ์ฐ์(==
,!=
)๋ ์ฌ์ฉํ์ง ์๋ ๊ฒ์ด ์ข๋ค. ์ง์ ๋ด๋ถ ๊ฐ์ unboxingํด์ ๋น๊ตํ๊ฑฐ๋ equals() ๋ฉ์๋๋ก ๋ด๋ถ ๊ฐ์ ๋น๊ตํ๋ ๊ฒ์ด ์ข๋ค.
java.util ํจํค์ง
์๋ฐ ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ฐ๋ฐํ ๋ ๊ณตํต์ ์ผ๋ก ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ ํจํค์ง ์ค ํ๋์ด๋ค. java.util ํจํค์ง๋ ์๋ฐ ํ๋ก๊ทธ๋จ ๊ฐ๋ฐ์ ์กฐ๋ฏธ๋ฃ ๊ฐ์ ์ญํ ์ ํ๋ ํด๋์ค๋ฅผ ๋ด๊ณ ์๋ค. ๋๋ถ๋ถ์ ์ปฌ๋ ์ ํด๋์ค๋ค์ด ์ฐจ์งํ๊ณ ์๋ค.
ํด๋์ค
์ฉ๋
Arrays
๋ฐฐ์ด์ ์กฐ์(๋น๊ต, ๋ณต์ฌ, ์ ๋ ฌ, ์ฐพ๊ธฐ)ํ ๋ ์ฌ์ฉ
Calendar
์ด์์ฒด์ ์ ๋ ์ง์ ์๊ฐ์ ์ป์ ๋ ์ฌ์ฉ
Date
๋ ์ง์ ์๊ฐ ์ ๋ณด๋ฅผ ์ ์ฅํ๋ ํด๋์ค
Objects
๊ฐ์ฒด ๋น๊ต, null ์ฌ๋ถ ๋ฑ์ ์กฐ์ฌํ ๋ ์ฌ์ฉ
StringTokenizer
ํน์ ๋ฌธ์๋ก ๊ตฌ๋ถ๋ ๋ฌธ์์ด์ ๋ฝ์๋ผ ๋ ์ฌ์ฉ
Random
๋์๋ฅผ ์ป์ ๋ ์ฌ์ฉ
Objects ํด๋์ค
Object์ ์ ์ฌํ ์ด๋ฆ์ ๊ฐ์ง Objects ํด๋์ค๋ ๊ฐ์ฒด ๋น๊ต, ํด์์ฝ๋ ์์ฑ, null ์ฌ๋ถ, ๊ฐ์ฒด ๋ฌธ์์ด ๋ฆฌํด ๋ฑ์ ์ฐ์ฐ์ ์ํํ๋ ์ ์ ๋ฉ์๋๋ก ๊ตฌ์ฑ๋ Object์ ์ ํธ๋ฆฌํฐ ํด๋์ค์ด๋ค.
๋ฆฌํดํ์
๋ฉ์๋(๋งค๊ฐ๋ณ์)
์ค๋ช
int
compare(T a, T b, Comparator<T> c)
๋ ๊ฐ์ฒด a์ b๋ฅผ Comparator๋ฅผ ์ฌ์ฉํด์ ๋น๊ต
boolean
deepEquals(Object a, Object b)
๋ ๊ฐ์ฒด์ ๊น์ ๋น๊ต(๋ฐฐ์ด์ ํญ๋ชฉ๊น์ง ๋น๊ต)
boolean
equals(Object a,Object b)
๋ ๊ฐ์ฒด์ ์์ ๋น๊ต(๋ฒ์ง๋ง ๋น๊ต)
int
hash(Objectโฆ values)
๋งค๊ฐ๊ฐ์ด ์ ์ฅ๋ ๋ฐฐ์ด์ ํด์์ฝ๋ ์์ฑ
int
hashCode(Object c)
๊ฐ์ฒด์ ํด์์ฝ๋ ์์ฑ
boolean
isNull(Objec obj)
๊ฐ์ฒด๊ฐ null์ธ์ง ์กฐ์ฌ
boolean
nonNull(Objec obj)
๊ฐ์ฒด๊ฐ null์ด ์๋์ง ์กฐ์ฌ
T
requireNonNull(T obj)
๊ฐ์ฒด๊ฐ null์ธ ๊ฒฝ์ฐ ์์ธ ๋ฐ์
T
requireNonNull(T obj, String message)
๊ฐ์ฒด๊ฐ null์ธ ๊ฒฝ์ฐ ์์ธ ๋ฐ์(์ฃผ์ด์ง ์์ธ ๋ฉ์์ง ํฌํจ)
T
requireNonNull(T obj, Supplier<String> messageSupplier)
๊ฐ์ฒด๊ฐ null์ธ ๊ฒฝ์ฐ ์์ธ ๋ฐ์(๋๋ค์์ด ๋ง๋ ์์ธ ๋ฉ์์ง ํฌํจ)
String
toString(Object o)
๊ฐ์ฒด์ toString() ๋ฆฌํด๊ฐ ๋ฆฌํด
String
toString(Object o, String nullDefault)
๊ฐ์ฒด์ toString() ๋ฆฌํด๊ฐ ๋ฆฌํด, ์ฒซ ๋ฒ์งธ ๋งค๊ฐ๊ฐ์ด null์ผ ๊ฒฝ์ฐ ๋๋ฒ์งธ ๋งค๊ฐ๊ฐ ๋ฆฌํด
๊ฐ์ฒด ๋น๊ต(compare(T a, T b, Comparator<T> c)
)
compare(T a, T b, Comparator<T> c)
)๋ ๊ฐ์ฒด๋ฅผ ๋น๊ต์(Comparator)๋ก ๋น๊ตํด์ int๊ฐ์ ๋ฆฌํดํ๋ค. java.util.Comparator<T>
๋ ์ ๋ค๋ฆญ ์ธํฐํ์ด์ค ํ์
์ผ๋ก ๋ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ compare(T a, T b)
๋ฉ์๋๊ฐ ์ ์๋์ด ์๋ค. ์ ๋ค๋ฆญ์ ์ดํ 13. ์ ๋ค๋ฆญ์์ ํ์ตํ๋ค. T๋ ๋น๊ตํ ๊ฐ์ฒด ํ์
์ด๋ค.
a๊ฐ b๋ณด๋ค ์์ผ๋ฉด ์์, ๊ฐ์ผ๋ฉด 0, ํฌ๋ฉด ์์๋ฅผ ๋ฆฌํดํ๋๋ก ๊ตฌํ ํด๋์ค๋ฅผ ๋ง๋ค์ด์ผํ๋ค.
public interface Comparator<T>{
int compare(T a, T b);
}
// ์์
class StudentComparator implements Comparator<Student>{
@Override
public int compare(Student a, Student b){
if(a.sno<b.sno)return -1;
else if(a.sno==b.sno)return 0;
else return 1;
// return Integer.compare(a.sno,b.sno)๋ก ๊ฐ๋จํ๊ฒ ๋ฐ๊ฟ ์ ์๋ค.
}
}
๋๋ฑ ๋น๊ต(equals()์ deepEquals())
a
b
Objects.equlas(a,b)
not null
not null
a.eqauls(b)์ ๋ฆฌํด๊ฐ
null
not null
false
not null
null
false
null
null
true
ํน์ดํ ์ ์ a์ b๊ฐ ๋๋ค null์ผ ๊ฒฝ์ฐ true๋ฅผ ๋ฆฌํดํ๋ค๋ ์ ์ด๋ค.
a
b
Objects.deepEqulas(a,b)
not null(not array)
not null(not array)
a.eqauls(b)์ ๋ฆฌํด๊ฐ
not null(array)
not null(array)
Arrays.deepEqauls(b)์ ๋ฆฌํด๊ฐ
null
not null
false
not null
null
false
null
null
true
ํด์์ฝ๋ ์์ฑ(hash(), hashCode())
๋งค๊ฐ๊ฐ์ผ๋ก ์ฃผ์ด์ง ๊ฐ๋ค์ ์ด์ฉํด์ ํด์ ์ฝ๋๋ฅผ ์์ฑํ๋ค. ์ฃผ์ด์ง ๋งค๊ฐ๊ฐ๋ค๋ก ๋ฐฐ์ด์ ์์ฑํ๊ณ Arrays.hashCode(Object[])
๋ฅผ ํธ์ถํด ํด์์ฝ๋๋ฅผ ์ป๊ณ ์ด ๊ฐ์ ๋ฆฌํดํ๋ค. ์ด ๋ฉ์๋๋ ํด๋์ค๊ฐ hashCode()
๋ฅผ ์ฌ์ ์ํ ๋ ๋ฆฌํด๊ฐ์ ์์ฑํ๊ธฐ ์ํด ์ฌ์ฉํ๋ฉด ์ข๋ค.
ํด๋์ค๊ฐ ์ฌ๋ฌ ๊ฐ์ง ํ๋๋ฅผ ๊ฐ์ง๊ณ ์์ ๋ ์ด ํ๋๋ค๋ก ๋ถํฐ ํด์์ฝ๋๋ฅผ ์์ฑํ๊ฒ ๋๋ฉด ๋์ผํ ํ๋๊ฐ์ ๊ฐ์ง๋ ๊ฐ์ฒด๋ ๋์ผํ ํด์์ฝ๋๋ฅผ ๊ฐ์ง ์ ์๋ค.
@Override
public int hashCode(){
return Objects.hash(field1,field2,field3);
}
Objects.hashCode(Object o)
๋ ๋งค๊ฐ๊ฐ์ผ๋ก ์ฃผ์ด์ง ๊ฐ์ฒด์ ํด์์ฝ๋๋ฅผ ๋ฆฌํดํ๊ธฐ ๋๋ฌธ์ o.hashCode()
์ ๋ฆฌํด๊ฐ๊ณผ ๋์ผํ๋ค. ์ฐจ์ด์ ์ null์ด๋ฉด 0์ ๋ฆฌํดํ๋ค.
//์์
public class HashCodeEx{
public static void main(String[] args){
Student s1 = new Student(1,"ํ๊ธธ๋");
Student s2 = new Student(1,"ํ๊ธธ๋");
System.out.println(s1.hashCode());
System.out.println(Objects.hashCode(s2));
//=> 54151054
//=> 54151054
}
static class Student{
int sno;
String name;
Student(int sno, String name){
this.sno = sno;
this.name = name;
}
@Override
public int hashCode(){
return Objects.hahs(sno,name);
}
}
}
๋ ์ฌ๋ถ ์กฐ์ฌ(isNull(), nonNull(), requireNonNull())
isNull()์ ๋งค๊ฐ๊ฐ์ด null์ธ ๊ฒฝ์ฐ true๋ฅผ ๋ฆฌํดํ๋ค. ๋ฐ๋๋ก nonNull()์ ๋งค๊ฐ๊ฐ์ด not null์ธ ๊ฒฝ์ฐ true๋ฅผ ๋ฆฌํดํ๋ค. requireNonNull์ ๋ค์ ์ธ๊ฐ์ง๋ก ์ค๋ฒ๋ผ์ด๋ฉ ๋์ด์๋ค.
๋ฆฌํดํ์
๋ฉ์๋(๋งค๊ฐ๋ณ์)
์ค๋ช
T
requireNonNull(T obj)
not nullโobj nullโNullPointerException
T
requireNonNull(T obj, String message)
not nullโobj nullโNullPointerException(message)
T
requireNonNull(T obj, Supplier<String> messageSupplier)
not nullโobj nullโNullPointerException(msgSupplier.get())
//์์
public class NullEx{
public static void main(String[] args){
String str1 = "ํ๊ธธ๋";
String str2 = null;
System.out.println(Objects.requireNonNull(str1));
//=>ํ๊ธธ๋
try{
String name = Objects.requireNonNull(str2);
}catch(Exception e){
System.out.println(e.getMessage());
}
//=> null
try{
String name = Objects.requireNonNull(str2,"์ด๋ฆ์ด ์์ต๋๋ค.");
}catch(Exception e){
System.out.println(e.getMessage());
}
//=>์ด๋ฆ์ด ์์ต๋๋ค.
try{
String name = Objects.requireNonNull(str2,()->"์ด๋ฆ์ด ์์ต๋๋ค.");
//๋๋ค์
}catch(Exception e){
System.out.println(e.getMessage());
}
//=>์ด๋ฆ์ด ์์ต๋๋ค.
}
}
๊ฐ์ฒด ๋ฌธ์ ์ ๋ณด(toString())
๊ฐ์ฒด์ ๋ฌธ์ ์ ๋ณด๋ฅผ ๋ฆฌํดํ๋ค. ๋ ๊ฐ์ง๋ก ์ค๋ฒ๋ก๋ฉ ๋์ด์๋ค.
๋ฆฌํด ํ์
๋ฉ์๋(๋งค๊ฐ ๋ณ์)
์ค๋ช
String
toString(Object o)
not nullโo.toString() nullโ"null"
String
toString(Object o, String nullDefault)
not nullโo.toString() nullโnullDefault
//์์
public class ToStringEx{
public static void main(String[] args){
String str1 = "ํ๊ธธ๋";
String str2 = null;
System.out.println(Objects.toString(str1));
System.out.println(Objects.toString(str2));
System.out.println(Objects.toString(str2,"์ด๋ฆ์ด ์์ต๋๋ค."));
//=>ํ๊ธธ๋
//=>null
//=>์ด๋ฆ์ด ์์ต๋๋ค.
}
}
StringTokenizer ํด๋์ค
๋ฌธ์์ด์ด ํน์ ๊ตฌ๋ถ์(delimiter)๋ก ์ฐ๊ฒฐ๋์ด ์์ ๊ฒฝ์ฐ, ๊ตฌ๋ถ์๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ถ๋ถ ๋ฌธ์์ด์ ๋ถ๋ฆฌํ๊ธฐ ์ํด์๋ String ์ split()๋ฉ์๋๋ฅผ ์ด์ฉํ๊ฑฐ๋, StringTokenizer ํด๋์ค๋ฅผ ์ด์ฉํ ์ ์๋ค.
์ฐจ์ด์ ์ split์ ์ ๊ทํํ์์ผ๋ก ๊ตฌ๋ถํ๊ณ , StringTokenizer๋ ๋ฌธ์๋ก ๊ตฌ๋ถํ๋ค.
split() ๋ฉ์๋
String[] res = "๋ฌธ์์ด".split("์ ๊ทํํ์");
์์ ๊ฐ์ด ์ ๊ทํํ์์ ๊ตฌ๋ถ์๋ก ํด์ ๋ฌธ์์ด์ ๋ถ๋ฆฌํ ํ, ๋ฐฐ์ด์ ์ ์ฅํ๊ณ ๋ฆฌํดํ๋ค.
์๋ฐ&java,๋ฃจ๋น-ruby
๋ค์ ๋ฌธ์์ด์ &
, ,
, -
๋ฅผ ์ ์ธํ๊ณ ๋ฐ๋ก ๋ฝ์๋ด๊ณ ์ถ์ ๊ฒฝ์ฐ
String PL = "์๋ฐ&java,๋ฃจ๋น-ruby".split("&|,|-");
//=> ["์๋ฐ","java","๋ฃจ๋น","ruby"]
StringTokenzier ํด๋์ค
๋ฌธ์์ด์ด ํ ์ข ๋ฅ์ ๊ตฌ๋ถ์๋ก ์ฐ๊ฒฐ๋์ด ์์ ๊ฒฝ์ฐ์ ์ฌ์ฉํ๋ฉด ์์ฝ๊ฒ ๋ฌธ์์ด์ ๋ถ๋ฆฌํด ๋ผ ์ ์๋ค.
StringTokenzier str = new StringTokenzier("๋ฌธ์์ด","๊ตฌ๋ถ์");
์ ์ฒด ํ ํฐ์, ๋จ์ ์๋ ํ ํฐ ์ฌ๋ถ๋ฅผ ํ์ธ ํ ์ ์๋ค.
๋ฉ์๋
์ค๋ช
int
countTokens()
๊บผ๋ด์ง ์๊ณ ๋จ์ ์๋ ํ ํฐ์ ์
boolean
hasMoreTokens()
๋จ์ ์๋ ํ ํฐ์ด ์๋์ง ํ์ธ
String
nextToken()
ํ ํฐ์ ํ๋์ฉ ๊บผ๋ด์ด
StringTokenzier ๊ฐ์ฒด์์ ๋์ด์ ๊ฐ์ ธ์ฌ ํ ํฐ์ด ์๋ค๋ฉด nextToken()์ NoSuchElementException ์์ธ๋ฅผ ๋ฐ์์ํจ๋ค.
String text = "์๋ฐ,java,๋ฃจ๋น,ruby";
//๋ฐฉ๋ฒ1 : ์ ์ฒด ํ ํฐ ์๋ฅผ ์ป์ด for๋ฌธ ์คํ
StringTokenzier str = new StringTokenzier(text,",");
int count = str.countTokens();
for(int i=0;i<count;i++){
String token = str.nextToken();
System.out.println(token);
}
//๋ฐฉ๋ฒ2 : ๋จ์ ์๋ ํ ํฐ์ ํ์ธํ๊ณ , while๋ฌธ ๋ฃจํ
str = new StringTokenzier(text,",");
while(str.hasMoreTokens()){
String token = str.nextToken();
System.out.println(token);
}
Arrays ํด๋์ค
๋ฐฐ์ด์ ๋ณต์ฌ, ํญ๋ชฉ ์ ๋ ฌ, ํญ๋ชฉ ๊ฒ์๊ณผ ๊ฐ์ ๋ฐฐ์ด ์กฐ์์ ํ ์ ์๋ค. ๋จ์ํ ๋ฐฐ์ด ๋ณต์ฌ๋ System.arraycopy()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์์ผ๋ Arraysํด๋์ค๋ ์ถ๊ฐ์ ์ธ ๊ธด์์ ์ ๊ณตํด์ค๋ค.
๋ฆฌํดํ์
๋ฉ์๋ ์ด๋ฆ
์ค๋ช
int
binarySearch(๋ฐฐ์ด, ์ฐพ๋๊ฐ)
์ ์ฒด ๋ฐฐ์ด ํญ๋ชฉ์์ ์ฐพ๋ ๊ฐ์ด ์๋ ์ธ๋ฑ์ค ๋ฆฌํด
ํ๊ฒ ๋ฐฐ์ด
copyOf(์๋ณธ๋ฐฐ์ด, ๋ณต์ฌํ ๊ธธ์ด)
์๋ณธ ๋ฐฐ์ด์ 0๋ฒ ์ธ๋ฑ์ค์์ ๋ณต์ฌํ ๊ธธ์ด๋งํผ ๋ณต์ฌํ ๋ฐฐ์ด ๋ฆฌํด, ๋ณต์ฌํ ๊ธธ์ด๋ ์๋ณธ ๋ฐฐ์ด์ ๊ธธ์ด๋ณด๋ค ์ปค๋ ๋๋ฉฐ, ํ๊ฒ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ๋๋ค.
ํ๊ฒ ๋ฐฐ์ด
copyOfRange(์๋ณธ๋ฐฐ์ด, ์์์ธ๋ฑ์ค, ๋์ธ๋ฑ์ค)
์๋ณธ ๋ฐฐ์ด์ ์์ ์ธ๋ฑ์ค์์ ๋ ์ธ๋ฑ์ค๊น์ง ๋ณต์ฌํ ๋ฐฐ์ด ๋ฆฌํด
boolean
deepEquals(๋ฐฐ์ด,๋ฐฐ์ด)
๋ ๋ฐฐ์ด์ ๊น์ ๋น๊ต(์ค์ฒฉ ๋ฐฐ์ด์ ํญ๋ชฉ๊น์ง ๋น๊ต)
boolean
equals(๋ฐฐ์ด,๋ฐฐ์ด)
๋ ๋ฐฐ์ด์ ์์ ๋น๊ต(์ค์ฒฉ ๋ฐฐ์ด์ ํญ๋ชฉ์ ๋น๊ตํ์ง ์์)
void
fill(๋ฐฐ์ด, ๊ฐ)
์ ์ฒด ๋ฐฐ์ด ํญ๋ชฉ์ ๋์ผํ ๊ฐ์ ์ ์ฅ
void
fill(๋ฐฐ์ด, ์์์ธ๋ฑ์ค,๋์ธ๋ฑ์ค, ๊ฐ)
์์ ์ธ๋ฑ์ค๋ถํฐ ๋ ์ธ๋ฑ์ค๊น์ง์ ํญ๋ชฉ์๋ง ๋์ผํ ๊ฐ์ ์ ์ฅ
void
sort(๋ฐฐ์ด)
๋ฐฐ์ด์ ์ ์ฒด ํญ๋ชฉ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ
String
toString(๋ฐฐ์ด)
"[๊ฐ1,๊ฐ2,โฆ]" ์ ๊ฐ์ ๋ฌธ์์ด ๋ฆฌํด
๋ฐฐ์ด ๋ณต์ฌ
๋ฐฉ๋ฒ1,2
char[] arr1 = {'J','A','V','A'};
char[] arr2 = Arrays.copyOf(arr1, arr1.length);
//=> ["J","A","V","A"]
char[] arr3 = Arrays.copyOfRange(arr1,1,3);
//์ฌ๊ธฐ์ ์์์ธ๋ฑ์ค๋ ํฌํจ๋์ง๋ง ๋ ์ธ๋ฑ์ค๋ ํฌํจํ์ง ์๋๋ค.
//=> [A","V"]
๋ฐฉ๋ฒ3
๋จ์ํ ๋ฐฐ์ด์ ๋ณต์ฌํ ๋ชฉ์ ์ด๋ผ๋ฉด System.arraycopy() ๋ฉ์๋๋ฅผ ์ด์ฉํ ์ ์๋ค.
System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
// ์ฐจ๋ก๋๋ก ์๋ณธ๋ฐฐ์ด, ์๋ณธ์์์ธ๋ฑ์ค, ํ๊ฒ๋ฐฐ์ด, ํ๊ฒ์์์ธ๋ฑ์ค, ๋ณต์ฌ๊ฐ์์ด๋ค.
//์์
char[] arr1 = {'J','A','V','A'};
//๋ฐฉ๋ฒ1
char[] arr2 = Arrays.copyOf(arr1, arr1.length);
//๋ฐฉ๋ฒ2
char[] arr3 = Arrays.copyOfRange(arr1,0,arr1.length);
//๋ฐฉ๋ฒ3
char arr4 = new char[arr1.length]
System.arraycopy(arr1,0,arr4,0,arr1.length);
๋ฐฐ์ด ํญ๋ชฉ ๋น๊ต
equals()๋ 1์ฐจ ํญ๋ชฉ์ ๊ฐ๋ง ๋น๊ตํ๊ณ , deepEquals()๋ 1์ฐจ ํญ๋ชฉ์ด ์๋ก ๋ค๋ฅธ ๋ฐฐ์ด์ ์ฐธ์กฐํ ๊ฒฝ์ฐ ์ค์ฒฉ๋ ๋ฐฐ์ด์ ํญ๋ชฉ๊น์ง ๋น๊ตํ๋ค.
int[][] origin = {{1,2},{3,4}};
//์์ ๋ณต์
int[][] clone1 = Arrays.copyOf(origin,origin.length);
System.out.println("๋ฐฐ์ด ๋ฒ์ง ๋น๊ต"+origin.equals(clone1));
//=>false
System.out.println("1์ฐจ ๋ฐฐ์ด ํญ๋ชฉ๊ฐ ๋น๊ต"+Arrays.deepEquals(clone1));
//=>true
System.out.println("์ค์ฒฉ ๋ฐฐ์ด ํญ๋ชฉ๊ฐ ๋น๊ต"+Arrays.deepEquals(clone1));
//=>true
//๊น์ ๋ณต์
int[][] clone2 = Arrays.copyOf(origin, origin.length);
clone2[0]=Arrays.copyOf(origin[0],origin[0].length);
clone2[1]=Arrays.copyOf(origin[1],origin[1].length);
System.out.println("๋ฐฐ์ด ๋ฒ์ง ๋น๊ต"+origin.equals(clone2));
//=>false
System.out.println("1์ฐจ ๋ฐฐ์ด ํญ๋ชฉ๊ฐ ๋น๊ต"+Arrays.deepEquals(clone2));
//=>false
System.out.println("์ค์ฒฉ ๋ฐฐ์ด ํญ๋ชฉ๊ฐ ๋น๊ต"+Arrays.deepEquals(clone2));
//=>true

๋ฐฐ์ด ํญ๋ชฉ ์ ๋ ฌ
๊ธฐ๋ณธ ํ์ ๋๋ String ๋ฐฐ์ด์ Arrays.sort()๋ฉ์๋์ ๋งค๊ฐ๊ฐ์ผ๋ก ์ง์ ํด์ฃผ๋ฉด ์๋์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ์ด ๋๋ค. ์ฌ์ฉ์ ์ ์ ํด๋์ค ํ์ ์ผ ๊ฒฝ์ฐ์๋ ํด๋์ค๊ฐ Comparable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๊ณ ์์ด์ผ ์ ๋ ฌ์ด๋๋ค.
public class Member implements Comparable<Memeber>{
String name;
Memeber(String name){
this.name = name;
}
@Override
public int compareTo(Member o){
return name.comapareTo(o.name);
}
}
Comparable<Member>
๋ Member ํ์
๋ง ๋น๊ตํ๊ธฐ ์ํด ์ ๋ค๋ฆญ<>
์ ์ฌ์ฉํ๋ค. compareTo() ๋ฉ์๋๋ ๋น๊ต๊ฐ์ ๋ฆฌํดํ๋๋ก ์ค๋ฒ๋ผ์ด๋ฉํ๋ค. compareTo()๋ฉ์๋๋ ์ค๋ฆ์ฐจ์์ธ ๊ฒฝ์ฐ ์์ ์ด ๋งค๊ฐ๊ฐ๋ณด๋ค ๋ฎ์ ๊ฒฝ์ฐ ์์, ๊ฐ์ ๊ฒฝ์ฐ 0 , ๋์ ๊ฒฝ์ฐ ์์๋ฅผ ๋ฆฌํดํ๋ฉด๋๋ค. ๋ฐ๋๋ก ๋ด๋ฆผ์ฐจ์์ผ ๋๋ ์ค๋ฆ์ฐจ์์ ๋ฐ๋๋ก ๋ฆฌํดํ๋ฉด๋๋ค.
int[] scores={99,97,98};
Arrays.sort(scores);
Member m1 = new Member("์ ์ฌ์");
Member m2 = new Member("๊ฐํธ๋");
Member m3 = new Member("์ ํ๋ฌด");
Member[] members = {m1,m2,m3};
Arrays.sort(members);
๋ฐฐ์ด ํญ๋ชฉ ๊ฒ์
๋ฐฐ์ด ํญ๋ชฉ์์ ํน์ ๊ฐ์ด ์์นํ ์ธ๋ฑ์ค๋ฅผ ์ป๋ ๊ฒ์ ๋ฐฐ์ด ๊ฒ์์ด๋ผ๊ณ ํ๋ค. ๋ฐฐ์ด ํญ๋ชฉ์ ๊ฒ์ํ๋ ค๋ฉด ๋จผ์ Arrays.sort()๋ฉ์๋๋ก ํญ๋ชฉ๋ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ํ, Arrays.binarySearch()๋ฉ์๋๋ก ํญ๋ชฉ์ ์ฐพ์์ผํ๋ค.
int[] scores={99,97,98};
Arrays.sort(scores);
int index = Arrays.binarySearch(scores,99);
//=>2
Member m1 = new Member("์ ์ฌ์");
Member m2 = new Member("๊ฐํธ๋");
Member m3 = new Member("์ ํ๋ฌด");
Member[] members = {m1,m2,m3};
Arrays.sort(members);
index = Arrays.binarySearch(members,m1);
//=>1
Last updated
Was this helpful?