자바의 정석 기초편 ch9 - 21 ~ 31[StringBuilder, Math클래스, 래퍼클래스, Number클래스, 오토박싱 & 언박싱, 문자열과 숫자변환]

1) StringBuilder

1. StringBuffer와 거의 비슷하며 StringBuffer는 동기화가 되어있음(멀티 쓰레드에 안전)
2. StringBuilder는 동기화가 되어있지 않음
3. 멀티 쓰레드 프로그램이 아닌경우(싱글쓰레드)의 동기화는 불필요한 성능 저하가 나올 수 있어 StringBuilder사용하면 됨
4. StringBuffer와 동일한 메서드를 사용함

** 참고

• 싱글쓰레드 : 한번에 1개 작업
• 멀티쓰레드 : 한번에 n개 작업 (한번에 여러작업을 할 수 있음)
• 동기화 : 멀티쓰레드는 쓰레드끼리 데이터를 공유 하는데 데이터를 보호하는 것 (멀티쓰레드에 문제 없음)
• 지금까지 작성해온 프로그램은 전부 싱글쓰레드로 작성 -> 멀티쓰레드로 프로그램 작성하는 방법은 13장 쓰레드에서 배움

// 멀티 쓰레드 사용
StringBuffer sb;
sb = new StringBuffer();
sb.append("abc");


// 싱글 쓰레드 사용
StringBuilder sb;
sb = new StringBuilder();
sb.append("abc");

---

2) Math클래스

• 수학과 관련된 static메서드의 집합, 전부 static 메서드

(1) 메서드

• static double abs(double a)
  • 인수의 값을 절대값으로 반환 (무조건 양수로 변환)
  • 실수, 정수 모두 가능

int i = Math.abs(-10);	
double d = Math.abs(-10.0);

// 결과
// i = 10
// d = 10.0

 

• static double ceil(double a) - 인수의 값을 올림
• static double floor(double a) - 인수의 값을 버림 후 반환
  • 두 상황 다 음수일 경우 조심해야함,
  • 음수에서는 값을 올리면 0에 가까워지고 값을 버리면 0에서 멀어진다고 생각해야함

double d = Math.ceil(10.1);
double d2 = Math.ceil(-10.1);
double d3 = Math.ceil(10.000015);

double d4 = Math.floor(10.8);
double d5 = Math.floor(-10.8);

// 결과
// d = 11.0
// d2 = -10.0 // (-11이 아니라 -10이 더 큰숫자)
// d3 = 11.0
// d4 = 10.0
// d5 = -11.0 // (-11이 더 작은숫자)

 

• static double max(double a , double b) - 인수의 두 값을 비교하여 큰 값을 반환
• static double min(double a, double b) - 인수의 두 값을 비교하여 작은 값을 반환

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

double d2 = Math.min(9.5, 9.50001);
int i2 = Math.min(0, -1);

// 결과
// d = 9.50001
// i = 0
// d2 = 9.5
// i2 = -1

 

• static double random() - 0.0이상 1.0미만(1.0 미포함)의 임의의 double값을 반환

double d = Math.random();
int i =(int)(Math.random()*10)+1;

// d의 반환값 범위
// 0.0 <= d < 1.0

// i의 반환값 범위
// 1 <= i < 11

 

• static double rint(double a)
  • 인자의 값과 가장 가까운 정수값을 double형으로 반환
  • 두 정수의 정 가운데 있는 값(1.5, 2.5, 3.5 등등)은 짝수로 반환(짝수 반올림)
  • 짝수 반올림 :  가까운 짝수로 반올림
  • ex) 1.5 -> 2 / 2.5 -> 2 / 3.5 -> 4 .. (아래 예제 참고)
  • 짝수반올림(round even)이 일반 반올림에 비해 전체 값을 더했을 때 오차가 줄어 듦

double d = Math.rint(1.2);
double d2 = Math.rint(2.6);
double d3 = Math.rint(3.5);
double d4 = Math.rint(4.5);

// 결과
// d = 1.0
// d2 = 3.0
// d3 = 4.0
// d4 = 4.0

 

• static double round(double a)
  • 소수점 첫째자리에서 반올림한 정수값을 long타입으로 반환
  • 두 정수의 정 가운데 있는 값(1.5, 2.5, 3.5 등등)은 항상 큰 수를 반환 (일반 반올림)

long l = Math.round(1.2);
long l2 = Math.round(2.6);
long l3 = Math.round(3.5);
long l4 = Math.round(4.5);

