Bibliothek

/*========================================
  ■■■ 주바의 주요(중요) 클래스 ■■■
  - Wrapper 클래스
==========================================*/


public class Test139
{
	public static void main(String[] args)
	{
		byte b = 3;
		int i = 256;

		Byte b2 = new Byte(b);
		Integer i2 = new Integer(i);

		System.out.println("b2 : " + b2);
		System.out.println("i2 : " + i2);
		

		print(b2);
		print(i2);

		// Byte 클래스의 byteValue() 메소드 호출
		byte b3 = b2.byteValue();
		
		// Integer 클래스의 intValue() 메소드 호출
		int i3 = i2.intValue();


		// check~!!!
		int i4 = b2.byteValue();
		byte b4 = i2.byteValue();
		//byte b5 = i2.intValue();	//--==>> 에러 발생
		


	}

	// 『java.lang.Number』 클래스(추상 클래스)
	// Number nb = new Number();	// 불가능
	// 모든 Wrapper 클래스의 부모 클래스
	// (슈퍼 클래스, 상위 클래스)이다.
	// b2, i2 자료형이 Number n 에 넘어오면서
	// 업 캐스팅이 일어나게 된다.
	static void print(Number n)	// ← 3 (Auto-Boxing)
	{
		System.out.println(n);
	}

}

java.math.BigDecimal 클래스

double 타입으로 표현할 수 있는 값은 범위가 넓지만 정밀도가 최대 13자리밖에 되지 않고 실수형의 특성상 오차를 피할 수 없다는 단점이 있다.  BigDecimal 은 실수형과 달리 정수를 이용해서 실수를 표현한다. 실수의 오차는 10진 실수를 2진 실수로 정확히 변환할 수 없는 경우가 있기 때문에 발생하는 것이므로, 오차가 없는 2진 정수로 변환하여 다루는 것이다. 실수를 정수와 10의 제곱의 곱으로 표현한다. 

BigDecimal의 연산

/*========================================
  ■■■ 자바의 주요(중요) 클래스 ■■■
  - Wrapper 클래스
==========================================*/

import java.math.BigDecimal;

public class Test138
{
	public static void main(String[] args)
	{
		BigDecimal a = new BigDecimal("123456789.123456789");

		// movePointLeft : 소수점을 왼쪽으로 이동
		BigDecimal b = a.movePointLeft(3);
		System.out.println("처리 결과 : " + b);
		//--==>> 처리 결과 : 123456.789123456789

		// 나눗셈 (두 번째 파라미터 확인) → 반올림 하지 않는다. → 절삭
		BigDecimal c = a.divide(b, BigDecimal.ROUND_DOWN);
		System.out.println("처리 결과 : " + c);
		//--==>> 처리 결과 : 1000.000000000

		System.out.println(BigDecimal.ROUND_DOWN);
		//--==>> 1 (의미를 가진 상수이다)

		// BigInteger 객체로 변환
		System.out.println(a.toBigInteger());
		//--==>> 123456789

	}
}

java.math.BigInteger 클래스

정수형으로 표현할 수 있는 값을 넘은 수들을 다룰 때  BigInteger 을 사용한다. 내부적으로는  int 배열을 사용해서 값을 다루기 때문에  long 타입보다 훨씬 큰 값을 다룰 수 있지만 성능은 떨어진다.

BigInteger의 연산

/*========================================
  ■■■ 자바의 주요(중요) 클래스 ■■■
  - Wrapper 클래스
==========================================*/

import java.math.BigInteger;

public class Test137
{
	public static void main(String[] args)
	{
		//int a1 = 123456789123456789;	
		//long b1 = 123456789123456789123456789L;
		//System.out.println(b1 * b1);
		
        
        	// BigInteger의 생성
		BigInteger a = new BigInteger("123456789123456789");
		BigInteger b = new BigInteger("123456789123456789");

		//BigInteger c = a + b;
		//System.out.println(c);

		// 더하기 
		BigInteger c = a.add(b);
		System.out.println("덧셈 결과 : " + c);

		// 빼기
		BigInteger d = a.subtract(b);
		System.out.println("뺄셈 결과 : " + d);
		//--==>> 뺄셈 결과 : 0

		// 곱하기
		BigInteger e = a.multiply(b);
		System.out.println("곱셈 결과 : " + e);
		//--==>> 곱셈 결과 : 15241578780673678515622620750190521

		// 나누기
		BigInteger f = a.divide(b);
		System.out.println("나눗셈 결과 : " + f);
		//--==>> 나눗셈 결과 : 1

		// 지수승
		BigInteger g = new BigInteger("2");
		System.out.println("2의 3승 : " + g.pow(3));
		//--==>> 2의 3승 : 8
	}
}

