[Java_Basic]자바의 기본 클래스(윤성우의 열혈 Java 프로그래밍)

래퍼 클래스 (Wrapper 클래스)

string 이 아닌 int 나 double 형 실수와 같은 기본 자료형의 값들을 인스턴스로 표현을 해야 할 때

해당 자료형으로 값을 감싸서 표현할 수 있다. 

class UseWrapperClass {
	public static void showData(Object obj) {
		System.out.println(obj);
	}

	public static void main(String[] args) {
		Integer iInst = new Integer(3);	//정수 3을 감싸는 래퍼 인스턴스 생성
		showData(iInst);
		showData(new Double(7.15));	//7.15를 감싸는 래퍼 인스턴스 생성 및 전달
	}
}

---

다른 때와 달리 컴파일 할때 위와같은 오류가 반복해서 났다

클래스 파일이 이미 생성된 상태여서 이런 오류가 나오는 것인데 클래스 파일을 지워준 뒤 해도 이처럼 메세지가 뜬 뒤에 클래스 파일이 생성되어 진다. 

생성된 클래스 파일은 정상적으로 읽혀지긴 했다. 

---

래퍼 클래스의 두가지 기능 : 박싱, 언박싱

값을 인스턴스에 감싸는 행위 : 박싱

감싸져 있는 값을 꺼내는 행위 : 언박싱

class BoxingUnboxing{
	public static void main(String[] args){
		Integer iObj = new Integer(10);	//박싱
		Double dObj = new Double(3.14);	//박싱
		System.out.println(iObj);
		System.out.println(dObj);
		System.out.println();

		int num1 = iObj.intValue();	//언박싱
		double num2 = dObj.doubleValue();	//언박싱
		System.out.println(num1);
		System.out.println(num2);
		System.out.println();

		//래퍼 인스턴스 값의 증가 방법
		iObj = new Integer(iObj.intValue() + 10);
		dObj = new Double(dObj.doubleValue() + 1.2);
		System.out.println(iObj);
		System.out.println(dObj);
	}
}

인스턴스는 '이뮤터블' 성질을 가지고 있다. 

값을 변경할 수가 없다는 의미 

그렇기에 해당 값을 꺼냈다가 연산을 한 뒤 다시 변수 안에 집어넣는 이러한 번거로운 방식을 거쳐야만 한다. 

 

오토 박싱 & 오토 언박싱

class AutoBoxingUnboxing{
	public static void main(String[] args){
		Integer iObj = 10;	//오토 박싱 진행
		Double dObj = 3.14;	//오토 박싱 진행
		System.out.println(iObj);
		System.out.println(dObj);
		System.out.println();

		int num1 = iObj;
		double num2 = dObj;
		System.out.println(num1);
		System.out.println(num2);
	}
}

위처럼 Integer 인스턴스와 Double 인스턴스가 와야하는 곳에 정수와 실수 값이 들어가있다. 

이 상황에선 이미 오토 박싱이 실행된 것이다. 

Integer iObj = 10;           ->            Integer iObj = new Integer(10);

Double dObj = 3.14;       ->            Double dObj  = new Double(3.14);

 

위처럼 오토 언박싱 또한 진행되었다. 

int num1 = iObj;               ->         int num1 = iObj.intValue();

double num2 = dObj;        ->         double num2 = dObj.doubleValue();

 

class AutpBoxingUnboxin2{
	public static void main(String[] args){
		Integer num = 10;
		num++;		//오토 박싱, 오토 언박싱 진행
		System.out.println(num);

		num += 3;
		System.out.println(num);

		int r = num + 5;	// 오토 언박싱 진행
		Integer rObj = num - 5;
		System.out.println(r);
		System.out.println(rObj);
	}
}

num++              -> new Integer(num.intValue() + 1);

num += 3          -> new Integer(num.intValue() + 3);

 

Number 클래스와 래퍼 클래스의 static 메소드

