[JAVA]18일차(wrapper(래퍼) 클래스/오토박싱/오토언박싱)
8월9일(월)
Test121~Test133
◼ Wrapper(래퍼) 클래스
// 자바의 정석 p.490
1. 자바에서는 언어 수준에서 제공하는 기본형 데이터를 제외한
나머지는 클래스로 정의하여 객체 단위로 처리한다.
따라서 자바에서는 이러한 기본형 데이터를
객체 단위로 처리할 수 있도록 클래스를 제공할 수 밖에 없는데
이러한 클래스들을 가리켜 Wrapper(래퍼) 클래스라 한다.
"10" → Stirng → 객체 → Object
↓
객체 → Integer → 메소드 parseInt() → 10
-------
// Wrapper를 Integer로 봐도됨!
Integer.parseInt(br.readLine());
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)
문자열 형식으로 저장된 숫자를 정수 형태로 변환한다.
↓ ↓ ↓
//Integer i = new Integer();
//i.parseInt() 라고 안하고
//Integer.parseInt() 라고 하는 이유는 parseInt가 static 메소드이기 때문이다!
static Integer valueOf(int i)
int 형을 Integer 형으로 변환한다.
byte byteValue(), int intValue(),
short shortValue(), long long Value(),
float floatValue(), double doubleValue()
해당 기본 자료형으로 형 변환한 값을 반환한다.*/
◼ 오토 박싱(Auto-Boxing)과 오토 언박싱(Auto-Unboxing)
check~!!!
BufferedReader br = "abcd"; 이렇게 쓰지않고
BufferedREader br = new BufferedReader() 이런식으로 쓴다.
일반적으로 래퍼런스 형과 기본 자료형은 호환되지 않으며
이 경우 발생하는 문제 해결을 위해 자바에서는 Wrapper 클래스를 제공하게 되었다.
하지만, JDK 1.5 부터 레퍼런스 형과 기본 자료형이
다음과 같이 형 변환이 가능하게 되었다.
int a = 10, b;
Integer ob; // ob는 지금 주소값을 참조하는건데 int 값인 a 를 바로 넣어주는 것!
//Rect rec = 10; 이거 실제론 불가능! 하지만 오토박싱에서 가능하게 해줌!
ob = a;
//-- 기본 자료형(int)이 Integer 형으로 자동 변환 (오토 박싱)
// 실제로는 ... 『ob = new Integer(a);』
b = ob;
//-- Integer(객체)가 기본 자료형인 int 형으로 자동 변환 (오토 언박싱)
// 실제로는 ... 『b = ob.intValue();』
// 이는 JDK 1.5 이후 추가된 오토 박싱 / 오토 언박싱 이라는
// 기능으로 인해 가능해진 것이다.*/
▪ Wrapper(래퍼) 클래스 코드 설명1📝
public class Test126
{
public static void main(String[] args)
{
int a = 10, b;
Integer c;
Object d;
b = a; //-- int 형 데이터(자료) -> int 형 변수
c = new Integer(0); //-- c는 객체타입
// ※ 레퍼런스 형(참조타입)과 기본 자료형(기본 타입)은 호환되지 않는다.
b = c; //-- Integer 형 데이터(객체) c를 int형 변수에 담겠다는것 (오토 언박싱)
b = c.intValue(); //원래는 이렇게 담아줘야함!! (언박싱)
d = new Object();
System.out.println("d.toString() : " + d.toString());
//--==>> d.toString() : java.lang.Object@15db9742
System.out.println("d : " + d);
//--==>> d : java.lang.Object@15db9742
d = new Integer(10); //-- Object 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());
System.out.println("d : " + d);
//--==>> d.toString() : 12.345
// d : 12.345
d = 10; //--오토 박싱
System.out.println("d.toString() : " + d.toString());
System.out.println("d : " + d);
//--==>> d.toString() : 10
// d : 10
}
}▪ Wrapper(래퍼) 클래스 코드 설명2(Integer 클래스)📝
public class Test127
{
public static void main(String[] args)
{
/*
boolean bi = true; //1 byte 기본 자료형
Boolean wrapBi = new Boolean(bi); // 불린 클래스타임의 객체 형식
Boolean wBi = bi; //--(오토 박싱) 원칙적으로 기본형에 객체를 넣는거 안되는데 이제 된다!
int ni = 300;
Integer wrapNi = new Integer(ni);
int ni2 = wrapNi; //-- (오토 언박싱)
float fi = 300.3f;
Float wrapFi = new Float(fi);
System.out.println(wrapBi.toString()); //-- 객체형식
System.out.println(wrapNi.toString()); //-- 객체형식
System.out.println(wrapFi.toString()); //-- 객체형식
//--==>> true
// 300
// 300.3
System.out.println(wrapBi);
System.out.println(wrapNi);
System.out.println(wrapFi);
//--==>> true
// 300
// 300.3
int ni 겹치니까 잠시 주석처리 */
// Integer 클래스
String sn = "12";
int ni = Integer.parseInt(sn);
System.out.printf("ni : %3d\n", ni);
//--==>> ni : 12
ni = Integer.parseInt("0101",2); //--매개변수가 2개인 parseInt도 있다. 오버로딩
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); //2진수
System.out.printf("sn : %s\n",sn);
//--==>> sn : 10100
sn = Integer.toHexString(31); //16진수
System.out.printf("sn : %s\n",sn);
//--==>> sn : 1f
sn = Integer.toOctalString(31); //8진수
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(래퍼) 클래스 코드 설명3(BigInteger)📝
import java.math.BigInteger;
public class Test128
{
public static void main(String[] args)
{
//int a1 = 123456789123456789; //담을 수 없다.
//long b1 = 123456789123456789123456789L; //담을 수 없다.
//System.out.println(a1);
//System.out.println(b1);
// 이렇게 큰 값을 담으려면 BigInteger 쓴다~!
BigInteger a = new BigInteger("123456789123456789"); //check~!!! 매개변수 문자열로 넘겨받게함 왜?
// -> 인트로 담으면 그만큼밖에 못담으니까! 문자열!
BigInteger b = new BigInteger("123456789123456789");
//BigInteger c = a + b;
//System.out.println(c); // 일반적인 산술 연산자(+)를 통해서 연산이 불가능하다!
// 더하기
BigInteger c = a.add(b);
System.out.println("덧셈 결과 : " + c);
//--==>> 덧셈 결과 : 246913578246913578
// 빼기
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)); // .pow() check~!!
//--==>> 2의 3승 : 8
}
}▪ Wrapper(래퍼) 클래스 코드 설명4(BigDecimal(실수형)📝
import java.math.BigDecimal;
public class Test129
{
public static void main(String[] args)
{
BigDecimal a = new BigDecimal("123456789.123456789");
// movePointLeft() : 소수점을 왼쪽으로 이동
BigDecimal b = a.movePointLeft(3);
System.out.println(b);
//--==>> 123456.789123456789
// 나눗셈 : divide() -> 대체 속성 확인, 반올림 하지 않는다. -> 절삭
BigDecimal c = a.divide(b, BigDecimal.ROUND_DOWN); //ROUND_DOWN은 이름만 봐도 static final 이겠구나
System.out.println(c);
//--==>> 1000.000000000
System.out.println(BigDecimal.ROUND_DOWN);
//--==>> 1
// toBigInteger()
// Decimal을 -> BigInteger 객체로 변환
System.out.println(a.toBigInteger());
//--==>> 123456789
}
}▪ Wrapper(래퍼) 클래스 코드 설명5📝
public class Test130
{
public static void main(String[] args)
{
byte b = 3;
int i = 256;
Byte b2 = new Byte(b); //Boxing
Integer i2 = new Integer(i); //Boxing
System.out.println(b2);
System.out.println(i2);
//--==>> 3
// 256
print(b2);
print(i2);
// Byte 클래스의 byteValue() 메소드 호출
byte b3 = b2.byteValue();
// Integer 클래스의 intValue() 메소드 호출
int i3 = i2.intValue();
System.out.println(b3);
System.out.println(i3);
//--==>> 3 //Unboxing
// 256 //Unboxing
//check~!!!
int i4 = b2.byteValue(); //b2는 객체타입 b2.byteValue()는 기본 자료형의 바이트 타입을 반환!! -> 3
//byte b4 = i2.intValue(); //i2 자체가 객체인데 intValue()로 반환하면 int 형으로 반환! -> 256 -> 에러 발생!!!
byte b4 = i2.byteValue(); //--==>> 반드시 확인!!! 바이트 타입으로 바꿔도 담기지 않음
//check~!!!
System.out.println(i4);
//--==>> 3
//System.out.println(b4);
// 이거는 int가 더 커서 오류남!
System.out.println(b4);
//--==>> 0
}
//위에 프린트를 인스턴스 생성없이 호출이 가능하게 하려면?
/*
static void print(Byte b) // 이건 b2만 처리됨
{
...;
}
static void print(Integer i) // i도 처리하려면 이거도 만들어
{
...;
}
static void print(int i)
{
...;
}
static void print(Object o) // 이거는 뭘넣어도 다됨!!
{
...;
}
*/
// java lang.Number 클래스(추상 클래스)는 Number ob = new Number(); 이렇게 인스턴스 생성할 수 없다!
// 모든 Wrapper 클래스들의 부모 클래스
// (슈퍼 클래스, 상위 클래스)이다.
// b2, i2 자료형이 Number n 에 넘어오면서
// Auto-Boxing 이 일어나게 된다.
public static void print(Number n)
{
System.out.println("++" + n);
System.out.println(n.intValue());
}
}
/*
3
256
++3
3
++256
256
3
256
3
0
계속하려면 아무 키나 누르십시오 . . .
*/▪ Wrapper(래퍼) 클래스 코드 설명6📝
public class Test131
{
public static void main(String[] args)
{
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
//--==>> 2147483647
// -2147483648
System.out.println(Long.MAX_VALUE);
System.out.println(Long.MIN_VALUE);
//--==>> 9223372036854775807
// -9223372036854775808
System.out.println(Double.MAX_VALUE);
System.out.println(Double.MIN_VALUE);
//--==>> 1.7976931348623157E308
// 4.9E-324
System.out.println();
System.out.println("1 : " + 3.0/0); //-- 무한대를 의미
System.out.println("2 : " + -3.0/0);
//--==>> 1 : Infinity
// 2 : -Infinity
System.out.println("3 : " + (3.0/0 == 3.0/0));
System.out.println("4 : " + (3.0/0 == -3.0/0));
//--==>> 3 : true
// 4 : false //양수 인피티니랑 음수 인피니티 다르다!
// 『Double.isInfinite()』 //둘다 양수 인피니티로 나타낸다.
// is 로 시작하는 메소드는 true / false값으로 반환한다!!! //check~!!!
System.out.println("5 : " + Double.isInfinite(3.0/0));
System.out.println("6 : " + Double.isInfinite(-3.0/0));
//--==>> 5 : true
// 6 : true
System.out.println("7 : " + (3.0/0 + -3.0/0));
System.out.println("8 : " + (0.0/0));
//--==>> 7 : NaN(→ Not a Number) 난
// 8 : NaN
System.out.println("9 : " + (0.0/0 == 0.0/0));
System.out.println("10 : " + (0.0/0 != 0.0/0));
//--==>> 9 : false 왜?!? 앞도 NaN이고 뒤도 NaN인데 왜?!!?
// NaN은 숫자가 아니니까 비교를 할 수가 없다!
//--==>> 10 : true
// ※ NaN(Not a Number) 값과 임의의 수를
// 『==』 연산자를 통해 비교 연산을 수행하게 되면
// 결과는 언제나 『false』를 반환한다.
// NaN인지 아닌기 확인하는 메소드
// 『Double.isNaN()』 -------> static 메소드 클래스명.메소드명()
System.out.println("11 : " + Double.isNaN(0.0/0));
System.out.println("12 : " + Double.isNaN(1.1+2.2));
//--==>> 11 : true
// 12 : false
}
}Author And Source
이 문제에 관하여([JAVA]18일차(wrapper(래퍼) 클래스/오토박싱/오토언박싱)), 우리는 이곳에서 더 많은 자료를 발견하고 링크를 클릭하여 보았다 https://velog.io/@hyojin_j/JAVA18일차wrapper-클래스오토박싱오토언박싱저자 귀속: 원작자 정보가 원작자 URL에 포함되어 있으며 저작권은 원작자 소유입니다.
우수한 개발자 콘텐츠 발견에 전념
(Collection and Share based on the CC Protocol.)
좋은 웹페이지 즐겨찾기