/*========================================
  ■■■ 자바의 주요(중요) 클래스 ■■■
  - Wrapper 클래스
==========================================*/

public class Test136
{
	public static void main(String[] args)
	{
		boolean bi = true;
		Boolean wrapbi = new Boolean(bi);
		Boolean wBi = bi;		//-- 오토 박싱

		int n = 300;
		Integer wrapn = new Integer(n);
		int n2 = wrapn;			//--오토 언박싱

		float f = 300.3f;
		Float wrapf = new Float(f);

		System.out.println(wrapbi.toString());
		System.out.println(wrapn.toString());
		System.out.println(wrapf.toString());
		//--==>>true
		//	300
		//	300.3


		System.out.println(wrapbi);
		System.out.println(wrapn);
		System.out.println(wrapf);
		//--==>>true
		//	300
		//	300.3

		String sn = "12";
		int ni = Integer.parseInt(sn);
		System.out.printf("ni : %3d\n", ni);
		//--==>> ni : 12

		ni = Integer.parseInt("0101", 2);
		System.out.printf("ni : %3d\n", ni);
		//--==>> ni :   5

		ni = Integer.parseInt("12", 8);
		System.out.printf("ni : %3d\n", ni);
		//--==>> ni : 10

		ni = Integer.parseInt("A",16);
		System.out.printf("ni : %3d\n", ni);
		//--==>> ni :  10

		sn = Integer.toBinaryString(20);
		System.out.printf("sn : %s\n", sn);
		//--==>> sn : 10100

		sn = Integer.toHexString(31);
		System.out.printf("sn : %s\n", sn);
		//--==>> sn : 1f
		
		sn = Integer.toOctalString(31);
		System.out.printf("sn : %s\n", sn);
		//--==>> sn : 37

		Integer num = new Integer(50);
		System.out.println(num.toString());
		//--==>> 50
		
		int n3 = 345;
		Integer n4 = Integer.valueOf(n3);
		System.out.println(n4);
		//--==>> 345

	}
}

○ Wrapper 클래스

   1. 자바에서는 언어 수준에서 제공하는 기본 데이터를 제외한 나머지는 클래스로 정의하여 객체 단위로 처리한다.
  따라서 자바에서는 이러한 기본형 데이터를 객체 단위로 처리할 수 있도록 클래스를 제공할 수 밖에 없는데
  이러한 클래스들을 가리켜 Wrapper 클래스라 한다.

  "10" → String → 객체 → Object
     ↓
 객체  → Integer → 메소드 parseInt() → 10
   
   2. 기본 자료형인
  byte, short,  int,        long,  float, double,  char,         boolean 형에 대응하는
  Byte, Short, Integer, Long, Float, Double, Character, Boolean 의 Wrapper 클래스 및 큰 숫자들을 다루기 위한
  java.math.BigInteger 와 java.math.BigDecimal 클래스를 제공한다.

  Wrapper 클래스는 java.lang 패키지에 포함되어 있으므로 별도의 import 과정 없이 바로 사용하는 것이 가능하며 기본형과 마찬가지로 Wrapper 클래스도 내부 메소드를 통해 형 변환이 가능하고 동등비교와 같은 연산도 가능하다.

  ex) java.lang.Integer 클래스
      int 기본 자료형의 Wrapper 클래스로 정수를 다루는데 필요한 상수나 메소드, 진수 변환 등에 필요한 메소드 등을 포함하고 있다.

  static int parseInt(String s)
  문자열 형식으로 저장된 숫자를 정수 형태로 반환한다

  static Integer valueOf(int i)
  int 형을 Integer 형으로 반환한다.

  byte byteValue(), int intValue()
  , short shortValue, long longValue()
  , float floatValue(), double doubleValue()
  해당 기본 자료형으로 형 변환한 값을 반환한다.

○ 박싱(Boxing)과 언박싱(Unboxing)

   박싱 : 기본 타입의 값을 Wrapper 객체로 변환

   언박싱 : Wrapper 객체에 들어 있는 기본 타입의 값을 빼내는 것

