๋ธ๋ก๊ทธ ์ฎ๊ฒผ์ต๋๋ค! ๐ก integer.blog
์๋ฐ์ ์ ์(๋จ๊ถ์ฑ ์ ) ํ์ต๋ด์ฉ ์ ๋ฆฌ
1. java.lang ํจํค์ง
- java.lang ํจํค์ง์ ํด๋์ค๋ค์ import๋ฌธ ์์ด๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
2. Object ํด๋์ค
- Object ํด๋์ค๋ ๋ชจ๋ ํด๋์ค์ ์ต๊ณ ์กฐ์
- Object ํด๋์ค์ ๋ฉค๋ฒ๋ค์ ๋ชจ๋ ํด๋์ค์์ ๋ฐ๋ก ์ฌ์ฉ ๊ฐ๋ฅ
- Object ํด๋์ค๋ ๋ฉค๋ฒ๋ณ์๋ ์๊ณ 11๊ฐ์ ๋ฉ์๋๋ง ์๋ค.
- protected Object clone() : ๊ฐ์ฒด ์์ ์ ๋ณต์ฌ๋ณธ ๋ฐํ
- public boolean equals(Object obj) : ๊ฐ์ฒด ์์ ๊ณผ ๊ฐ์ฒด obj๊ฐ ๊ฐ์ ๊ฐ์ฒด์ธ์ง ํ๋จ
- protected void finalize() : ๊ฐ์ฒด๊ฐ ์๋ฉธ๋ ๋ ๊ฐ๋น์ง์ฝ๋ ํฐ์ ์ํด ์๋์ผ๋ก ํธ์ถ(๊ฑฐ์ ์ฌ์ฉ์ํจ)
- public Class getClasss() : ๊ฐ์ฒด ์์ ์ ํด๋์ค ์ ๋ณด๋ฅผ ๋ด๊ณ ์๋ Class ์ธ์คํด์ค๋ฅผ ๋ฐํ
- public int hashCode() : ๊ฐ์ฒด ์์ ์ ํด์์ฝ๋๋ฅผ ๋ฐํ
- public String toString() : ๊ฐ์ฒด ์์ ์ ์ ๋ณด๋ฅผ ๋ฌธ์์ด๋ก ๋ฐํ
- public void notify() : ๊ฐ์ฒด ์์ ์ ์ฌ์ฉํ๋ ค๊ณ ๊ธฐ๋ค๋ฆฌ๋ ์ฐ๋ ๋๋ฅผ ํ๋๋ง ๊นจ์ด๋ค.
- public void notifyAll() : ๊ฐ์ฒด ์์ ์ ์ฌ์ฉํ๋ ค๊ณ ๊ธฐ๋ค๋ฆฌ๋ ๋ชจ๋ ์ฐ๋ ๋๋ฅผ ๊นจ์ด๋ค.
- public void wait(long timeout, int nanos) : ๋ค๋ฅธ ์ฐ๋ ๋๊ฐ notify()๋ notifyAll()์ ํธ์ถํ ๋ ๊น์ง ํ์ฌ ์ฐ๋ ๋๋ฅผ ๋ฌดํํ ๋๋ ์ง์ ๋ ์๊ฐ๋์ ๊ธฐ๋ค๋ฆฌ๊ฒ ํ๋ค.
3. equals(Object obj)
- Object ํด๋์ค๋ก๋ถํฐ ์์๋ฐ์ equals ๋ฉ์๋๋ ๋ ๊ฐ์ ์ฐธ์กฐ๋ณ์๊ฐ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋์ง(๋ ์ฐธ์กฐ๋ณ์์ ์ ์ฅ๋ ์ฃผ์๊ฐ์ด ๊ฐ์์ง) ํ๋จ
- equals ๋ฉ์๋๋ก Value ์ธ์คํด์ค๊ฐ ๊ฐ์ง๊ณ ์๋ value๊ฐ์ ๋น๊ตํ๋ ค๋ฉด,
Value ํด๋์ค์์ equals ๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ์ฌ ์ฃผ์๊ฐ ์๋ ๊ฐ์ฒด์ ์ ์ฅ๋ ๋ด์ฉ์ ๋น๊ตํ๋๋ก ๋ณ๊ฒฝํด์ผ ํ๋ค.
4. hashCode()
- ํด์ํจ์๋ ์ฐพ๋ ๊ฐ์ ์ ๋ ฅํ๋ฉด, ๊ทธ ๊ฐ์ด ์ ์ฅ๋ ์์น๋ฅผ ์๋ ค์ฃผ๋ ํด์์ฝ๋(hash code)๋ฅผ ๋ฐํํ๋ค.
- ์ผ๋ฐ์ ์ผ๋ก ํด์์ฝ๋๊ฐ ๊ฐ์ ๋ ๊ฐ์ฒด๊ฐ ์กด์ฌํ๋ ๊ฒ์ด ๊ฐ๋ฅํ์ง๋ง,
Object ํด๋์ค์ ์ ์๋ hashCode ๋ฉ์๋๋ ๊ฐ์ฒด์ ์ฃผ์๊ฐ์ ์ด์ฉํด์ ํด์์ฝ๋๋ฅผ ๋ง๋ค์ด ๋ฐํํ๊ธฐ ๋๋ฌธ์
์๋ก ๋ค๋ฅธ ๋ ๊ฐ์ฒด๋ ๊ฐ์ ํด์์ฝ๋๋ฅผ ๊ฐ์ง ์ ์๋ค. - String ํด๋์ค๋ ๋ฌธ์์ด์ ๋ด์ฉ์ด ๊ฐ์ผ๋ฉด ๊ฐ์ ํด์์ฝ๋๋ฅผ ๋ฐํํ๋๋ก hashCode๋ฉ์๋๊ฐ ์ค๋ฒ๋ผ์ด๋ฉ ๋์ด ์๊ธฐ ๋๋ฌธ์
๋ฌธ์์ด์ ๋ด์ฉ์ด ๊ฐ์ str1๊ณผ str2์ ๋ํด hashCode()๋ฅผ ํธ์ถํ๋ฉด ํญ์ ๋์ผํ ํด์์ฝ๋ ๊ฐ์ ์ป๋๋ค.
5. toString()
- Object ํด๋์ค์ ์ ์๋ toString()
public String toString() { return getClass().getName()+"@"+Integer.toHexString(hashCode()); }
- ํด๋์ค๋ฅผ ์์ฑํ ๋ toString()์ ์ค๋ฒ๋ผ์ด๋ฉ ํ์ง ์๊ณ , toString()์ ํธ์ถํ๋ฉด ํด๋์ค์ด๋ฆ+16์ง์์ ํด์์ฝ๋๋ฅผ ๋ฐํํ๋ค.
- String ํด๋์ค์ toString()์ String ์ธ์คํด์ค๊ฐ ๊ฐ๊ณ ์๋ ๋ฌธ์์ด์ ๋ฐํํ๋๋ก ์ค๋ฒ๋ผ์ด๋ฉ ๋์ด ์๋ค.
- Date ํด๋์ค์ ๊ฒฝ์ฐ, Date ์ธ์คํด์ค๊ฐ ๊ฐ๊ณ ์๋ ๋ ์ง์ ์๊ฐ์ ๋ฌธ์์ด๋ก ๋ฐํํ๋๋ก ์ค๋ฒ๋ผ์ด๋ฉ ๋์ด ์๋ค.
6. clone()
- ์์ ์ ๋ณต์ ํ์ฌ ์๋ก์ด ์ธ์คํด์ค๋ฅผ ์์ฑํ๋ค.
- Object ํด๋์ค์ ์ ์๋ clone()์ ๋จ์ํ ์ธ์คํด์ค ๋ณ์์ ๊ฐ๋ง ๋ณต์ฌํ๊ธฐ ๋๋ฌธ์
์ฐธ์กฐํ์ ์ ์ธ์คํด์ค ๋ณ์๊ฐ ์๋ ํด๋์ค๋ ์์ ํ ์ธ์คํด์ค ๋ณต์ ๊ฐ ์ด๋ฃจ์ด์ง์ง ์๋๋ค. - clone()์ ๋ฐ๋์ ์์ธ์ฒ๋ฆฌ๋ฅผ ํด์ค์ผ ํ๋ค.
7. ๊ณต๋ณ ๋ฐํํ์ (covariant return type)
- JDK1.5๋ถํฐ ์ค๋ฒ๋ผ์ด๋ฉํ ๋ ๋ถ๋ชจ ๋ฉ์๋์ ๋ฐํํ์
์ ์์ ํด๋์ค์ ํ์
์ผ๋ก ๋ณ๊ฒฝ ๊ฐ๋ฅํ๋ค.
public Point clone() { // ๋ฐํํ์ ์ Object์์ Point๋ก ๋ณ๊ฒฝ Object obj = null; try { obj = super.clone(); } catch(CloneNotSupportedException e) {} return (Point)obj; //Point ํ์ ์ผ๋ก ํ๋ณํ
- ๊ณต๋ณ ๋ฐํํ์
์ ์ฌ์ฉํ๋ฉด ์กฐ์์ ํ์
์ด ์๋, ์ค์ ๋ก ๋ฐํ๋๋ ์์ ๊ฐ์ฒด์ ํ์
์ผ๋ก ๋ฐํํ ์ ์์ด ๋ฒ๊ฑฐ๋ก์ด ํ๋ณํ์ด ์ค์๋ค.
Point copy = (Point)original.clone();
->Point copy = original.clone();
8. ๋ฐฐ์ด ๋ณต์ฌ
- ๋ฐฐ์ด๋ ๊ฐ์ฒด์ด๊ธฐ ๋๋ฌธ์ Object ํด๋์ค๋ฅผ ์์๋ฐ์ผ๋ฉฐ, ๋์์ Cloneable ์ธํฐํ์ด์ค์ Serializable ์ธํฐํ์ด์ค๊ฐ ๊ตฌํ๋์ด ์๋ค.
- ์ผ๋ฐ์ ์ผ๋ก ๋ฐฐ์ด์ ๋ณต์ฌํ ๋๋ ๊ฐ์ ๊ธธ์ด์ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํ ๋ค์
System.arraycopy()
๋ฅผ ์ด์ฉํด์ ๋ด์ฉ์ ๋ณต์ฌํ์ง๋งclone()
์ ์ด์ฉํด์ ๊ฐ๋จํ๊ฒ ๋ณต์ฌํ ์ ์๋ค.int[] arr = {1,2,3,4,5}; int[] arrClone = arr.clone();
int[] arr = {1,2,3,4,5}; int[] arrClone = new int[arr.length]; System.arraycopy(arr,0,arrClone,0,arr.length);
- ๋ฐฐ์ด ๋ฟ๋ง ์๋๋ผ
java.util
ํจํค์ง์
Vector
ArrayList
LinkedList
HashSet
TreeSet
HashMap
TreeMap
Calendar
Date์ ๊ฐ์ ํด๋์ค๋ค๋ ๋ณต์ ๊ฐ ๊ฐ๋ฅํ๋ค.
9. ์์ ๋ณต์ฌ์ ๊น์ ๋ณต์ฌ (shallow copy & deep copy)
- clone()์ ๊ฐ์ฒด์ ์ ์ฅ๋ ๊ฐ์ ๊ทธ๋๋ก ๋ณต์ ํ ๋ฟ, ๊ฐ์ฒด๊ฐ ์ฐธ์กฐํ๊ณ ์๋ ๊ฐ์ฒด๊น์ง ๋ณต์ ํ์ง ์์
- ์๋ณธ๊ณผ ๋ณต์ ๋ณธ์ด ๊ฐ์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐ
- ์ด๊ฒ์ด ์์ ๋ณต์ฌ(shallow copy)
- ์์ ๋ณต์ฌ์์๋ ์๋ณธ์ ๋ณ๊ฒฝํ๋ฉด ๋ณต์ฌ๋ณธ๋ ์ํฅ์ ๋ฐ๋๋ค.
- ์๋ณธ์ด ์ฐธ์กฐํ๊ณ ์๋ ๊ฐ์ฒด๊น์ง ๋ณต์ ํ๋ ๊ฒ์ด ๊น์ ๋ณต์ฌ(deep copy)
- ์๋ณธ๊ณผ ๋ณต์ฌ๋ณธ์ด ์๋ก ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ธฐ ๋๋ฌธ์ ์๋ณธ์ ๋ณ๊ฒฝ์ด ๋ณต์ฌ๋ณธ์ ์ํฅ ์์
- ์๋ณธ๊ณผ ๋ณต์ฌ๋ณธ์ด ์๋ก ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ธฐ ๋๋ฌธ์ ์๋ณธ์ ๋ณ๊ฒฝ์ด ๋ณต์ฌ๋ณธ์ ์ํฅ ์์
10. getClass()
- ์์ ์ด ์ํ ํด๋์ค์ Class ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ ๋ฉ์๋
- Class ๊ฐ์ฒด๋ ์ด๋ฆ์ด ‘Class’์ธ ํด๋์ค์ ๊ฐ์ฒด์ด๋ค.
public final class Class implements ... { ... }
- Class ๊ฐ์ฒด๋ ํด๋์ค์ ๋ชจ๋ ์ ๋ณด๋ฅผ ๋ด๊ณ ์์ผ๋ฉฐ, ํด๋์ค ๋น 1๊ฐ๋ง ์กด์ฌํ๋ค.
- ํด๋์ค ํ์ผ์ด ‘ClassLoader’์ ์ํด ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ผ๊ฐ ๋ ์๋์ผ๋ก ์์ฑ
- ํ์ผ ํํ๋ก ์ ์ฅ๋์ด ์๋ ํด๋์ค๋ฅผ ์ฝ์ด์ Classํด๋์ค์ ์ ์๋ ํ์์ผ๋ก ๋ณํํ๋ ๊ฒ
- ์ฆ, ํด๋์ค ํ์ผ์ ์ฝ์ด์ ์ฌ์ฉํ๊ธฐ ํธํ ํํ๋ก ์ ์ฅํ ๊ฒ์ด ํด๋์ค ๊ฐ์ฒด
- Class ๊ฐ์ฒด ์ป๋ ๋ฐฉ๋ฒ
Class cObj = new Card().getClass(); // ์์ฑ๋ ๊ฐ์ฒด๋ก ๋ถํฐ ์ป๊ธฐ
Class cObj = Card.class; // ํด๋์ค ๋ฆฌํฐ๋ด(*.class)๋ก ๋ถํฐ ์ป๊ธฐ
Class cObj = Class.forName("Card"); //ํด๋์ค ์ด๋ฆ์ผ๋ก ๋ถํฐ ์ป๊ธฐ
- ๊ฐ์ฒด ์์ฑ
Card c = new Card(); // new์ฐ์ฐ์๋ก ๊ฐ์ฒด ์์ฑ
Card c = Card.class.newInstance(); // Class๊ฐ์ฒด๋ก ๊ฐ์ฒด ์์ฑ
11. String ํด๋์ค
- String ํด๋์ค๋ ๋ฌธ์์ด์ ์ ์ฅํ๊ธฐ ์ํด ๋ฌธ์ํ ๋ฐฐ์ด ๋ณ์(char[]) value๋ฅผ ์ธ์คํด์ค ๋ณ์๋ก ์ ์๋์ด์๋ค.
public final class String implements java.io.Serializable, Comparable { private char[] value; ... }
- ์ธ์คํด์ค ์์ฑ ์ ์์ฑ์์ ๋งค๊ฐ๋ณ์๋ก ์
๋ ฅ๋ฐ๋ ๋ฌธ์์ด์ ์ธ์คํด์ค ๋ณ์
value
์ ๋ฌธ์ํ ๋ฐฐ์ดchar[]
๋ก ์ ์ฅ๋๋ ๊ฒ์ด๋ค. - String ํด๋์ค๋ ์์ final์ด ๋ถ์ด ์์ผ๋ฏ๋ก ๋ค๋ฅธ ํด๋์ค์ ๋ถ๋ชจ๊ฐ ๋ ์ ์๋ค.
- ๋ณ๊ฒฝ ๋ถ๊ฐ๋ฅํ(Immutable) ํด๋์ค๋ค.
- ์๋ฅผ ๋ค์ด ‘+’ ์ฐ์ฐ์๋ฅผ ์ด์ฉํด์ ๋ฌธ์์ด์ ๊ฒฐํฉํ๋ ๊ฒฝ์ฐ, ์ธ์คํด์ค ๋ด์ ๋ฌธ์์ด์ด ๋ฐ๋๋ ๊ฒ์ด ์๋๋ผ ์๋ก์ด ๋ฌธ์์ด์ด ๋ด๊ธด String ์ธ์คํด์ค๊ฐ ์์ฑ๋๋ ๊ฒ์ด๋ค.
- ์ฆ, ๋งค ์ฐ์ฐ ๋ง๋ค ์๋ก์ด ๋ฌธ์์ด์ ๊ฐ์ง String ์ธ์คํด์ค๊ฐ ์์ฑ๋์ด ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฐจ์งํ๋ค.
11.1. ๋ฌธ์์ด์ ๋ง๋๋ ๋ฐฉ๋ฒ 2๊ฐ์ง
String str1 = "abc";
// ๋ฌธ์์ด ๋ฆฌํฐ๋ด “abc”์ ์ฃผ์๋ฅผ str1์ ์ ์ฅString str2 = new String("abc");
// ์๋ก์ด String ์ธ์คํด์ค ์์ฑ- ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์ด๋ฏธ ์กด์ฌํ๋ ๊ฒ์ ์ฌ์ฌ์ฉ ํ๋ ๊ฒ์ด๋ค. (๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ํด๋์ค๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ๋ก๋๋ ๋ ์๋์ผ๋ก ๋ฏธ๋ฆฌ ์์ฑ๋๋ค.)
String str1 = "abc"; String str2 = "abc"; str1 == str2 ? true str1.equals(str2) ? true String str3 = new String("abc"); String str4 = new String("abc"); str3 == str4 ? false str3.equals(str4) ? true
11.2. ๋ฌธ์์ด ๋ฆฌํฐ๋ด
- ํด๋์ค ํ์ผ์๋ ์์คํ์ผ์ ํฌํจ๋ ๋ชจ๋ ๋ฆฌํฐ๋ด์ ๋ชฉ๋ก์ด ์๋ค.
- ํด๋น ํด๋์ค ํ์ผ์ด ํด๋์ค ๋ก๋์ ์ํด ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ผ๊ฐ ๋, ๋ฆฌํฐ๋ด ๋ชฉ๋ก์ ์๋ ๋ฆฌํฐ๋ด๋ค์ด JVM๋ด์ ์๋ ์์ ์ ์ฅ์(constant pool)์ ์ ์ฅ๋๋ค.
11.3. ๋น ๋ฌธ์์ด
- ๊ธธ์ด๊ฐ 0์ธ ๋ฐฐ์ด์ ์กด์ฌํ๋ค.(C์ธ์ด๋ ๋ถ๊ฐ๋ฅ)
- charํ ๋ฐฐ์ด๋ ๊ธธ์ด๊ฐ 0์ธ ๋ฐฐ์ด ์์ฑํ ์ ์๊ณ , ์ด ๋ฐฐ์ด์ ๋ด๋ถ์ ์ผ๋ก ๊ฐ์ง๊ณ ์๋ ๋ฌธ์์ด์ด ๋น ๋ฌธ์์ด์ด๋ค.
String s = "";
์์ ์ฐธ์กฐ๋ณ์s
๊ฐ ์ฐธ์กฐํ๊ณ ์๋ String ์ธ์คํด์ค๋ ๋ด๋ถ์new char[0]
๊ฐ์ด ๊ธธ์ด๊ฐ 0์ธ charํ ๋ฐฐ์ด์ ์ ์ฅํ๊ณ ์๋ ๊ฒ์ด๋ค.char[] chArr = new char[0];
int[] iArr = {};
11.4. join()
๊ณผ StringJoiner
(jdk1.8๋ถํฐ ์ถ๊ฐ)
join()
์ ๋ฌธ์์ด ์ฌ์ด์ ๊ตฌ๋ถ์๋ฅผ ๋ฃ์ด์ ๊ฒฐํฉString[] arr = { "dog", "cat", "bear"}; String str = String.join("-", arr);
java.util.StringJoiner
ํด๋์ค ์ฌ์ฉํ์ฌ ๋ฌธ์์ด ๊ฒฐํฉStringJoiner sj = new StringJoiner("," , "[" , "]"); String[] strArr = { "aaa", "bbb", "ccc" }; for(String s : strArr) sj.add(s.toUpperCase()); System.out.println(sj.toString()); // [AAA,BBB,CCC]
11.5. ๊ธฐ๋ณธํ-String ๋ณํ
- ์ซ์์ ๋น๋ฌธ์์ด(“”) ๋ํ๊ธฐ
valueOf()
์ฌ์ฉString str1 = 100 + ""; // 100 > "100" String str2 = String.valueOf(100); // 100 > "100" int i = Integer.parseInt("100") // "100" > 100 int i2 = Integer.valueOf("100") // "100" > 100
- valueOf()์ ๋ฐํํ์ ์ int๊ฐ ์๋๋ผ Integer์ง๋ง ์คํ ๋ฐ์ฑ์ ์ํด ์๋๋ณํ
valueOf(String s)
๋ ๋ฉ์๋ ๋ด๋ถ์parseInt(String s)
๋ฅผ ํธ์ถํ ๋ฟ์ด๋ฏ๋ก, ๋ ๋ฉ์๋๋ ๋ฐํ ํ์ ๋ง ๋ค๋ฅด๊ณ ๊ฐ์ ๋ฉ์๋๋ค.
12. StringBuffer & StringBuilder ํด๋์ค
public final class StringBuffer implements java.io.Serializable {
private char[] value;
...
}
- Stringํด๋์ค๋ Immutable์ด๋ฏ๋ก ์ธ์คํด์ค๋ฅผ ์์ฑํ ๋ ์ง์ ๋ ๋ฌธ์์ด์ ๋ณ๊ฒฝํ ์ ์์ง๋ง, StringBufferํด๋์ค๋ ๊ฐ๋ฅํ๋ค.
- ๋ด๋ถ์ ์ผ๋ก ๋ฌธ์์ด ํธ์ง์ ์ํ buffer๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, StringBuffer ์ธ์คํด์ค๋ฅผ ์์ฑํ ๋ ๊ทธ ํฌ๊ธฐ๋ฅผ ์ง์ ํ ์ ์๋ค.
- buffer์ ํฌ๊ธฐ๋ฅผ ์ง์ ํ์ง ์์ผ๋ฉด 16๊ฐ์ ๋ฌธ์๋ฅผ ์ ์ฅํ ์ ์๋ ํฌ๊ธฐ์ ๋ฒํผ ์์ฑ
12.1 append()
append()
๋ ๋ฐํํ์ ์ด StringBuffer์ด๋ฉฐ ์์ ์ ์ฃผ์๋ฅผ ๋ฐํํ๋ค.StringBuffer sb = new StringBuffer("abc"); sb.append("123").append("ZZ");
- ์์ ์ฝ๋์์
sb.append("123")
์ดsb
๋ฅผ ๋ฐํํ๋ฏ๋ก ์ฐ์์ ์ผ๋ก append()๋ฅผ ํธ์ถํ ์ ์๋ค. - StringBuffer ํด๋์ค๋ equals() ๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉ ํ์ง ์์์
==
๋ก ๋น๊ตํ ๊ฒ๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป๋๋ค. - StringBuffer ์ธ์คํด์ค์ ๋ด๊ธด ๋ฌธ์์ด์ ๋น๊ตํ๊ธฐ ์ํด์๋ ์ธ์คํด์ค์
toString()
์ ํธ์ถํด์ String์ธ์คํด์ค๋ฅผ ์ป์ ํ์equals()
์ฌ์ฉํด์ผ ํ๋ค.
12.2. StringBuilder ํด๋์ค
- StringBuffer๋ ๋ฉํฐ์ฐ๋ ๋์ ์์ (thread safe)ํ๋๋ก ๋๊ธฐํ ๋์ด์๋ค.
- ๋๊ธฐํ๊ฐ StringBuffer์ ์ฑ๋ฅ์ ๋จ์ดํธ๋ฆฌ๋ฏ๋ก, StringBuffer์์ ์ฐ๋ ๋์ ๋๊ธฐํ๋ง ๋บ ๊ฒ์ด StringBuilder.
13. java.util.Random ํด๋์ค
Math.random()
์ ๋ด๋ถ์ ์ผ๋ก Randomํด๋์ค์ ์ธ์คํด์ค๋ฅผ ์์ฑํด์ ์ฌ์ฉํ๋ค.Math.random()
๊ณผRandom
์ ๊ฐ์ฅ ํฐ ์ฐจ์ด๋ ์ข ์๊ฐ(seed)์ ์ค์ ํ ์ ์๋ค๋ ๊ฒ์ด๋ค.- ์ข
์๊ฐ์ด ๊ฐ์
Random
์ธ์คํด์ค๋ค์ ํญ์ ๊ฐ์ ๋์๋ฅผ ๊ฐ์ ์์๋๋ก ๋ฐํ - ์์ฑ์
Random()
์ ์ข ์๊ฐ์System.currentTimeMillis()
๋ก ํ๊ธฐ ๋๋ฌธ์ ์คํํ ๋๋ง๋ค ์ป๋ ๋์๊ฐ ๋ฌ๋ผ์ง๋ค.
14. java.util.StringTokenizer ํด๋์ค
- StringTokenizer๋ ๊ธด ๋ฌธ์์ด์ ์ง์ ๋ ๊ตฌ๋ถ์(delimeter)๋ฅผ ๊ธฐ์ค์ผ๋ก ํ ํฐ(token)์ด๋ผ๋ ์ฌ๋ฌ ๊ฐ์ ๋ฌธ์์ด๋ก ์๋ผ๋ด๋ ๋ฐ ์ฌ์ฉ
- StringTokenizer๋ ๊ตฌ๋ถ์๋ก ๋จ ํ๋์ ๋ฌธ์๋ง ์ฌ์ฉ ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ๋ณต์กํ ํํ์ ๊ตฌ๋ถ์๋ ์ ๊ท์์ ์ฌ์ฉํด์ผ ํ๋ค.
StringTokenizer (String str, String delim, boolean returnDelims)
- returnDelims ๊ฐ์ true๋ก ํ๋ฉด ๊ตฌ๋ถ์๋ ํ ํฐ์ผ๋ก ๊ฐ์ฃผํ๋ค.split()
์ ๋น ๋ฌธ์์ด๋ ํ ํฐ์ผ๋ก ์ธ์, StringTokenizer๋ ๋น ๋ฌธ์์ด์ ํ ํฐ์ผ๋ก ์ธ์ ์ํจsplit()
์ ๋ฐ์ดํฐ๋ฅผ ํ ํฐ์ผ๋ก ์๋ผ๋ธ ๊ฒฐ๊ณผ๋ฅผ ๋ฐฐ์ด์ ๋ด์์ ๋ฐํ- StringTokenizer๋ ๋ฐ์ดํฐ๋ฅผ ํ ํฐ์ผ๋ก ๋ฐ๋ก๋ฐ๋ก ์๋ผ์ ๋ฐํํ๋ฏ๋ก
split()
๋ณด๋ค ์ฑ๋ฅ ์ข์
14.1. ํ๊ธ๋ก ๋ ์ซ์๋ฅผ ์๋ผ๋น์ ์ซ์๋ก ๋ณํ
import java.util.*;
class StringTokenizer {
public static void main(String args[]) {
String input = "์ผ์ญ๋ง์ผ์ฒ๋ฐฑ์ญ์ค";
System.out.println(input); // ์ผ์ญ๋ง์ผ์ฒ๋ฐฑ์ญ์ค
System.out.println(hangulToNum(input)); // 303115
}
public static long hangulToNum(String input) {
long result = 0; // ์ต์ข
๋ณํ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ๋ณ์
long tmpResult = 0; // ์ญ๋ฐฑ์ฒ ๋จ์์ ๊ฐ์ ์ ์ฅํ๊ธฐ ์ํ ์์๋ณ์
long num = 0;
final String NUMBER = "์์ผ๋ฆฌ์ผ์ฌ์ค์ก์น ํ๊ตฌ";
final String UNIT = "์ญ๋ฐฑ์ฒ๋ง์ต์กฐ";
final long[] UNIT_NUM = {10,100,1000,10000,(long)1e8,(long)1e12};
StringTokenizer st = new StringTokenizer(input, UNIT, true);
while(st.hasMoreTokens()) {
String token = st.nextToken();
int check = NUMBER.indexOf(token); // ์ซ์์ธ์ง, ๋จ์(UNIT)์ธ์ง ํ์ธ
if(check == -1) {
if("๋ง์ต์กฐ".indexOf(token) == -1) {
tmpResult += ( num!=0 ? num : 1) * UNIT_NUM[UNIT.indexOf(token)];
}else {
tmpResult += num;
result += (tmpResult!=0 ? tmpResult : 1)
* UNIT_NUM[UNIT.indexOf(token)];
tmpResult = 0;
}
num = 0;
}else {
num = check;
}
}
return result + tmpResult + num;
}
}