자바 도전기-15

김치전사·2022년 1월 21일

Java Spring

자바도전기

목록 보기

15/17

java.lang패키지

java.lang패키지는 자바프로그래밍에 가장 기본이 되는 클래스들을 포함하고 있다.
java.lang패키지의 클래스들은 import문 없이도 사용할 수 있게 되어 있다.

Object클래스

Object클래스는 모든 클래스의 최고 조상이기 때문에 Object클래스의 멤버들은 모든 클래스에서 바로 사용 가능하다

Object클래스의 메서드	설 명
protected Object clone( )	객체 자신의 복사본은 반환한다
public boolean equals(Object obj)	객체 자신과 객체 obj가 같은 객체인지 알려준다.(같으면 true)
protected void finalize( )	객체가 소멸될 때 가비지 컬렉터에 의해 자동적으로 호출된다. 이 때 수행되어야하는 코드가 있을 때 오버라이딩한다.(거의 사용안함)
public Class getClass( )	객체 자신의 클래스 정보를 담고 있는 Class인스턴스를 반환한다
public int hashCode( )	객체 자신의 해시코드를 반환한다
public String toString( )	객체 자신의 정보를 문자열로 반환한다
public void notify( )	객체 자신을 사용하려고 기다리는 쓰레드를 하나만 깨운다
public void notifyAll( )	객체 자신을 사용하려고 기다리는 모든 쓰레드를 깨운다
public void wait( ) public void wait(long timeout) public void wait(long timeout, int nanos)	다른 쓰레드가 notify( )나 notifyAll( )을 호출할 때까지 현재 쓰레드를 무한히 또는 지정된 시간(timeout, nanos)동안 기다리게 한다.(timeout은 천 분의 1초, nanos는 109분의 1초)

equals(Object obj)
매개변수로 객체의 참조변수를 받아서 비교하여 그 결과를 boolean값으로 알려 주는 역할을 한다.

public boolean equals(Object obj){
    return (this==obj);
}

hashCode( )
해시함수는 찾고자하는 값을 입력하면, 그 값이 저장된 위치를 알려주는 해시코드(hashcode)를 반환한다

public class HashCodeEx {
    public static void main(String[] args) {
        String str1 = new String("abc");
        String str2 = new String("abc");

        System.out.println(str1.equals(str2));
        System.out.println(str1.hashCode());//96354
        System.out.println(str2.hashCode());//96354
        System.out.println(System.identityHashCode(str1));//2003749087
        System.out.println(System.identityHashCode(str2));//1324119927
    }
}

System.identifyHashCode(Object x)는 Object클래스의 hashCode메서드처럼 객체의 주소값으로 해시코드를 생성하기 때문에 모든 객체에 대해 항상 다른 해시코도값을 반환할 것을 보장한다

toString( )
이 메서드는 인스턴스에 대한 정보를 문자열(String)로 제공할 목적으로 정의한 것이다. 인스턴스의 정보를 제공한다는 것은 대부분의 경우 인스턴스 변수에 저장된 값들을 문자열로 표현한다는 뜻이다

public String toString(){
        return getClass().getName()+"@"+Integer.toHexString(hashCode());
    }

public class ToStringTest {
    public static void main(String[] args) {
        String str = new String("KOREA");
        java.util.Date today = new java.util.Date();

        System.out.println(str);
        System.out.println(str.toString());
        System.out.println(today);
        System.out.println(today.toString());
    }
}

clone( )
이 메서드는 자신을 복제하여 새로운 인스턴스를 생성하는 일을 한다.
어떤 인스턴스에 대해 작업을 할 때, 원래의 인스턴스는 보존하고 clone메서드를 이용해서 새로운 인스턴스를 생성하여 작업을 하면 작업이전의 값이 보존되므로 작업에 실패해서 원래의 상태로 되돌리거나 변경되기 전의 값을 참고하는데 도움이 될 것이다.

public class CloneEx1 {
    public static void main(String[] args) {
        Point original = new Point(3,5);
        Point copy = (Point)original.clone();
        System.out.println(original);
        System.out.println(copy);
    }
}

class Point implements Cloneable{
    int x, y;

    Point(int x,int y){
        this.x=x;
        this.y=y;
    }

    public String toString(){
        return "x="+x+", y="+y;
    }

    public Object clone(){
        Object obj = null;
        try{
            obj= super.clone();//clone()은 반드시 예외처리를 해주어야 한다.
        }catch(CloneNotSupportedException e){}
        return obj;
    }
}

clone( )을 사용하려면, 먼저 복제할 클래스가 Cloneable인터페이스를 구현해야하고, clone( )을 오버라이딩하면서 접근 제어자를 protected에서 public으로 변경한다. 그래야만 상속관계가 없는 다른 클래스에서 clone( )을 호출 할 수 있다.

import java.util.*;

public class CloneEx2 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        int[] arrClone=arr.clone();
        arrClone[0]=6;

        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arrClone));
    }
}

일반적으로 배열을 복사할 때, 같은 길이의 새로운 배열을 생성한 다음에 System.arraycopy( )를 이용해서 내용을 복사하지만, clone( )을 이용해서 간단하게 복사할 수 있다.
얕은 복사와 깊은 복사
clone( )은 단순히 객체에 저장된 값을 그대로 복제할 뿐, 객체가 참조하고 잇는 객체까지 복제하지는 않는다.
기본형 배열인 경우에는 아무런 문제가 없지만, 객체배열을 clone( )으로 복제하는 경우에는 원본과 복제본이 같은 객체를 공유하므로 완전한 복제라고 보기 어렵다.
이러한 복제(복사)를 '얕은 복사(shallow copy)'라고 한다.

class Circle implements Cloneable{
    Point p;//원점
    double r;//반지름

    Circle(Point p, double r){
        this.p=p;
        this.r=r;
    }