double d = 90.7552	// 실수

// 대상 값에 반올림하고자 하는 값의 위치를 소수점 첫째짜리가 되도록 곱셈연산 후 반올림을 적용한뒤 다시 나누기
double d2 = Math.round(d*100)/100.0;	// d를 소수점 2째자리 반올림


// 결과
// l = 1
// l2 = 3
// l3 = 4
// l4 = 5

// d2 = 90.76

 

 

** rint,round 차이

public class RoundTest {

	public static void main(String[] args) {
		
		double sum = 0;
		double sum1 = 0;
		double sum2 = 0;
		
		for(double d = 1.5; d<=10.5; d++) {
			double d1 = Math.round(d);
			double d2 = Math.rint(d);
			
			System.out.printf("%4.1f %4.1f %4.1f%n", d, d1, d2);
			
			sum += d;
			sum1 += d1;
			sum2 += d2;
		}
		System.out.println("-------------------");		
		System.out.printf("%4.1f %4.1f %4.1f%n", sum, sum1, sum2);
	}
}

// 대상 round rint
// 1.5  2.0  2.0
// 2.5  3.0  2.0 // 짝수로 버림
// 3.5  4.0  4.0
// 4.5  5.0  4.0 // 짝수로 버림
// 5.5  6.0  6.0
// 6.5  7.0  6.0 // 짝수로 버림
// 7.5  8.0  8.0
// 8.5  9.0  8.0 // 짝수로 버림
// 9.5 10.0 10.0
//10.5 11.0 10.0 // 짝수로 버림
-------------------
// 60.0 65.0 60.0 rint의 결과의 합계는 원래값의 합계와의 오차가 발생하지 않음

---

3) 래퍼(wrapper)클래스

• 기본형 값을 감싸는 클래스
• 8개의 기본형(기본형은 객체가 아님)을 객체로 다뤄야 할 때 사용하는 클래스

// Integer 래퍼 클래스 일부
public final class Integer extends Number implements Comparable {
   ...
   private int value; (기본형 int 값을 감싸고 있음)
   ... 
}

 

(1) 래퍼클래스 종류

• 대부분 기본형에서 맨 앞에만 대문자로 변환하면 됨
• char, int 타입만 풀네임으로 Character, Integer로 작성

 

(2) Integer 래퍼클래스 예제

class Ex9_14 {
	public static void main(String[] args) {
		Integer i  = new Integer(100);
		Integer i2 = new Integer(100);

		// 객체 주소값 비교
		System.out.println("i==i2 ? "+(i==i2));
		
		// 내용 비교(equals가 오버라이딩 되어있음)
		System.out.println("i.equals(i2) ? "+i.equals(i2));
		
		// i.compareTo(): i값이 인자의 값과 같으면 0, 크면 양수, 작으면 음수 반환
		System.out.println("i.compareTo(i2)="+i.compareTo(i2));
		System.out.println("i.toString()="+i.toString());

		System.out.println("MAX_VALUE="+Integer.MAX_VALUE);
		System.out.println("MIN_VALUE="+Integer.MIN_VALUE);
		System.out.println("SIZE="+Integer.SIZE+" bits");
		System.out.println("BYTES="+Integer.BYTES+" bytes");
		System.out.println("TYPE="+Integer.TYPE);
	}
}

/*
결과
i==i2 ? false       // 주소값 비교 
i.equals(i2) ? true // 내용 비교
i.compareTo(i2)=0
i.toString()=100
MAX_VALUE=2147483647
MIN_VALUE=-2147483648
SIZE=32 bits
BYTES=4 bytes
TYPE=int
*/

---

4) Number클래스

• 모든 숫자 래퍼 클래스의 조상
• 래퍼(객체)의 값을 기본값으로 변환하는 메서드들을 가지고 있음

// Number클래스의 구조
public abstract class Number implements java.io.serializable {
	public abstract int intValue();
	public abstract long longValue();
	public abstract float floatValue();
	public abstract double doubleValue();

	public byte byteValue() {
    	return (byte)intValue();
    }

	public short shortValue();
		return (short)intValue();
    }
    
    ...
}

 

(1) 계층 구조

• Object (최고조상)
  • Number (숫자의 최고조상)
    • Byte
    • Short
    • Integer
    • Long : 10의 19제곱
    • Float
    • Double : 10의 308제곱 - 정밀도 15자리
    • BigInteger : 아주 큰 정수 (Long보다 큰 값이 필요할 때)
    • BigDecimal : 아주 큰 실수 (Double보다 정밀도가 더 높은 값이 필요할 때)