class NumberMethod{
	public static void main(String[] args){
		Integer num1 = new Integer(29);
		System.out.println(num1.intValue());	//int형 값으로 반환
		System.out.println(num1.doubleValue());	//double형으로 반환

		Double num2 = new Double(3.14);
		System.out.println(num2.intValue());	//int형 값으로 반환
		System.out.println(num2.doubleValue());	//double형 값으로 반환
	}
}
		

integer 를 double 형으로 반환할 수도 있고, double을 integer로 반환할 수도 있지만 반환값에 차이가 있으므로 이 부분을 주의해야 한다.

 

class WrapperClassMethod{
	public static void main(String[] args){
		//클래스 메소드를 통한 인스턴스 생성 방법 두 가지
		Integer n1 = Integer.valueOf(5);	// 숫자 기반 Integer 인스턴스 생성
		Integer n2 = Integer.valueOf("1024");	//문자 기반 Integer 인스턴스 생성

		//대소 비교와 합을 계산하는 클래스 메소드
		System.out.println("큰 수 : " + Integer.max(n1,n2));
		System.out.println("작은 수 : " + Integer.min(n1,n2));
		System.out.println("합계 : " + Integer.sum(n1,n2));
		System.out.println();

		//정수에 대한 2진, 8진, 16진수 표현 결과를 반환하는 클래스 메소드
		System.out.println("12의 2진 표현: " + Integer.toBinaryString(12));
		System.out.println("12의 8진 표현: " + Integer.toOctalString(12));
		System.out.println("12의 6진 표현: " + Integer.toHexString(12));
	}
}

Integer.valueOf();를 사용할 수도 있다. 

Integer.valueOf(5);            -> new Integer(5);  와 같은 값이 나온다.

 

Integer.max   :  최대값 추출

Integer.min   :  최솟값 추출

Integer.sum  : 합계 추출

 

BigInteger 클래스과 BigDecimal 클래스

import java.math.BigInteger;

class SoBigInteger{
	public static void main(String[] args){
		//long형으로 표현 가능한 값의 크기 출력
		System.out.println("최대 정수: " + Long.MAX_VALUE);
		System.out.println("최소 정수: " + Long.MIN_VALUE);
		System.out.println();

		//매우 큰 수를 BigInteger 인스턴스로 표현
		BigInteger big1 = new BigInteger("100000000000000000000");
		BigInteger big2 = new BigInteger("-99999999999999999999");
	
		//BigInteger 기반 덧셈 연산
		BigInteger r1 = big1.add(big2);
		System.out.println("덧셈 결과 : " + r1);
	
		//BigInteger 기반 곱셈 연산 
		BigInteger r2 = big1.multiply(big2);
		System.out.println("곱셈 결과: " + r2);
	
		//인스턴스에 저장된 값을 int 형 정수로 변환
		int num = r1.intValueExact();
		System.out.println("From BigInteger : " + num);
	}
}

BigInteger : int형 중 가장 긴 정수 표현이 가능한 long보다도 큰 수를 표현해야 할 때 사용하는 클래스이다. 

덧셈 : public BigInteger add(BigInteger val)

뺄셈 : public BigInteger subtract(BigInteger val)

곱셈 : public BigInteger multiply(BigInteger val)

나눗셈의 몫 : public BigInteger divide(BigInteger val)

나눗셈의 나머지 : public BigInteger remainder(BigInteger val)

 

class DoubleError{
	public static void main(String[] args){
		double d1 = 1.6;
		double d2 = 0.1;
		System.out.println("덧셈 결과: " + (d1 + d2));
		System.out.println("곲셈 결과: " + (d1 * d2));
	}
}

위처럼 더블형으로는 오차가 발생한다. 

그러한 오차가 없는 계산을 하고 싶을때 사용하는것이 바로 BigDecimal 클래스 이다. 

 

import java.math.BigDecimal;

class WowBigDecimal{
	public static void main(String[]  args){
		BigDecimal d1 = new BigDecimal("1.6");
		BigDecimal d2 = new BigDecimal("0.1");
		System.out.println("덧셈 결과 : " + d1.add(d2));
		System.out.println("곱셈 결과 : " + d1.multiply(d2));
	}
}