    public Circle shallowCopy(){//얕은 복사
        Object obj = null;

        try{
            obj = super.clone();
        }catch(CloneNotSupportedException e){}

        return (Circle)obj;
    }

    public Circle deepCopy(){//깊은 복사
        Object obj = null;

        try{
            obj = super.clone();
        }catch(CloneNotSupportedException e){}

        Circle c = (Circle)obj;
        c.p = new Point(this.p.x, this.p.y);

        return c;
    }

    public String toString(){
        return "[p="+p+ ", r="+r+"]";
    }
}
class Point{
    int x, y;

    Point(int x, int y){
        this.x=x;
        this.y=y;
    }

    public String toString(){
        return "("+x+", "+y+")";
    }
}

public class ShallowDeepCopy {
    public static void main(String[] args) {
        Circle c1 = new Circle(new Point(1,1),2.0);
        Circle c2 = c1.shallowCopy();
        Circle c3 = c1.deepCopy();

        System.out.println("c1="+c1);
        System.out.println("c2="+c2);
        System.out.println("c3="+c3);

        c1.p.x=9;
        c1.p.y=9;
        System.out.println("= c1의 변경 후 =");
        System.out.println("c1="+c1);
        System.out.println("c2="+c2);
        System.out.println("c3="+c3);
    }
}

deepCopy( )는 shallowCopy( )에 위에 두 줄을 추가하여, 복제된 객체가 새로운 Point인스턴스를 참조하도록 했다.

getClass( )
이 메서드는 자신이 속한 클래스의 Class객체를 반환하는 메서드인데, Class객체는 이름이 'Class'인 클래스의 객체이다.

public final class Class implements ...{//Class 클래스
        ...
}

Class객체는 클래스의 모든 정보를 담고 있으며, 클래스 당 1개만 존재한다.
Class객체를 얻는 방법
클래스의 정보가 필요할 때, 먼저 Class객체에 대한 참조를 얻어 와야 하는데, 해당 Class객체에 대한 참조를 얻는 방법은 여러 가지가 있다.

Class cObj = new Card().getClass();//생성된 객체로 부터 얻는 방법
Class cObj = Card.class;//클래스 리터럴(*.class)로 부터 얻는 방법
Class cObj = Class.forName("Card");//클래스 이름으로 부터 얻는 방법

forName( )은 특정 클래스 파일, 예를 들어 데이터베이스 드라이버를 메모리에 올릴 때 주로 사용한다.

Card c = new Card();//new연산자를 이용해서 객체 생성
Card c = Card.class.newInstace();//Class객체를 이용해서 객체 생성

String클래스

String클래스인데, String클래스는 문자열을 저장하고 이를 두르는데 필요한 메서드를 함께 제공한다.

변경 불가능한(immutable) 클래스
인스턴스 생성 시 생성자의 매개변수로 입력받는 문자열은 이 인스턴스변수(value)에 문자형 배열(char[ ])로 저장되는 것이다

public final class String implements java.io.Serializable, Comparable{
    private char[] value;
    ...
}

한번 생성된 String인스턴스가 갖고 있는 문자열은 읽어 올 수만 있고, 변경할 수는 없다.
'+'연산자를 이용해서 문자열을 결합하는 경우 인스턴스내의 문자열이 바뀌는 것이 아니라 새로운 문자열이 담긴 String인스턴스가 생성되는 것이다.
StringBuffer인스턴스에 저장된 문자열은 변경이 가능하므로 하나의 StringBuffer인스턴스만으로도 문자열을 다루는 것이 가능하다.
문자열의 비교

        String str1 = "abc";
        String str2 = "abc";
        String str3 = new String("abc");
        String str4 = new String("abc");

String클래스의 생성자와 메서드

