[자바의 정석] Object, String, StringBuffer 클래스 정리

Object Class

Object class는 모든 클래스의 최고 조상이며 오직 11개의 메서드만을 가지고 있다.

• equals(Object obj), hashCode(), toString()은 상황에 맞게 적절히 오버 라이딩해야 한다.

Object class에 있는 11개의 메서드에 대해 알아보기

• protected Object clone()
  • 객체 자신의 복사본을 반환한다.
• public boolean equals(Object obj)
  • 객체 자신과 객체 obj가 같은 객체인지 알려준다.
• 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) 동안 기다리게 한다.

public boolean equals(Object obj)

객체 자신과 주어진 객체(obj)를 비교하여 같으면 true를 반환한다.

• Object 클래스에서 정의된 equals()는 참조 변수 값( 객체의 주소 )을 비교한다.
• equals()를 오버 라이딩해서 인스턴스 변수의 값을 비교하도록 한다.
• equals()를 오버 라이딩하면 hashCode()도 같이 오버 라이딩해줘야 한다.
  • equals()의 결과가 true이면 두 객체의 해시 코드 또한 같아야 하기 때문이다.

class Person{
    long id;
    
    public boolean equals(Object obj){
        if(obj != null && obj instanceof Person){
            return id == ((Person)obj).id;
        }else{
            return false;
        }
    }
    
    Person(long id){
        this.id = id;
    }
}

Person p1 = new Person(80110811111222L);
Person p2 = new Person(80110811111222L);

System.out.println(p1 == p2); // false
System.out.println(p1.equals(p2)); // true

// 아직 hashCode()를 오버라이딩 해주지 않아서 해시코드가 다르게 나온다.
System.out.println(p1.hashCode()); // ex) 250075633
System.out.println(p2.hashCode()); // ex) 358699161

public int hashCode()

객체의 해시 코드를 반환하는 메서드이며 다량의 데이터를 저장 및 검색하는 해싱 기법으로 사용됩니다.

• Object 클래스의 hashCode()는 객체의 내부 주소를 반환한다.

public String toString()

객체의 정보를 문자열로 제공할 목적으로 정의된 메서드이다.

• 객체를 toString메서드를 사용해서 출력하면 "클래스명+@+주소 값을 int형으로 변환한 값"이 나온다.
• 오버 라이딩을 통해 원하는 형태로 바꿔줄 수 있다.