이렇게 오차가 없다는 것을 알 수 있다. 

그러나 일반적인 연산의 경우에는 해당 클래스가 무겁기에 정확한 연산을 요하는 때가 아니라면 사용하지 않는다. 

 

Math클래스

class SimpleMathUse {
    public static void main(String[] args) {
        System.out.println("원주율: " + Math.PI);
        System.out.println("2의 제곱근: " + Math.sqrt(2));
        System.out.println();
        
        System.out.println("파이에 대한 Degree: " + Math.toDegrees(Math.PI));
        System.out.println("2 파이에 대한 Degree: " + Math.toDegrees(2.0 * Math.PI));
        System.out.println();

        double radian45 = Math.toRadians(45);    // 라디안으로의 변환!
        
        System.out.println("싸인 45: " + Math.sin(radian45));
        System.out.println("코싸인 45: " + Math.cos(radian45));
        System.out.println("탄젠트 45: " + Math.tan(radian45));
        System.out.println();
        
        System.out.println("로그 25: " + Math.log(25));
        System.out.println("2의 16승: "+ Math.pow(2, 16));
    }
}

이처럼 다양한 수학 연산을 할 수 있다. 

 

import java.util.Random;

class RandomNumberGenerator{
	public static void main(String[] args){
		Random rand = new Random();

		for(int i = 0; i < 7; i++){
			System.out.println(rand.nextInt(1000));	//0이상 1000미만 난수 생성
		}
	}
}

Random 클래스를 사용하면 난수를 생성할 수 있다. 

public boolean nextBoolean()    boolean형 난수 반환

public int nextInt()    int형 난수 반환

public long nextLong()    long형 난수 반환

public int nextIng(int bound)    0이상 bound 미만의 int형 난수 반환

public float nextFloat()    0.0이상 1.0 미만의 float형 난수 반환

public double nextDouble()    0.0이상 1.0미만의 double형 난수 반환

 

씨드 기반의 난수 생성

컴퓨터의 난수는 진짜 난수가 아닌 진짜처럼 보이는 가짜 난수의 성질을 갖고 있다

숨겨진 패턴이 있고 해당 패턴은 씨드에 따라 같은 씨드를 갖는다면 해당 패턴은 일치하는 성격을 갖고 있다. 

import java.util.Random;

class PseudoRandom{
	public static void main(String[] args){
		Random rand = new Random(12);

		for(int i  = 0; i<7; i++){
			System.out.println(rand.nextInt(1000));
		}
	}
}

 

토큰 구분

"PM:08:45"

위와 같은 문자열이 존재할다고 할 때. 해당 문자열을 이루는 정보는 세가지

PM, 08, 45

콜론을 기준으로 나뉘고 있으며 콜론은 '구분자'의 역할을 하고, 구분자를 기준으로 나뉜 문자열 조각들은 '토큰'이다. 

 

이런 토큰을 추출하는 클래스가 StringTokenizer 클래스이다. 

import java.util.StringTokenizer;

class TokenizerString{
	public static void main(String[] args){
		StringTokenizer st1 = new StringTokenizer("PM:08:45",":");

		while(st1.hasMoreTokens())
			System.out.print(st1.nextToken() + ' ');
		System.out.println();

		StringTokenizer st2 = new StringTokenizer("12 + 36 - 8 / 2 = 44", "+-/= ");

		while(st2.hasMoreTokens())
			System.out.print(st2.nextToken() + ' ');
		System.out.println();
	}
}

public boolean hasMoreToken()   : 반환할 토큰이 남아있는지 확인

public String nextToken()   : 다음 토큰을 반환

 

두번째는 공백도 구분자로 포함되어 있는것을 알 수 있다. 공백을 구분자로 포함시키지 않는다면 토큰들 사이에 공백이 2칸으로 생길 수 있다. 

 

토큰들 사이에 공백을 안넣고 싶다면 이렇게 표현하면 된다.