메서드/설명	예제	결과
String(String s) 주어진 문자열(s)을 갖는 String인스턴스를 생성한다.	String s = new String("hello");	s= "hello";
String(char[ ] value) 주어진 문자열(value)을 갖는 String인스턴스를 생성한다	Char[ ] c={'H','e','l','l','o'}; String s = new String(c);	s = "Hello";
String(StringBuffer buf) StringBuffer인스턴스가 갖고 있는 문자열과 같은 내영의 String인스턴스를 생성한다	StringBuffer sb = new StringBuffer("hello"); String s = new String(sb);	s = "hello";
char charAt(int index) 지정된 위치(index)에 있는 문자를 알려준다 (index는 0부터 시작)	String s = "Hello"; String n = "0123456"; char c = s.charAt(1); char c2 = n.charAt(1);	c = 'e' c2 = '1'
int compareTo(String str) 문자열(str)과 사전순서로 비교한다. 같으면, 0을, 사전순으로 이전이면 음수를, 이후면 양수를 반환한다	int i ="aaa".compareTo("aaa"); int i2 ="aaa".compareTo("bbb"); int i3="bbb".compareTo("aaa");	i = 0 i2 = -1 i3 = 1
String concat(String str) 문자열(str)을 뒤에 덧붙인다	String s = "Hello"; String s2=s.concat(" World");	s2="Hello World";
boolean contains(CharSequence s) 지정된 문자열(s)이 포함되었는지 검사한다.	String s ="abcedfg"; boolean b = s.contains("bc");	b = true
boolean endsWith(String suffix) 지정된 문자열(suffix)로 끝나는지 검사한다.	String file = "Hello.txt"; boolean b = file.endsWith("txt");	b=true
boolean equals(Object obj) 매개변수로 받은 문자열(obj)과 String인스턴스의 문자열을 비교한다. obj가 String이 아니거나 문자열이 다르면 false를 반환한다	String s = "hello"; boolean b = s.equals("hello); booelan b2 = s.equals("Hello);	b=true b=false
boolean equalsIgnoreCase(String str) 문자열과 String인스턴스의 문자열을 대소문자 구분없이 비교한다	String s = "Hello"; booelan b = s.equalsIgnoreCase("HELLO"); boolean b2 = s.equalsIgnoreCase("heLLo");	b = true b2 = true
int indexOf(int ch) 주어진 문자(ch)가 문자열에 존재하는지 확인하여 위치(index)를 알려준다. 못 찾으면 -1을 반환한다.(index는 0부터 시작)	String s = "Hello"; int idx1 = s.indexOf('o'); int idx2 = s.indexOf('k');	idx1 = 4 idx2 = -1
int indexOf(int ch, int pos) 주어진 문자(ch)가 문자열에 존재하는지 지정된 위치(pos)부터 확인하여 위치(index)를 알려준다. 못 찾으면 -1을 반환한다.(index는 0부터 시작)	String s = "Hello"; int idex = s.indexOf('e',0); int idx2 = s.indexOf('e',2);	idx1 = 1 idx2 = -1
int indexOf(String str) 주어진 문자열이 존재하는지 확인하여 그 위치(index)를 알려준다. 없으면 -1을 반환한다.(index는 0부터 시작)	String s = "ABCDEFG"; int idx = s.indexOf("CD");	idx = 2
String intern( ) 문자열이 상수풀(constant pool)에 등록한다. 이미 상수풀에 같은 내용의 문자열이 있을 경우 그 문자열의 주소값을 반환한다	String s = new String("abc"); String s2 = new String("abc"); boolean b = (s==s2); boolean b2 = s.equals(s2); boolean b3 = (s.intern()==s2.intern());	b = false b2 = true b3 = true
int lastIndexOf(int ch) 지정된 문자 도는 문자코드를 문자열의 오른쪽 끝에서부터 찾아서 위치(index)를 알려준다. 못 찾으면 -1을 반환한다	String s = "java.lang.Object"; int idx1 = s.lastIndexOf('.'); int idx2 = s.indexOf('.');	idx1 = 9 idx2 = 4
int length( ) 문자열의 길이를 알려준다	String s = "Hello"; int length = s.length( );	length = 5;
String replace(char old, char nw) 문자열 중의 문자(old)를 새로운 문자(nw)로 바꾼 문자열을 반환한다	String s = "Hello"; String s1 = s.replace('H','C');	s1 = "Cello"
String replace(CharSequence old, CharSequence nw) 문자열 중의 문자열(old)을 새로운 문자열(nw)로 모두 바꾼 문자열을 반환한다	String s = "Hellollo"; String s1 = s.replace("ll","LL");	s1="HeLLoLLo"
String replaceAll(String regex, String replacement) 문자열 중에서 지정된 문자열(regex)과 일치하는 것을 새로운 문자열(replacement)로 모두 변경한다.	String ab = "AABBAABB"; String r = ab.replaceAll("BB","bb");	r="AAbbAAbb"
String replaceFirst(String regex, String replacement) 문자열 중에서 지정된 문자열(regex)과 일치 하는 것 중, 첫 번째 것만 새로운 문자열(replacement)로 변경한다	String ab = "AABBAABB"; >String r = ab.replaceFirst("BB","bb");	r="AAbbAAbb"
String split(String regex) 문자열을 지정된 분리자(regex)로 나누어 문자열 배열에 담아 반환한다	String animals = "dog,cat,bear"; String[] arr = animals.split(",");	arr[0] = "dog" arr[1] = "cat" arr[2] = "bear"
String[ ] split(String regex, int limit) 문자열을 지정된 분리자(regex)로 나누어 문자열배열에 담아 반환한다. 단, 문자열 전체를 지정된 수(limit)로 자른다	String animals = "dog,cat,bear"; String[ ] arr=animals.split(",",2);	arr[0]="dog" arr[1]="cat,bear"
boolean startsWith(String prefix) 주어진 문자열(prefix)로 시작하는지 검사한다	String s = "java.lang.Object"; booelan b = s.startsWith("java"); boolean b2=s.startsWith("lang");	b = true b2 = false
String substring(int begin) String substring(int begin, int end) 주어진 시작위치(begin)부터 끝 위치(end) 범위에 포함된 문자열을 얻는다. 이 때, 시작위치의 문자는 범위에 포함되지만, 끝 위치의 문자는 포함되지 않는다(begin<=x<end)	String s = "java.lang.Object"; String c = s.substring(10); String p = s.substring(5,9);	c = "Object" p = "lang"
String toLowerCase( ) String인스턴스에 저장되어있는 모든 문자열을 소문자로 변환하여 반환한다	String s = "Hello"; String s1 = s.toLowerCase( );	s1 = "hello"
String toString( ) String인스턴스에 저장되어 있는 문자열을 반환한다	String s = "Hello"; String s1 = s.toString( );	s1 = "Hello"
String toUpperCase( ) String인스턴스에 저장되어있는 모든 문자열을 대문자로 변환하여 반환한다	String s = "Hello"; String s1 = s.toUpperCase( );	s1 = "HELLO"
String trim( ) 문자열의 왼쪽 끝과 오른쪽 끝에 있는 공백을 없앤 결과를 반환한다. 이 때 문자열 중간에 있는 공백은 제거되지 않는다	String s =" Hello World "; String s1 = s.trim( );	s1="Hello World"
static String valueOf(booelan b) static String valueOf(char c) static String valueOf(int i) static String valueOf(long l) static String valueOf(float f) static String valueOf(double d) static String valueOf(Object o) 지정된 값을 문자열로 반환한다. 참조변수의 경우, toString( )을 호출한 결과를 반환한다	String b=String.valueOf(true); String c = String.valueOf('a'); String i = String.valueOf(100); String l=String.valueOf(100L); String f = String.valueOf(10f); String d=String.valueOf(10.0); java.util.Date dd = new java.util.Date(); String date=String.valueOf(dd);	b = "true" c = "a" i ="100" l = "100" f = "10.0" d = "10.0"" date = "Sun Jan 17 01:33:10 KST 2022"