** BigInteger, BigDecimal은 검색

---

5) 문자열을 숫자, 래퍼클래스로 변환하기

(1) 문자열을 숫자,래퍼클래스로 변환하는 다양한 방법

// floatValue(), longVlaue(),... 등 사용 가능
int i = new Integer("100").intValue();  // 래퍼클래스 -> int값으로 변환
int i2 = Integer.parseInt("100");
Integer i3 = Integer.valueOf("100");    // 기본형으로도 반환이 가능함(언박싱 적용)

• 문자열 -> 기본형
  • 래퍼클래스.parse타입("문자열")
  • 래퍼클래스.valueOf("문자열")
• 문자열 -> 래퍼클래스

Byte b = new Byte("100");     // 이렇게도 가능
Byte b = Byte.valueOf("100"); // 위와 동일코드
// b = 100

 

• 래퍼클래스 -> 문자열 변환
  • 래퍼클래스를 가리키는 참조변수로 toString()메서드를 호출한 반환값을 String타입 참조변수에 저장하면 새로운 String 객체가 생성됨

String str = b.toString();
// str = "100"

 

(2) 문자열을 n진법의 숫자로 변환하는 방법

// 2번째 인수에 변환하고자하는 진수를 입력, 진수를 안쓰면 기본 10진수로 변환
int i4 = Integer.parseInt("100", 2);   // 100(2) -> 4
int i5 = Integer.parseInt("100", 8);   // 100(8) -> 64
int i6 = Integer.parseInt("100", 16);  // 100(16) -> 256
int i7 = Integer.parseInt("FF", 16);   // "FF"(16) -> 255

// 에러(10진수에는 F가 없음) NumberFormatException 발생
int i8 = Integer.parseInt("FF");

---

6) 오토박싱 & 언박싱

• 기본형과 참조형간의 자동 변환하는 기능
• 기본형 -> 래퍼클래스 : 오토박싱(Autoboxing)
• 래퍼클래스 -> 기본형 : 언박싱 (Unboxing)
• 둘다 자동으로 해주며 JDK 1.5이전에는 기본형과 참조형간의 연산이 불가능했음

// 기본형과 참조형을 덧셈
int i = 5;
Integer iObj = new Integer(7);

int sum = i + iObj; // 1.5 이전에는 에러, 1.5 이후에는 연산이 가능함
int sum = i + iObj.intValue(); // 컬파일러가 Integer를 int로 자동으로 변환(언박싱)

ArrayList<Integer> list = new ArrayList<Integer>();	// 제네릭스 - 타입지정, 12장에서 배움

list.add(10); // 오토박싱 - 기본형인 10을 Integer 타입인 ArrayList에 저장
int value = list.get(0); // 언박싱 - Integer타입인 list변수의 0번째 인덱스의 값을 int타입변수에 저장

 

(1) 예제

class Ex9_16 {
	public static void main(String[] args) {
		int i = 10;
		
		// 기본형을 참조형으로 형변환(오토박싱, 언박싱으로 형변환을 생략해도 컴파일러가 알아서 해줌)
		Integer intg = (Integer)i; // Integer intg = Integer.valueOf(i);
		Object obj = (Object)i;    // Object obj = (Object)Integer.valueOf(i);

		Long     lng = 100L;  // Long lng = new Long(100L);

		int i2 = intg + 10;   // 참조형과 기본형간의 연산 가능
		long l = intg + lng;  // 참조형 간의 덧셈도 가능

		Integer intg2 = new Integer(20);
		int i3 = (int)intg2;  // 참조형을 기본형으로 형변환도 가능(형변환 생략가능)

		Integer intg3 = intg2 + i3; 

		System.out.println("i     ="+i);
		System.out.println("intg  ="+intg);
		System.out.println("obj   ="+obj);
		System.out.println("lng   ="+lng);
		System.out.println("intg + 10  ="+i2);
		System.out.println("intg + lng ="+l);
		System.out.println("intg2 ="+intg2);
		System.out.println("i3    ="+i3);
		System.out.println("intg2 + i3 ="+intg3);
	}
}

/* 
출력값
i     =10
intg  =10
obj   =10
lng   =100
intg + 10  =20
intg + lng =110
intg2 =20
i3    =20
intg2 + i3 =40
*/

 

** 출처 : 남궁성의 정석코딩_자바의정석_기초편 유튜브 강의