// toString 메서드 코드
public String toString(){
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

// 예제
class Card{
    String kind;
    int number;
    
    Card(){this("SPADE", 1);}
    Card(String kind, int number){
        this.kind = kind;
        this.number = number;
    }
    // toString 오버라이딩 x
}

class Card2 extends Card{
    Card2(){
        super("SPADE", 1);
    }
    Card2(String kind, int number){
        super(kind, number);
    }
    public String toString(){ // toString 오버라이딩 O
        return "kind = " + kind + ", number = " + number;
    }
}

public class CardToString{
    public static void main(String[] args){
        Card c1 = new Card();
        Card c2 = new Card();
        System.out.println(c1.toString()); // ex) Card@e553
        System.out.println(c2.toString()); // ex) Card@c10f
        
        Card2 c3 = new Card2();
        Card2 c4 = new Card2();
        System.out.println(c3.toString()); // kind = SPADE, number = 1
        System.out.println(c4.toString()); // kind = SPAED, number = 1
    }
}

public Class getClass()

객체 자신의 클래스 정보(설계도 정보)를 담고 있는 Class 인스턴스를 반환한다.

• Class객체는 클래스의 모든 정보와 생성을 담고 있으며, 클래스당 단 1개만 존재한다.
• 소스파일을 컴파일하면 *. class 파일이 생성된다.
• *.class 파일을 실행하면 해당 파일명의 객체가 생성되고 이게 설계도가 된다.

Card.class  >>> ClassLoader >>> Class객체

String Class

문자형 배열(char [])과 그에 관련된 메서드들이 정의되어 있다.

// String 클래스 기본 형태
public final class String implements java.io.Serializable, Comparable{
    // ....
    private char[] value;
    // ....
}

• final 클래스이며 private 이기 때문에 String 인스턴스의 내용은 절대 변경할 수 없다.

String str = "ABC"와 String str = new String("ABC")의 비교

String str1 = "abc";
String str2 = "abc";
String str3 = new String("abc"); // 새로운 String 객체를 만든다.
String str4 = new String("abc"); // 새로운 String 객체를 만든다.

System.out.println(str1 == str2); // true
System.out.println(str3 == str4); // false
System.out.println(str1.equals(str2)); // true
System.out.println(str3.equals(str4)); // true

빈 문자열(empty string)

내용이 없는 문자열이며 크기가 0인 char형 배열을 저장하는 문자열을 말한다.

• 크기가 0인 배열을 생성하는 것은 어느 타입이나 가능하다.

char[] cArr = new char[0]; // 크기가 0인 char배열
int[]  iArr = {};          // 크기가 0인 int배열

String은 빈 문자열("")이 가능하지만 char의 경우 빈문자('')가 불가능하다.

• String은 참조형의 기본값인 null보다는 빈 문자열("")로 초기화하는 게 좋다.
• char은 기본값인 '\u0000'보다는 공백(' ')으로 초기화하는게 좋다.

String s = ""; // 빈문자열로 초기화
char c = ' ';  // 공백으로 초기화

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 c1 = s.charAt(1);
char c2 = n.charAt(1);
// 결과 >> c1 = 'e', c2 = '1'

• String concat(String str)
  • 문자열(str)을 뒤에 덧붙인다.

String s1 = "Hello";
String s2 = s1.concat(" world");
// 결과 >> s2 = "Hello world"

• boolean contains(CharSequence s)
  • 지정된 문자열(s)이 포함되었는지 검사한다.

String s = "abcdefg";
boolean b = s.contains("bc");
// 결과 >> b = true

• boolean endWith(String suffix)
  • 지정된 문자열(suffix)로 끝나는지 검사한다.

String file = "Hello.txt";
boolean b = file.endWith("txt");
// 결과 >> b = true

• boolean equals(Object obj)
  • 매개변수로 받은 문자열(obj)과 String인스턴스의 문자열을 비교한다.
  • obj가 String이 아니거나 문자열이 다르면 false를 반환한다.

String s = "Hello";
boolean b1 = s.equals("Hello");
boolean b2 = s.equals("hello");
// 결과 >> b1 = true, b2 = false

• boolean equalsIgnoreCase(String str)
  • 문자열과 String인스턴스의 문자열을 대소문자 구분 없이 비교한다.

String s = "Hello";
boolean b1 = s.equalsIgnoreCase("HELLO");
boolean b2 = s.equalsIgnoreCase("HeLlo");
// 결과 >> b1 = true, b2 = true

• int indexOf(char ch)
  • 주어진 문자(ch)가 문자열에 존재하는지 확인하여 위치(index)를 알려준다.
  • 주어진 문자(ch)가 없는 경우 -1을 반환한다.
• int indexOf(String str)
  • 주어진 문자열(str)이 존재하는지 확인하여 위치(index)를 알려준다.
    • 문자열(str)의 첫 번째 문자가 있는 위치를 반환하는 것이다.
  • 주어진 문자열(str)이 없는 경우 -1을 반환한다.

String s1 = "Hello";
int idx1 = s1.indexOf('o');
int idx2 = s1.indexOf('k');
// 결과 >> idx1 = 4, idx2 = -1

String s2 = "ABCDEFG";
int idx3 = s2.indexOf("CD");
// 결과 >> idx3 = 2

• String intern()
  • 문자열을 constant pool에 등록한다.
  • 이미 constant pool에 같은 내용의 문자열이 있을 경우 그 문자열의 주소 값을 반환한다.

Stirng s1 = new String("abc");
String s2 = new String("abc");
boolean b1 = (s1 == s2);
boolean b2 = s1.equals(s2);
boolean b3 = (s1.intern() == s2.intern());
// 결과 >> b1 = false, b2 = true, b3 = true

• int lastIndexOf(char ch)
  • 지정된 문자 또는 문자코드를 문자열의 오른쪽 끝에서 부터 탐색한다.
  • 문자 또는 문자코드가 있다면 그 위치를 반한 한다.
  • 없는 경우 -1을 반환한다.
• int lastIndexOf(String str)
  • 지정된 문자열을 인스턴스의 오른쪽 끝에서 부터 탐색한다.
  • 있다면 문자열(str)이 시작하는 지점을 반환하고 없다면 -1을 반환한다.

String s1 = "java.lang.Object";
int idx1 = s1.lastIndexOf('.');
int idx2 = s1.indexOf('.');
// 결과 >> idx1 = 9, idx2 = 4

String s2 = "java.lang.java";
int idx3 = s2.lastIndexOf("java");
int idx4 = s2.indexOf("java");
// 결과 >> idx3 = 10, idx4 = 0

• int length()
  • 문자열의 길이를 알려준다.

String s = "Hello";
int length = s.length();
// 결과 >> length = 5

• String replace(char old, char new)
  • 문자열 중의 문자(old)를 새로운 문자(new)로 바꾼 문자열을 반환한다.
• String replace(CharSequence old, CharSequence new)
  • 문자열 중의 문자열(old)을 새로운 문자열(new)로 바꾼 문자열을 반환한다.
• String replaceAll(String regex, String replacement)
  • 문자열 중에서 지정된 문자열(regex)과 일치하는 것을 새로운 문자열(replacement)로 모두 변경한다.
  • replace와 차이점은 replaceAll에서는 정규식을 사용할 수 있다는 것이다.
• String replaceFirst(String regex, String replacement)
  • 문자열 중에서 지정된 문자열(regex)과 일치하는 것  중 첫 번째 것만 새로운 문자열(replacement)로 변경한다.

String s1 = "Hellollo";
String s2 = s1.replace('o','k');
// 결과 >> s2 = "Hellkllk"

String s3 = "Hellollo";
String s4 = s3.replace("ll","LL");
// 결과 >> s4 = "HeLLoLLo"

String s5 = "AABBAABB";
String s6 = s5.replaceAll("BB","bb");
// 결과 >> s6 = "AAbbAAbb"
String s7 = "abcabcdabcdee";
String s8 = s7.replaceAll("[abc]", "왕");
String s9 = s7.replace("a","왕").replace("b", "왕").replace("c", "왕");
// 결과 >> s8 = "왕왕왕왕왕왕d왕왕왕dee";
// 결과 >> s9 = "왕왕왕왕왕왕d왕왕왕dee";

String s7 = "AABBAABB";
String s8 = s7.replaceFirst("BB","bb");
// 결과 >> s8 = "AAbbAABB"

• String [] split (String regex)
  • 문자열을 지정된 분리자(regex)로 나누어 문자열 배열에 담아 반환한다.
• String[] split (String regex, int limit)
  • 문자열을 지정된 분리자(regex)로 나누어 문자열 배열에 담아 반환한다.
  • 단, 문자열 전체를 지정된 수(limit)로 자른다.

String animals1 = "dog,cat,bear";
String[] arr1 = animals1.split(",");
// 결과 >> arr1[0] = "dog", arr1[1] = "cat", arr1[2] = "bear"

String animals2 = "dog,cat,bear";
String[] arr2 = animals2.split(",",2);
// 결과 >> arr2[0] = "dog", arr2[1] = "cat,bear"

• boolean startsWith (String prefix)
  • 주어진 문자열(prefix)로 시작하는지 검사한다.

String s = "java.lang.Object";
boolean b1 = s.startsWith("java");
boolean b2 = s.startsWith("lang");
// 결과 >> b1 = true, b2 = false

• String substring (int begin)
• String substring (int begin, int end)
  • 주어진 시작 위치(begin)부터 끝 위치(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 toUpperCase()
  • String 인스턴스에 저장되어 있는 모든 문자열을 대문자로 변환하여 반환한다.

String s1 = "Hello";
String s2 = s1.toLowerCase();
String s3 = s1.toUpperCase();
// 결과 >> s2 = "hello", s3 = "HELLO"

• String toString()
  • String 인스턴스에 저장되어 있는 문자열을 반환한다.

String s1 = "Hello";
String s2 = s1.toString();
// 결과 >> s2 = "Hello"

• String trim()
  • 문자열의 왼쪽 끝과 오른쪽 끝에 있는 공백을 없앤 결과를 반환한다.
  • 이때 문자열 중간에 있는 공백은 제거되지 않는다.

String s1 = "    Hello World   ";
String s2 = s1.trim();
// 결과 >> s2 = "Hello World"

• static String valueOf (boolean 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(10.0f);
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 = "Fri Oct 21 01:11:52 GMT 2022"
*/

문자열과 기본형 간의 변환

기본형 값을 문자열로 바꾸는 방법에는 2가지가 있다.

• 속도의 경우 2번 방법이 더 빠르다.

int i = 100;
String str1 = i + ""; // 결과 >> "100" 방법1
String str2 = String.valueOf(i); // 결과 >> "100" 방법2 (속도 빠름)

문자열을 기본형 값으로 변환하는 방법에는 2가지가 있다.

int i1 = Integer.parseInt("100"); // 결과 100 방법1
int i2 = Integer.valueOf("100");  // 결과 100 방법2 (JDK 1.5이후)
char c = "A".charAt(0); // 결과 'A'
// String을 char배열로 만들고 index 0을 반환하라는 코드이다.

문자열을 기본형으로 변환하는 방법
boolean	Boolean.getBoolean(String s)
byte	Byte.parseByte (String s)
short	Short.parseShort (String s)
int	Integer.parseInt (String s)
long	Long.parseLong (String s)
float	Float.parseFloat (String s)
double	Double.parseDouble (String s)

StringBuffer Class

String처럼 문자열 배열(char [])을 내부적으로 가지고 있다.

// 기본 코드
public final class StringBuffer implements java.io.Serializable{
    // ....
    private char[] value;
    // ....
}

하지만 String 클래스와 달리 내용을 변경할 수 있습니다.

StringBuffer sb = new StringBuffer("abc");
sb.append("123");

인스턴스를 생성할 때 버퍼(배열)의 크기를 충분히 지정해주는 것이 좋다.

• 버퍼가 작으면 성능이 저하되기 때문에 작업 중에 더 큰 배열의 생성이 필요하다.

String 클래스와 달리 equals()를 오버 라이딩하지 않는다.

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

String s1 = sb1.toString();
String s2 = sb2.toString();
System.out.println(s1.equals(s2)); // true

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

• StringBuffer()
  • 16 문자를 담을 수 있는 버퍼를 가진 StringBuffer 인스턴스를 생성한다.

StringBuffer sb = new StringBuffer();
// 결과 >> sb = ""

• StringBuffer(int length)
  • 지정된 개수의 문자를 담을 수 있는 버퍼를 가진 StringBuffer 인스턴스를 생성한다.

StringBuffer sb = new StringBuffer(10);
// 결과 >> sb = ""

• StringBuffer(String str)
  • 지정된 문자열(str)을 갖는 StringBuffer 인스턴스를 생성한다.

StringBuffer sb = new StringBuffer("Hi");
// 결과 >> 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 인스턴스가 저장하고 있는 문자열의 뒤에 덧붙인다.

StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = sb1.append(true);
sb1.append('d').append(10.0f);
StringBuffer sb3 = sb1.append("ABC").append(123);
/*
결과
sb1 = "abctrued10.0ABC123"
sb2 = "abctrued10.0ABC123"
sb3 = "abctrued10.0ABC123"
*/

• int capacity()
  • StringBuffer인스턴스의 버퍼 크기를 알려준다.
  • length()는 버퍼에 담긴 문자열의 크기를 알려준다.

StringBuffer sb  = new StringBuffer(100);
sb.append("abcd");
int bufferSize = sb.capacity();
int StringSize = sb.length();
// 결과 >> bufferSize = 100, StringSize = 4
// sb에 담긴 문자열이 "abcd"이기 때문이다.

• char charAt(int index)
  • 지정된 위치(index)에 있는 문자를 반환한다.

StringBuffer sb = new StringBuffer("abcd");
char c = sb.charAt(2);
// 결과 >> c = 'c'

• StringBuffer delete (int start, int end)
  • 시작 위치(start)부터 끝 위치(end) 사이에 있는 문자를 제거한다.
  • 단, 끝 위치의 문자는 제외한다.

StringBuffer sb1 = new StringBuffer("0123456");
StringBuffer sb2 = sb1.delete(3,6);
// 결과 >> sb1 = "0126", sb2 = "0126"

• StringBuffer deleteCharAt(int index)
  • 지정된 위치(index)의 문자를 제거한다.

StringBuffer sb = new StringBuffer("0123456");
sb.deleteCharAt(3);
// 결과 >> sb = "012456"

• StringBuffer insert (int pos, boolean b)
• StringBuffer insert (int pos, char [] str)
• StringBuffer insert (int pos, float f)
• StringBuffer insert (int pos, double d)
• StringBuffer insert (int pos, Object obj)
• StringBuffer insert (int pos, char c)
• StringBuffer insert (int pos, int i)
• StringBuffer insert (int pos, long l)
• StringBuffer insert (int pos, String str)
  • 두 번째 매개변수로 받은 값을 문자열로 반환하여 지정된 위치(pos)에 추가한다.
  • 인덱스는 0부터 시작한다.

StringBuffer sb = new StringBuffer("0123456");
sb.insert(4, '.');
// 결과 >> sb = "0123.456"

• int length()
  • StringBuffer인스턴스에 저장되어 있는 문자열의 길이를 반환한다.

StringBuffer sb = new StringBuffer("0123456");
int length = sb.length();
// 결과 >> legnth = 7

• StringBuffer replace(int start, int end, String str)
  • 지정된 범위(start ~ end)의 문자들을 주어진 문자열(str)로 바꾼다.
  • end위치의 문자는 포함되지 않는다.

StringBuffer sb = new StringBuffer("0123456");
sb.replace(3,6,"AB");
// 결과 >> sb = "012AB6"

• StringBuffer reverse()
  • StringBuffer인스턴스에 저장되어 있는 문자열의 순서를 거꾸로 나열한다.

StringBuffer sb = new StringBuffer("0123465");
sb.reverse()
// 결과 >> sb = "6543210"

• void setLength(int newLength)
  • 지정된 크기(newLength)로 문자열의 길이를 변경한다.
  • 크기를 늘리는 경우에 나머지 빈 공간은 널문자('\u0000')로 채운다.

StringBuffer sb1 = new StringBuffer("0123456");
sb1.setLength(5);
StringBuffer sb2 = new StringBuffer("0123456");
sb2.setLength(10);
String str = sb2.trim();
/*
결과
sb1 = "012345"
sb2 = "0123456    "
str = "0123456"
*/

• String toString()
  • StringBuffer인스턴스의 문자열을 String으로 반환한다.

StringBuffer sb = new StringBuffer("0123456");
String str = sb.toString();
// 결과 >> str = "0123456"

• String substring(int start)
• String substring(int start, int end)
  • 지정된 범위 내의 문자열을 String으로 뽑아서 반환한다.
  • 시작 위치(start)만 지정하면 시작 위치부터 문자열 끝까지 뽑아서 반환한다.

StringBuffer sb = new StringBuffer("0123456");
String str1 = sb.substring(3);
String str2 = sb.substring(3,5);
// 결과 >> str1 = "3456", str2 = "34"

Math & wrapper Class

• staitc int abs(int f)
• static float abs(float f)
• static double abs(double d)
• static long abs(long l)
  • 주어진 값의 절댓값을 반환한다.

int i = Math.abs(-10);
double d = Math.abs(-10.0);
// 결과 >> i = 10, d = 10.0

• static double ceil(double d)
  • 주어진 값을 무조건 올림 하여 반환한다.

double d1 = Math.ceil(10.1);
double d2 = Math.ceil(-10.1);
double d3 = Math.ceil(10.0000015);
// 결과 >> d1 = 11.0, d2 = -10.0, d3 = 11.0

• static double floor(double d)
  • 주어진 값을 무조건 버림 하여 반환한다.

double d1 = Math.floor(10.8);
double d2 = Math.floor(-10.8);
// 결과 >> d1 = 10.0, d2 = -11.0

• static int max(int a, int b)
• static long max(long a, long b)
• static float max(float a, float b)
• static double max(double a, double b)
  • 주어진 두 값을 비교해서 큰 쪽을 반환한다.

double d = Math.max(9.5, 9.50001);
int i = Math.max(0, -1);
// 결과 >> d = 9.50001, i = 0

• static int min(int a, int b)
• static long min(long a, long b)
• static float min(float a, float b)
• staitc double min(double a, double b)
  • 주어진 두 값을 비교하여 작은 쪽을 반환한다.

double d = Math.min(9.5, 9.500001);
int i = Math.min(0, -1);
// 결과 >> d = 9.5, i = -1

• static double random()
  • 0.0 ~ 1.0 범위의 임의의 double 값을 반환한다.
  • 0.0은 포함되지만 1.0은 포함되지 않는다.

double d = Math.random();
int i = (int)(Math.random() * 10) + 1;
/*
결과
d = 0.0 <= x < 1.0의 실수
i = 1 <= x < 11의 정수
*/

• static double rint(double d)
  • 주어진 double값과 가장 가까운 정수 값을 double형으로 반환한다.

double d1 = Math.rint(5.55);
double d2 = Math.rint(5.11);
double d3 = Math.rint(-5.55);
double d4 = Math.rint(-5.11);
// 결과 >> d1 = 6.0, d2 = 5.0, d3 = -6.0, d4 = -5.0

• static long round(double d)
• static long round(float f)
  • 소수점 첫째 자리에서 반올림한 정수 값(long)을 반환한다.

long l1 = Math.round(5.55);
long l2 = Math.round(5.11);
long l3 = Math.round(-5.55);
long l4 = Math.round(-5.11);
double d1 = 90.7552;
double d2 = Math.round(d1*100)/100.0;
// 결과 >> l1 = 6, l2 = 5, l3 = -6, l4 = -5, d2 = 90.76

wrapper class

기본형을 클래스로 정의한 것으로 기본형 값도 객체로 다뤄져야 할 때 가 있다.

기본형	wrapper class	생성자	활용 예제
boolean	Boolean	Boolean (boolean vlaue) Boolean (String s)	Boolean b1 = 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 b1 = new Byte(10); Byte b2 = new Byte("10");
short	Short	Short (short value) Short (String s)	Short s1 = new Short(10); Short s2 = new Short("10");
int	Integer	Integer (int value) Integer (String s)	Integer i1 = new Integer(10); Integer i2 = new Integer("10");
long	Long	Long (long value) Long (String s)	Long l1 = new Long(100); Long l2 = new Long("100");
float	Float	Float (double value) Float (float value) Float (String s)	Float f1 = 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 d1 = new Double(10.0); Double d2 = new Double("10.0");

wrapper class는 값을 비교하도록 내부적으로 equlas()가 오버 라이딩되어있다.

• 내부적으로 equals()를 값을 비교하도록 오버 라이딩한 것은 String 클래스가 있다.

Integer i1 = new Integer(100);
Integer i2 = new Integer("100");

System.out.println(i1 == i2); // false
System.out.println(i1.equals(i2)) // true