join( )과 StringJoiner
join( )은 여러 문자열 사이에 구분자를 넣어서 결합한다.

String animals = "dog,cat,bear";
String[] arr= animals.split(",");
String str = String.join("-",arr);
System.out.println(str);//dog-cat-bear

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]

String.format( )
format( )은 형식화된 문자열을 만들어내는 간단한 방법이다. printf( )하고 사용법이 완전히 똑같다.

String str = String.format("%d 더하기 %d는 %d입니다",3,5,3+5);
System.out.println(str);//3 더하기 5는 8입니다.

기본형 값을 String으로 변환
기본형을 문자열로 변경하는 방법은 간단하다. 숫자에 빈 문자열""을 더해주기만 하면 된다. 이 외에도 valueOf( )를 사용하는 방법도 있다.

int i = 100;
String str1 = i + "";//"100"
String str2 = String.valueOf(i);//"100"

String을 기본형 값으로 변환
valueOf( )를 쓰거나 앞서 배운 parseInt( )를 사용하면 된다.

int i = Integer.parseInt("100");//100
int i2 = Integer.valueOf("100");//100

기본형 -> 문자열	문자열 -> 기본형
String String.valueOf(boolean b) String String.valueOf(char c) String String.valueIf(int i) String String.valueOf(long l) String String.valueOf(float f) String String.valueOf(double d)	boolean Boolean.parseBoolean(String s) byte Byte.parseByte(String s) short Short.parseShort(String s) int Interger.parseInt(String s) long Long.parseLong(String s) float Float.parseFloat(String s) double Double.parseDouble(String s)

public class StringEx7 {
    public static void main(String[] args) {
        String fullName = "Hello.java";

        int index = fullName.indexOf('.');

        String fileName=fullName.substring(0,index);
        String ext=fullName.substring(index+1);

        System.out.println(fullName+"의 확장자를 제외한 이름은 "+fileName);//Hello.java의 확장자를 제외한 이름은 Hello
        System.out.println(fullName+"의 확장자는 "+ext);//Hello.java의 확장자는 java
    }
}

StringBuffer클래스와 StringBuilder클래스

String클래스는 인스턴스를 생성할 때 지정된 문자열을 변경할 수 없지만 StringBuffer클래스는 변경이 가능하다.
내부적으로 버퍼(Buffer)를 사지고 있으며, StringBuffer인스턴스를 생성할 때 그 크기를 지정할 수 있다.
StringBuffer의 생성자
StringBuffer인스턴스를 생성할 때, 버퍼의 크기를 지정해주지 않으면 16개의 문자를 저장할 수 있는 크기의 버퍼를 생성한다

public StringBuffer(int length){
    value = new char[length];
    shared = false;
}

public StringBuffer(){
    this(16);//버퍼의 크기를 지정하지 않으면 버퍼의 크기는 16이 된다
}

public StringBuffer(String str){
    this(str.length()+16);//지정한 문자열의 길이보다 16이 더 크게 버퍼를 생성한다
    append(str);
}

StringBuffer의 변경
String과 달리 StringBuffer는 내용을 변경할 수 있다.

        StringBuffer sb = new StringBuffer("abc");
        System.out.println(sb);//abc
        sb.append("123");
        System.out.println(sb);//abc123
        StringBuffer sb2 = sb.append("ZZ");
        System.out.println(sb);//abc123zz
        System.out.println(sb2);//abc123zz

StringBuffer의 비교
StringBuffer클래스는 equals메서드를 오버라이딩하지 않아서 StringBuffer클래스의 equals메서드를 사용해도 등가비교연산자(==)로 비교한 것과 같은 결과를 얻는다.

	StringBuffer sb = new StringBuffer("abc");
	StringBuffer sb2 = new StringBuffer("abc");
        System.out.println(sb==sb2);//false
        System.out.println(sb.equals(sb2));//false

StringBuffer클래스의 생성자와 메서드