○ 오토 박싱(Auto-Boxing)과 오토 언박싱(Auto-Unboxing)

   일반적으로 레퍼런스 형과 기본 자료형은 호환되지 않으며 이 경우 발생하는 문제 해결을 위해 자바에서는 Wrapper 클래스를 제공하게 되었다. 하지만, JDK 1.5 부터 레퍼런스 형과 기본 자료형이 다음과 같은 방식으로 형 변환이 가능하게 되었다.

   int a=10, b;
   Integer ob;
   ob = a;
   기본 자료형(int)이 Integer 형으로 자동 변환(오토 박싱)
   실제로는 ... 『ob = new Integer(a);』

   b = ob;
   Integer(객체)가 기본 자료형 int 형으로 자동 변환(오토 언박싱)
   실제로는 ... b = ob.IntValue();

   이는 JDK 1.5 이후 추가된 오토 박싱 / 오토 언박싱이라는 기능으로 인해 가능해진 것이다.

/*========================================
  ■■■ 자바의 주요(중요) 클래스 ■■■
  - Wrapper 클래스
==========================================*/

public class Test135
{
	public static void main(String[] args)
	{
		int a = 10, b;
		Integer c;
		Object d;

		b = a; //-- int 형 데이터(자료) → int 형 변수
		c = new Integer(0);

		// ※ 레퍼런스 형(참조 타입)과 기본 자료형(값 타입)은 호환되지 않는다.
	
		b = c;					//-- Integer 형 데이터(객체) → int 형 변수(오토 언박싱)
		b = c.intValue();		//-- 언박싱

		d = new Object();
		System.out.println("d.toString() : " + d.toString());
		//--==>> d.toString() : java.lang.Object@15db9742

		d = new Integer(10);	//-- 업 캐스팅
		System.out.println("d.toString() : " + d.toString());
		//--==>> d.toString() : 10

		d = new Double(12.345);	//-- 업 캐스팅
		System.out.println("d.toString() : " + d.toString());
		//--==>> d.toString() : 12.345

		d = 10;					//-- 오토 박싱
		/*
		Integer i = 10;
		→ Integer i = new Integer(10);

		Object o = i;
		→ Object o = new Integer(10);

		Object o = 10;
		*/
		System.out.println("d.toString() : " + d.toString());
		//--==>> d.toString() : 10

	}
}

/*========================================
  ■■■ 주바의 주요(중요) 클래스 ■■■
  - Object 클래스
==========================================*/

class NewCar
{
	private int velocity;			//-- 자동차의 속도
	private int wheelNum;			//-- 자동차의 바퀴 갯수
	private String carName;			//-- 자동차의 이름

	NewCar(int speed, String name, int wheel)
	{
		velocity = speed;
		carName = name;
		wheel = wheel;
	}
}

public class Test134
{
	public static void main(String[] args)
	{
		NewCar nCar1 = new NewCar(100, "볼보", 4);
		NewCar nCar2 = new NewCar(150, "BMW", 4);

		// equals()
		System.out.println("1-1 : " + nCar1.equals(nCar2));		
		System.out.println("1-2 : " + (nCar1 == nCar2));	
		//--==>> 1-1 : false
		//	     1-2 : false

		NewCar nCar3 = nCar1;	//-- 객체 복사 → 얕은 의미 복사(참조형)
								//   → 주소값 복사

		System.out.println("2-1 : " + nCar1.equals(nCar3));
		System.out.println("2-2 : " + (nCar1 == nCar3));
		//--==>>2-1 : true
		//		2-2 : true

		
		// toString()
		System.out.println("3-1 : " + nCar1.toString());
		System.out.println("3-2 : " + nCar2.toString());
		System.out.println("3-3 : " + nCar3.toString());
		//--==>> 3-1 : NewCar@15db9742
		//		 3-2 : NewCar@6d06d69c
		//		 3-3 : NewCar@15db9742
		

		// hashCode()
		System.out.println("4-1 : " + nCar1.hashCode());
		System.out.println("4-2 : " + nCar2.hashCode());		
		System.out.println("4-3 : " + nCar3.hashCode());
		//--==>>4-1 : 366712642
		//		4-2 : 1829164700
		//		4-3 : 366712642
		//-- 결과값을 16진수 형태로 바꾸게 되면
		//   『toString()』메소드가 반환한 결고값 확인 가능


		// getClass()
		System.out.println("5-1 : " + nCar1.getClass());
		System.out.println("5-2 : " + nCar2.getClass());
		System.out.println("5-3 : " + nCar3.getClass());
		//--==>> 5-1 : class NewCar
		//		 5-2 : class NewCar
		//		 5-3 : class NewCar
		//-- 생성된 객체를 통해
		//   기반 설계도 클래스를 확인할 수 있는 기능을 가진 메소드

		
		// clone()		//-- 객체 복사

		// finalize()	//-- 객체 직렬화

		// 기타 나머지 메소드는 스레드 처리와 관련이 있다.


	}
}