메서드/설명	예제/결과
StringBuffer( )	StringBuffer sb = new StringBuffer( );
16문자를 담을 수 있는 버퍼를 가진 StringBuffer 인스턴스를 생성한다	sb = ""
StringBuffer(int length)	StringBuffer sb = new StringBuffer(10);
지정된 개수의 문자를 담을 수 있는 버퍼를 가진 StringBuffer인스턴스를 생성한다	sb = ""
StringBuffer(String str)	StringBuffer sb = new StringBuffer("Hi");
지정된 문자열 값(str)을 갖는 StringBuffer 인스턴스를 생성한다	sb = "Hi"
StringBuffer append(boolean b) StringBuffer append(char c) StringBuffer append(char[ ] str) StringBuffer append(double d) StringBuffer append(float f) StringBuffer append(int i) StringBuffer append(long l) StringBuffer append(Object obj) StringBuffer append(String str)	StringBuffer sb = new StringBuffer("abc"); StringBuffer sb2 = sb.append(true); sb.append('d').append(10.0f); StringBuffer sb3 = sb.append("ABC").append(123);
매개변수로 입력된 값을 문자열로 변환하여 StringBuffer인스턴스가 저장하고 있는 문자열의 뒤에 덧붙인다	sb = "abctrued10.0ABC123" sb2 = "abctrued10.0ABC123" sb3 = "abctrued10.0ABC123"
int capacity( )	StringBuffer sb = new StringBuffer(100); sb.append("abcd"); int bufferSize = sb.capacity( ); int stringSize = sb.length( );
StringBuffer인스턴스의 버퍼크기를 알려준다. length( )는 버퍼에 담긴 문자열의 길이를 알려준다	bufferSize = 100; stringSize = 4(sb에 담긴 문자열이 "abcd"이므로)
char charAt(int index)	StringBuffer sb = new StringBuffer("abc'); char c = sb.charAt(2);
지정된 위치(index)에 있는 문자를 반환한다	c='c'
StringBuffer delete(int start, int end)	StringBuffer sb = new StringBuffer("0123456"); StringBuffer sb2 = sb.delete(3,6);
시작위치(start)부터 끝 위치(end) 사이에 있는 문자를 제거한다. 단, 끝 위치의 문자는 제외	sb = "0126" sb2 = "0126"
StringBuffer deleteCharAt(int index)	StringBuffer sb = new StringBuffer("0123456"); sb.deleteCharAt(3);
지정된 위치(index)의 문자를 제거한다	sb = "012456"
StringBuffer insert(int pos, boolean b) StringBuffer insert(int pos, char c) StringBuffer insert(int pos, char[ ] str) StringBuffer insert(int pos, double d) StringBuffer insert(int pos, float f) StringBuffer insert(int pos, int i) StringBuffer insert(int pos, long l) StringBuffer insert((int pos, Object obj) StringBuffer insert(int pos, String str)	StringBuffer sb = new StringBuffer("0123456"); sb.insert(4,'.');
두 번째 매개변수로 받은 값을 문자열로 변환하여 지정된 위치(pos)에 추가한다. pos는 0부터 시작	sb = "0123.456"
int length( )	StringBuffer sb = new StringBuffer("0123456"); int length = sb.length( );
StringBuffer인스턴스에 저장되어 있는 문자열ㄹ의 길이를 반환한다	length = 7
StringBuffer replace(int start, int end, String str)	StringBuffer sb = new StringBuffer("0123456"); sb.replace(3,6,"AB");
지정된 범위(start~end)의 문자들을 주어진 문자열로 바꾼다. end위치의 문자는 범위에 포함 되지 않음(start<=x<end)	sb = "0123AB6" //"345"를 "AB"로 바꿨다.
String reverse( )	StringBuffer sb = new StringBuffer("0123456"); sb.reverse( );
StringBuffer인스턴스에 저장되어 있는 문자열의 순서를 거꾸로 나열한다	sb = "6543210"
void setCharAt(int index, char ch)	StringBuffer sb = new StringBuffer("0123456"); sb.setCharAt(5, 'o');
지정된 위치의 문자를 주어진 문자(ch)로 바꾼다.	sb = "01234o6"
void setLength(int newLength)	StringBuffer sb = new StringBuffer("0123456"); sb.setLength(5); StringBuffer sb2 = new StringBuffer("0123456"); sb2.setLength(10); String str = sb2.toString( ).trim( );
지정된 길이로 문자열의 길이를 변경한다. 길이를 늘리는 경우에 나머지 빈 공간을 널문자 '\u0000'로 채운다	sb = "01234" sb2 = "0123456 " str = "0123456"
String toString( )	StringBuffer sb = new StringBuffer("0123456"); String str = sb.toString( );
StringBuffer인스턴스의 문자열을 String으로 반환	str = "0123456"
String substring(int start) String substring(int start, int end)	StringBuffer sb = new StringBUffer("0123456"); String str = sb.substring(3); String str2 = sb.substring(3, 5);
지정된 범위 내의 문자열을 String으로 뽑아서 반환한다. 시작위치(start)만 지정하면 시작위치부터 문자열 끝까지 뽑아서 반환한다.	str = "3456" str2 = "34"

StringBuilder란?
StringBuffer에서 쓰레드의 동기화만 뺀 StringBuilder가 새로 추가되었다.
StringBuilder는 StringBuffer와 완전히 똑같은 기능으로 작성되어 있어서, 소스코드에서 StringBuffer대신 StringBuilder를 사용하도록 바꾸기만 하면 된다.

Math클래스

Ceil	Round	Rint	Float
올림	반올림	반올림	내림

import static java.lang.Math.;
import static java.lang.System.;

rint( )도 round( )처럼 소수점 첫 째자리에서 반올림하지만, 반환값이 double이다.
예외를 발생시키는 메서드
메서드 이름에 'Exact'가 포함된 메서드들이 새로 추가되었다. 이들은 정수형간의 연산에서 발생할 수 있는 오버플로우(overflow)를 감지하기 위한 것이다.

int addExact(int x,int y) //x+y;
int subtractExact(int x,int y)//x-y
int multiplyExact(int x,int y)//x*y
int incrementExact(int a)//a++ 
int decrementExact(int a)//a--
int negateExact(int a)//-a
int toIntExact(long value)//(int)value - int로의 형변환

위의 메서드들은 오버플로우가 발생하면, 예외(ArithmeticException)를 발생시킨다.

메서드	설명	예제
static double abs(double a) static float abs(float f) static int abs(int f) static long abs(long f)	주어진 값의 절대값을 반환한다.	Math.abs( )
static double ceil(double a)	주어진 값을 올림하여 반환한다	Math.ceil( )
static double floor(double a)	주어진 값을 버림하여 반환한다	Math.floor( )
static double max(double a, double b) static float max(float a, float b) static int max(int a, int b) static long max(long a, long b)	주어진 두 값을 비교하여 큰 쪽을 반환한다	Math.max( )
static double min(double a, double b) static float min(float a, float b) static int min(int a, int b) static long min(long a, long b)	주어진 두 값을 비교하여 작은 쪽을 반환한다	Math.min( )
static double random( )	0.0~1.0범위의 임의의 double값을 반환한다.(1.0은 범위에 포함되지 않는다	Math.random( )
static double rint(double a)	주어진 double값과 가장 가까운 정수값을 double형으로 반환한다. 단, 두 정수의 정가운데 있는 값(1.5, 2.5, 3.5 등)은 짝수를 반환	Math.rint( )
static long round(double a) static long round(float a)	소수점 첫째자리에서 반올림한 정수값(long)을 반환한다. 매개변수의 값이 음수인 경우, round( )와 rint( )의 결과가 다르다는 것에 주의하자.	Math.round( )

래퍼(wrapper) 클래스

객체지향 개념에서 모든 것은 객체로 다루어져야 한다.
기본형 값들을 객체로 변환하여 작업을 수행해야 하는데 이 때 사용되는 것이 래퍼(wapper)클래스이다.

기본형	래퍼클래스	생성자	활용예
boolean	Boolean	Boolean(boolean value) Boolean(String s)	Boolean b = new Boolean(true); Boolean b2 = new Boolean("true");
char	Character	Character(char value)	Character c = new Character('a');
byte	Byte	Byte(byte value) Byte(String s)	Byte b = new Byte(10); Byte b2 = new Byte("10");
short	Short	Short(short value) Short(String s)	Shrot s = new Short(10); Srhot s2 = new Short("10");
int	Integer	Integer(int value) Integer(String s)	Interger i = new Integer(100); Integer i2 = new Integer("100");
long	Long	Long(loong value) Long(String s)	Long l = new Long(100); Long l2 = new Long("100");
float	Float	Float(double value) Float(float value) Float(String s)	Float f = new Float(1.0); Float f2 = new Float(1.0f); Float f3 = new Float("1.0f");
double	Double	Double(double value) Double(String s)	Double d = new Double(1.0); Double d2 = new Double("1.0");

Number클래스
Number클래스 자손으로 BigInteger와 BigDecimal 등이 있는데, BigInteger는 long으로도 다룰 수 없는 큰 범위의 정수를, BigDecimal은 double로도 다룰 수 없는 큰 범위의 부동 소수점수를 처리한다.

문자열->기본형	문자열->래퍼 클래스
byte b = Byte.parseByte("100"); short s = Short.parseShort("100"); int i = Integer.parseInt("100"); long i = Long.parseLong("100"); float f = Float.parseFloat("3.14"); double d = Double.parseDouble("3.14");	Byte b = Byte.valueOf("100"); Short s = Short.valueOf("100"); Integer i = Integer.valueOf("100"); Long l = Long.valueOf("100"); Float f = Float.valueOf("3.14"); Double d = Double.valueOf("3.14");

오토박싱 & 언박싱(autoboxing & unboxing)
기본형 값을 래퍼 클래스의 객체로 자동 변환해주는 것을 '오토박싱(autoboxing)'이라고 하고, 반대로 변환하는 것을 '언박싱(unboxing)'이라고 한다.

유용한 클래스

java.util.Objects클래스

Object클래스의 보조 클래스로 Math클래스처럼 모든 메서드가 'static'이다.
객체의 비교나 널 체크(null check)에 유용하다.
isNull( )은 해당 객체가 널인지 확인해서 null 이면 true를 반환하고 아니면 false를 반환한다.
nonNull( )은 isNull( )과 정반대의 일을 한다. 즉, !Object.isNull(obj)와 같다.

static boolean isNull(Object obj)
static boolean nonNull(Object obj)

requireNonNull( )은 해당 객체가 널이 아니어야 하는 경우에 사용한다. 만일 객체가 널이면, NullPointerException을 발생시킨다.

    void setName(String name){
        if(name==null){
            throw new NullPointerException("name must not be null.");
        }
        this.name=name;
    }
    
    void setName(String name){
        this.name= Objects.requireNonNull(name,"name must not be null");
    }

Objects에는 compare( )가 추가되었다. compare( )는 두 비교대상이 같으면 0, 크면 양수, 작으면 음수를 반환한다.

static int compare(Object a, Object b, Comparator c);

java.util.Random클래스

Random클래스를 사용하면 난수를 얻을 수 있다.

double randNum = Math.random();
double randNum = new Random().nextDouble();//위의 문장과 동일

1~6사이의 정수를 나수로 얻고자 할 때는 다음과 같다

int num = (int)(Math.random()*6)+1;
int num = new Random().nextInt(6)+1;//nextInt(6)은 0~6사이의 정수를 반환

Random클래스의 생성자와 메서드
생성자 Random( )은 종자값을 System.currentTimeMillis( )로 하기 대문에 실행할 때마다 얻는 난수가 달라진다.

public Random(){
	this(System.currentTimeMillis());//Random(long seed)를 호출한다
}

메서드	설명
Random( )	현재시간(System.currentTimeMillis( ))을 종자값(seed)으로 이용하는 Random인스턴스를 생성한다
Random(long seed)	매개변수seed를 종자값으로 하는 Random인스턴스를 생성한다
boolean nextBoolean( )	boolean타입의 난수를 반환한다
void nextBytes(byte[ ] bytes)	bytes배열에 byte타입의 난수를 채워서 반환한다
double nextDouble( )	double타입의 난수를 반환한다(0.0<=x<1.0)
float nextFLoat( )	float타입의 난수를 반환한다(0.0<=x<1.0)
double nextGaussian( )	평균은 0.0이고 표준편자는 1.0인 가우시안(Gaussian)분포에 따른 double형의 난수를 반환한다
int nextInt( )	int타입의 난수를 반환한다(int의 범위)
int nextInt(int n)	0~n의 범위에 있는 int값을 반환한다(n은 범위에 포함되지 않음)
long nextLong( )	long타입의 난수를 반환한다(long의 범위)
void setSeed(long seed)	종자값을 주어진 값(seed)으로 변경한다

int[ ] fileRand(int[ ] arr, int from, int to)
: 배열 arr을 from과 to범위의 값드로 채워서 반환한다
int[ ] fileRand(int[ ] arr, int[ ] data)
: 배열 arr을 배열 data에 있는 값들로 채워서 반환한다
int getRand(int from, int to)
:from과 to범위의 정수(int)값을 반환한다. from과 to 모두 범위에 포함된다

정규식(Regular Expression) - java.util.regex패키지

정규식이란 텍스트 데이터 중에서 원하는 조건(패턴, pattern)과 일치하는 문자열을 찾아내기 위해 사용하는 것으로 미리 정의된 기호와 문자를 이용해서 작성한 문자열을 말한다.

import java.util.regex.*;

public class RegularEx1 {
    public static void main(String[] args) {
        String[] data = {"bat","baby","bonus","cA","ca","co","c.","c0","car","combat","count","date","disc"};
        Pattern p = Pattern.compile("c[a-z]*");//c로 시작하는 소문자영단어

        for(int i=0;i<data.length;i++){
            Matcher m = p.matcher(data[i]);
            if(m.matches()){
                System.out.print(data[i]+",");//ca,co,car,combat,count
            }
        }
    }
}

Pattern은 정규식을 정의하는데 사용되고 Matcher는 정규식(패턴)을 데이터와 비교하는 역할을 한다.

정규식을 매개변수로 Pattern클래스의 static메서드인 Pattern compile(String regex)을 호출하여 Pattern인스턴스를 얻는다
Pattern p = Pattern.compile("c[a-z]*");
정규식으로 비교할 대상을 매개변수로 Pattern클래스의 Matcher matcher(CharSequence input)를 호출해서 Matcher인스턴스를 얻는다.
Matcher m = p.matcher(data[i]);
Matcher인스턴스에 boolean matches( )를 호출해서 정규식에 부합하는지 확인한다.
if(m.matches( ))

정규식 패턴	설명	결과
c[a-z]*	c로 시작하는 영단어	c, ca, co, car, combat, count,
c[a-z]	c로 시작하는 두 자리 영단어	ca, co
c[a-zA-Z]	c로 시작하는 두 자리 영단어 (a~z 또는 A~Z, 즉 대소문자 구분안함)	cA, ca, co,
.*	모든 문자열	bat, baby, bonus, c, cA, ca, co, c#, date, disc,
c.	c로 시작하는 두 자리 문자열	cA, co, c., c0, c#
c.*	c로 시작하는 모든 문자열(기호포함)	cA, ca, c0, c#, combat, count,
c\.	c.와 일치하는 문자열'.'은 패턴작성에 사용되는 문자이므로 escape문자인 '\'을 사용해야한다.	c.,
c\d c[0-9]	c와 숫자로 구성된 두 자리 문자열	c0,
c.*t	c로 시작하고 t로 끝나는 모든 문자열	combat, count,
[b\|c].* [bc].* [b-c].*	b 또는 c로 시작하는 문자열	bat, baby, bonus, c, cA, c0, c#, combat,
[^b\|c].* [^bc].* [^b-c].*	b 또는 c로 시작하지 않는 문자열	date, disc,
.a.	a를 포함하는 모든 문자열 *: 0 또는 그 이상의 문자	bat, baby, ca, car, combat, date,
.*a.+	a를 포함하는 모든 문자열 +: 1 또는 그 이상의 문자. '+'는 '*'과는 달리 반드시 하나 이상의 문자가 있어야 하므로 a로 끝나는 단어는 포함되지 않았다.	bat, baby, car, combat, date
[b\|c].{2}	b 또는 c로 시작하는 세 자리 문자열.(b 또는 c 다음에 두 자리이므로 모두 세 자리)	bat, car,

정규식 패턴	설명
0\\d{1,2}	0으로 시작하는 최소 2자리 최대 3자리 숫자(0포함)
\\d{3,4}	최소 3자리 최대 4자리의 숫자
\\d{4}	4자리의 숫자

java.util.Scanner클래스

Scanner는 화면, 파일, 문잦열과 같은 입력소스로부터 문자데이터를 읽어오는데 도움을 줄 목적으로 추가되었다.

        Scanner(String source)
        Scanner(File source)
        Scanner(InputStream source)
        Scanner(Readable source)
        Scanner(ReadableByteChannel source)
        Scanner(Path source)

Scanner는 정규식 표현(Regular expression)을 이용한 라인단위의 검색을 지원하며 구분자(delimiter)에도 정규식 표현을 사용할 수 있어서 복잡한 형태의 구분자도 처리가 가능하다

Scanner useDelimiter(Pattern pattern)
Scanner useDelimiter(String pattern)

java.util.StringTokenizer클래스

StringTokenizer는 긴 문자열을 지정된 구분자(delimiter)를 기준으로 토큰(token)이라는 여러 개의 문자열로 잘라내는 데 사용된다.
정규식 표현(Regular expression)에 익숙하지 않은 경우 StringTokenizer를 사용하는 것이 간단하면서도 명확한 결과를 얻을 수 있을 것이다.
그러나 StringTokenizer는 구분자로 단 하나의 문자 밖에 사용하지 못하기 때문에 보다 복잡한 형태의 구분자로 문자열을 나누어야 할 때에는 어쩔 수 없이 정규식을 사용하는 메서드를 사용해야 할 것이다.
StringTokenizer의 생성자와 메서드

생성자/메서드	설명
StringTokenizer(String str, String delim)	문자열(str)을 지정된 구분자(delim)로 나누는 StringTokenizer를 생성한다(구분자는 토큰으로 간주되지 않음)
StringTokenizer(String str, String delim, boolean returnDelims)	문자열(str)을 지정된 구분자(delim)로 나누는 StringTokenizer를 생성한다. returnDelims의 값을 true로 하면 구분자도 토큰으로 간주된다
int countTokens( )	전체 토큰의 수를 반환한다
boolean hasMoreTokens( )	토큰이 남아있는지 알려준다.
String nextToken( )	다음 토큰을 반환한다

import java.util.*;

public class StringTokenizerEx1 {
    public static void main(String[] args) {
        String source = "100,200,300,400";
        StringTokenizer st = new StringTokenizer(source,",");

        while(st.hasMoreTokens()){
            System.out.println(st.nextToken());//100 200 300 400
        }
    }
}

java.math.BigInteger클래스

BigInteger는 내부적으로 int배열을 사용해서 값을 다룬다.
BigInteger는 String처럼 불변(immutable)이다. 그리고 모든 정수형이 그렇듯이 BigInteger 역시 값을 '2의 보수'의 형태로 표현한다.

BigInteger val = new BigInteger("1234567891234567890");//문자열로 생성
BigInteger val = new BigInteger("FFFF",16);//n진수(radix)의 문자열로 생성
BigInteger val = new BigInteger.valueOf(1234567890L);//숫자로 생성

BigInteger를 문자열, 또는 byte배열로 변환하는 메서드는 다음과 같다

String toString()//문자열로 변환
String toString(int radix)//지정된 진법(radix)의 문자열로 변환
byte[] toByteArray()//byte배열로 변환

BigInteger에는 정수형으로 사용할 수 잇는 모든 연산자와 수학적인 계산을 쉽게 해주는 메서드들이 정의되어 있다.

BigInteger add(BigInteger val)//덧셈(this+val)
BigInteger subtract(BigInteger val)//뺄셈(this-val)
BigInteger multiply(BigInteger val)//곱셈(this * val)
BigInteger divide(BigInteger val)//나눗셈(this/val)
BigInteger remainder(BigInteger val)//나머지(this%val)

워낙 큰 숫자를 다루기 위한 클래스이므로, 성능을 향상시키기 위해 비트단위로 연산을 수행하는 메서드들을 많이 가지고 있다.

int bitCount() //2진수로 표현했을 때, 1의 개수(음수는 0의 개수)를 반환
int bitLength() //2진수로 표현했을 때, 값을 표현하는데 필요한 bit수
boolean testBit(int n) //우측에서 n+1번째 비트가 1이면 true, 0이면 false
BigInteger setBit(int n) //우측에서 n+1번째 비트를 1로 변경
BigInteger clearBit(int n) //우측에서 n+1번째 비트를 0으로 변경
BigInteger flipBit(int n) //우측에서 n+1번째 비트를 전황(1->0, 0->1)

java.math.BigDecimal클래스

double타입으로 표현할 수 있는 값은 상당히 범위가 넓지만, 정밀로가 최대 13자리 밖에 되지 않고 실수형의 특성상 오차를 피할 수 없다. BigDecimal은 실수형과 달리 정수를 이용해서 실수를 표현한다.
정수 X 10-scale
scale은 0부터 Integer.MAX_VALUE사이의 범위에 있는 값이다.
그리고 BigDecimal은 정수를 저장하는데 BigInteger를 사용한다.

BigDecimal val = new BigDecimal("123.45"); //12345*10^-2
System.out.println(val.unscaledValue()); //12345
System.out.println(val.scale()); //2
System.out.println(val.precision()); //5

scale은 소수점 이하의 자리수를 의미하고 precision은 정수의 전체 자리수를 의미한다

BigDecimal을 문자열로 변환하는 메서드는 다음과 같다

String toPlainString() //어떤 경우에도 다른 기호없이 숫자로만 표현
String toString() //필요하면 지수형태로 표현할 수도 있음

BigDecimal에는 실수형에 사용할 수 있는 모든 연산자와 수학적인 계산을 쉽게 해주는 메서드들이 정의되어 있다.

BigDecimal add(BigDecimal val) //덧셈(this + val)
BigDecimal substract(BigDecimal val) //뺄셈(this + val)
BigDecimal multiply(BigDecimal val) //곱셈(this * val)
BigDecimal divide(BigDecimal val) //나눗셈(this / val)
BigDecimal remainder(BigDecimal val) //나머지(this % val)

반올림 모드 - divide( )와 setScale( )

BigDecimal divide(BigDecimal divisor)
BigDecimal divide(BigDecimal divisor, int roundingMode)
BigDecimal divide(BigDecimal divisor, RoundingMode roundingMode)
BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)
BigDecimal divide(BigDecimal divisor, MathContext mc)

roundingMode는 반올림 처리방법에 대한 것으로 BigDecimal에 정의된 'ROUND_'로 시작하는 상수들 중에 하나를 선택해서 사용하면 된다.
가능한 열거형 RoundingMode를 사용하자

상수	설명
CEILING	올림
FLOOR	내림
UP	양수일 때는 올림, 음수일 때는 내림
DOWN	양수일 때는 내림, 음수일 때는 올림(UP과 반대)
HALF_UP	반올림(5이상 올림, 5미만 버림)
HALF_EVEN	반올림(반올림 자리의 값이 짝수면 HALF_DOWN, 홀수면 HALF_UP)
HALF_DOWN	반올림(6이상 올림, 6미만 버림)
UNNECESSARY	나눗셈의 결과가 딱 떨어지는 수가 아니면, ArithmeticException발생

java.math.MathContext클래스는 반올림 모드와 정밀로(precision)을 하나로 묶어 놓은 것일 뿐 별다른 것은 없다.
한 가지 주의할 점은 divide( )에서는 scale이 소수점 이하의 자리수를 의미하는데, MathContext에서는 precision이 정수와 소수점 이하를 모두 포함한 자리수를 의미한다.
BigDecimal을 10으로 곱하거나 나누는 대신 scale의 값을 변경함으로써 같은 결과를 얻을 수 있다. BigDecimal의 scale을 변경하려면, setScale( )을 이용하면 된다.

BigDecimal setScale(int newScale)
BigDecimal setScale(int newScale, int roundingMode)
BigDecimal setScale(int newScale, RoundingMode mode)

setScale( )로 scale의 값을 줄이는 것은 10의 n제곱으로 나누는 것과 같으므로, divide( )를 호출할 때처럼 오차가 발생할 수 있고 반올림 모드를 지정해 주어야 한다.

김치전사

개인공부 블로그입니다. 상업적 용도 X

이전 포스트

자바 도전기-14

다음 포스트

자바 도전기-15