chapter 9. java.lang 패키지와 유용한 클래스
Object클래스
: 모든 클래스의 최고조상. 오직 11개의 메서드만을 가지고 있음.(iv, cv없음)
: norify(), wait() 등은 쓰레드와 관련된 메서드
finalize() : 생성자와 반대되는 개념 -> 객체가 제거하기전에 마무리 작용
protected되어있는 것을 오버라이딩해서 public로 변경해야함 (finalize도 마찬가지)
class Class {}: 클래스의 정보를 담기위한 클래스
*.class (자바소스 컴파일 하면 생성되는 파일) 이 메모리에 올라갈때 class객체가 자동으로 만들어짐 ( 여기에는 클래스에 대한 정보가 들어있음(설계도 객체) ) getClass를 호출하면 설계도 객체를 반환함.
설계도를 가지고 객체 생성도 하고 정보를 얻을 수 있도록한것을 reflection API라고 함 .
equals(Obhect obj)
- 객체 자신과 주어진 객체를 비교. 같으면 true, 다르면 false 반환
- Object 클래스의 equals()는 객체의 주소를 비교(참조변수값 비교)
class Ex9_1 {
public static void main(String[] args) {
Value v1 = new Value(10);
Value v2 = new Value(10);
if (v1.equals(v2))
System.out.println("v1과 v2는 같습니다.");
else //equals는 주소 비교 -> 서로 다른 객체는 항상 거짓
System.out.println("v1과 v2는 다릅니다.");
} // main
}
class Value {
int value;
Value(int value) {
this.value = value;
}
public boolean equals(Object obj){
//return this == obj; //원래 equals
//Object의 equals()를 오버라이딩해서 주소가 아닌 value를 비교
//참조변수의 형변환 전에는 반드시 instanceof로 확인해야함
if(obj instance Value)) return false;
Value v = (Value)obj; //obj를 value로 형변환 (Value라는 리모콘에는 value가 있지만 Object는 없기 때문 )
return this.value == v.value; //이렇게 오버라이딩 하면 객체의 값을 비교할 수 있음
}
}
대부분의 경우 인스턴스(iv)의 값을 비교하도록 equals()를 오버라이딩 해야함
cv : 객체마다 공통(공유) / iv : 객체마다 다름(개별)
hashCode()
- 객체의 해시코드를 반환하는 메서드 / 정수값으로 해싱알고리즘에 사용됨 (11장 참고)
- Object클래스의 hashCode()는 객체의 주소를 int로 변환해서 반환 (객체마다 다른 값)
public class Object{
...
public native int hashCode(); //내용 X -> native 메서드 : OS가 이미 가지고 있는 메서드 (C언어로 작성)- equals()를 오버라이딩하면, hashCode()도 오버라이딩해야함 : equals를 iv를 가지고 하도록 오버라이딩하면 hashCode도 iv를 가지고 하도록 오버라이딩해야함 (equals 결과가 true인 두 객체의 해시코드는 같아야하기 때문)
- System.identityHashCode(Object obj)는 Object클래스의 hashCode()와 동일 //hashCode를 오버라이딩(iv가지고) 한 경우 객체마다 다른 hashcode가 필요할때 사용함
toString()
- 객체를 문자열로 변환하기 위한 메서드
import java.util.Objects;
class Card {
String kind;
int number;
Card() {
this("SPADE", 1);
}
Card(String kind, int number) {
this.kind = kind;
this.number = number;
}
// iv 비교하도록 equals 오버라이딩
public boolean equals(Object obj) { //반드시 Object 여야..-> 오버라이딩은 선언부 일치해야함
if(!(obj instanceof Card))
return false;
Card c= (Card)obj;
return this.kind.equals(c.kind) &&this.number==c.number;
}
//equals를 오버라이딩하면 hashCode도 오버라이딩해줘야함
public int hashCode() {
return Objects.hash(kind,number)
}
//Object클래스의 toString()를 오버라이딩
public String toString() {
return "kind:"+kind+", number:"+number;
}
}
class Ex9_4 {
public static void main(String[] args) {
Card c1 = new Card();
Card c2 = new Card();
System.out.println(c1.toString());
System.out.println(c2.toString());
}
}
String 클래스
- 문자열을 다루는데 사용되는클래스
- 데이터(char[]) + 메서드(문자열 관련)
- 내용을 변경할 수 없는 불변 클래스 (immutable class)
- 덧셈 연산자를 이용한 문자열 결합은 성능이 떨어짐(문자열은 내용을 변경할 수 없기 떄문) / 문자열의 결합이나 변경이 잦다면, 내용을 변경가능한 StringBuffer를 사용
문자열의 비교
- String str ="abc" 와 String str = new String("abc")
String str1= "abc" ; //문자열 리터럴 "abc"의 주소가 str1에 저장
String str1= "abc" ;
String str3 = new String("abc") // 새로운 String인스턴스를 생성
String str3 = new String("abc")
Stirng는 불변이기 떄문에 굳이 새로운 객체를 만들필요없음
문자열 리터럴
- 문자열 리터럴은 프로그램 실행시 자동으로 생성됨 (constant pool에 저장)
- 같은 내용으이 문자열 리터럴은 하나만 만들어짐 (위에서 str1,str2는 하나의 문자열 리터럴을 가리킴)
빈 문자열 ("", empty string)
- 내용이 없는 문자열, 크기가 0인 char형 배열을 저장하는 문자열
String str =''; //str을 빈 문자열로 초기화
-크기가 0인 배열을 생성하는 것은 어느타입이나 가능
char [] chArr = new char[0]; //길이가 0인 char배열
int[] iArr ={}; //길이가 0인 int배열
-문자(char)와 문자열(String)의 초기화
//문자열 초기화
String s =null;
String str = new String(""); // 계속 빈 배열이 만들어짐 -> 좋지 않음
String s =""; //이 방법이 더 좋음
//문자 초기화
char c ='\u0000';
char c =' '; //이 방법이 더 좋음String 클래스의 생성자와 메서드
- String(String s) : 주어진 문자열을 갖는 String인서턴스 생성
String s = new String("Hello"); - String(char[] value) : 주어진 문자열을 갖는 String인스턴스를 생성 (반대는 toCharArray)
char[] c={'H','e','l','l','o'}; String s= new String(c); - String(StringBuffer buf) : StringBuffer인서턴스가 갖고 있는 문자열과 같은 내용의 String 인스턴스 생성
StringBuffer는 내용변경가능한 문자열StringBuffer sb= new StringBuffer("Hello"); String s= new String(sb);
StringBuffer을 String로 만들때 사용되는 생성자(반대로 바꿀때는 StringBuffer의 생성자를 사용하면됨) - char charAt(int index) : 지정된 위치에 있는 문자를 알려줌
String s = "Hello"; String n = "0123456"; char c = s.charAt(1); char c2 = n.charAt(1); //c ='e' //c2='1' - int compareTo(String err) : 문자열과 사전순서로 비교. 같으면 0/ 이전이면 음수, 이후면 양수 반환 (정렬할때 사용 -> 11장 참고)
int i = "aaa".compareTo("aaa"); int i2 ="aaa".compareTo("bbb"); int i3 = "bbb".compareTo("aaa"); // i=0 //i2=-1 //i3=1 - String concat(String str) : 문자열을 뒤에 덧붙임
String s = "Hello"; String s2 = s.concat("World"); - boolean contains(CharSequence s) : 포함여부 확인
CharSequence : 인터페이스 -> 장점은 서로 관계없는 클래스들의 관계를 맺어줌String s= "abcdefg"; boolean b= s.contains("bc");
CharBuffer, Segment, String, StringBuffer, StringBuilder이 이 인터페이스를 구현 (공통조상이 없는 사이에 공통점이 생김/ 이 인터페이스를 구현한 것들은 상속 관계와 상관없이 매개변수로 들어갈 수 있음 -> 여러종류의 클래스가 들어갈 수 있게 함 ) - boolean endsWith(String suffix): 지정된 문자열로 끝나는지 검사
String file = "Hello.txt"; boolean b= file.endsWith("txt"); //true - boolean equals(Object obj) : 매개변수로 받은 문자열과 String인스턴스의 문자열을 비교. obj가 String이 아니거나 문자열이 다르면 false반환
String s = "Hello"; boolean b= s.equals("Hello"); boolean b2 =s.equals("hello"); //b=true //b2=false - boolean equalsIgnoreCase(String str) : 문자열 String인스턴스의 문자열을 대소문자 구분없이 비교
String s = "Hello"; boolean b= s.equalsIgnoreCase("HELLO"); boolean b2=s.equalsIgnoreCase("heLLo"); //b,b2 =true - int indexOf(int ch): 주어진 문자가 문자열에 존재하는지 확인하여 위치를 알려줌. 못찾으면 -1반환
String s ="Hello"; int idx1=s.indexOf('o'); int ind2=s.indexOf('k') //ind1=4 //ind2=-1 - int indexOf(int ch, int pos) : 주어진 문자가 문자열에 존재하는지 지정된 위치(pos)부터 확인하여 위치를 알려줌. 못찾으면 -1을 반환
String s="Hello"; int idx1 = s.indexOf('e',0); int idx2 = s.indexOf('e',2); //idx =1 //idx2 =-1 - int indexOf(String str) : 주어진 문자열이 존재하는지 확인하여 그 위치를 알려줌. 없으면 -1을 반환
String s = "ABCDEFG"; int idx = s.indexOf("CD"); //idx =2 - int lastIndexOf(int ch) : 지정된 문자 또는 문자코드를 문자열의 오른쪽 끝에서부터 찾아서 위치를 알려줌. 못찾으면 -1을 반환
String s = "java.lang.Object"; int idx1=s.lastIndexOf('.'); int idx2=s.indexOf('.'); //idx1=9 //idx2=4 - int lastIndexOf(String str) : 지정된 문자열을 인스턴스의 문자열 끝에서부터 찾아서 위치를 알려줌. 못찾으면 -1을 반환
String s = "java.lang.java"; int idx1 = s.lastIndexOf("java"); int idx2 = s.indexOF("java"); //idx1=10 //idx2=0 - int length() : 문자열의 길이를 알려줌
String s ="Hello"; int length = s. length(); //length =5 - String[] split(Sting regex) : 문자열을 지정된 분리자로 나누어 문자열 배열에 담아 반환
String animals ="dog,cat,bear"; String[] arr = animals.split(","); //arr[0] ="dog"; //arr[1]="cat"; //arr[2]="bear"; - String[] split(String regex, int limit) : 문자열을 지정된 분리자로 나누어 문자열 배열에 담아 반환. 단 문자열 전체를 지정된 수로 자름
String animals ="dog,cat,bear"; String[] arr = animals.split(",",2); //arr[0] ="dog"; //arr[1]="cat,bear"; - boolean startsWith(String prefix) : 주어진 문자열로 시작하는지 검사
String s = "java.lang.Object"; boolean b= s.startsWith("java"); boolean b2 =s.startWith("lang"); //b=true //b2=false - String substring(int begin) : 문자열 자르기
String substring(int begin, int end) : 주어진 시작위치로부터 끝위치에 범위에 포함된 문자열을 얻음. 이때 시작위치의 문자는 범위에 포함. 끝위치는포함되지 않음 / 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 s ="Hello"; String s1 =s.toLowerCase(); - String toUpperCase() : String인스턴스에 저장되어있는 모든 문자열을 대문자로 변환하여 반환
String s1 = s.toUpperCase(); - String trim () : 문자열의 왼쪽 끝과 오른쪽 끝에있는 공백을 없엔 결과를 반환. 문자열 중간의 공백은 제거하지 않음
String s = " Hello world "; String s1 =s.trim(); //s1="Hello world" - static String valueOf() : 지정된 값을 문자열로 변환하여 반환.( 기본형을 문자열로 변환 ) 참조변수의 경우 toString()을 호출한 결과를 반환 / 빈문자열을 더한것과 같은 결과이지만 valueOf가 더 빠름
StringJoiner, 문자열과 기본형의 변환
join()은 여러 문자열 사이에 구분자를 넣어서 결합함
String animals ="dog,cat,bear";
String[] arr = animals.split(",");// 문자열을 ','를 구분자로 나눠서 배열에 저장
Stirng str = String.join("-",arr);//배열의 문자열을 '-' 로 구분해서 결합
//str=dog-cat-bear문자열을 +로 연결하면 객체가 계속 만들어져 성능이 떨어질 수 있음. join의 경우 내부적으로 StringBuffer을 사용해서 속도를 향상시키도록 코드가 작성되어있음
문자열과 기본형 간의 변환
- 숫자를 문자열로
int i =100;
String str = i +""; //편리함
String str2= String.valueOF(i); //빠름- 문자열을 숫자로
int i = Interger.ParseInt("100"); //old
int i2 = Interger.ValueOF("100); //new
Integer i2 = Inter.valueOF("100"); //원래는 반환 타입이 Integer (참조형) -> 오토박싱때문에 기본형으로 써도 괜찮음
StringBuffer클래스
-문자열을 다루기 위한 클래스
-String처럼 문자열배열(char[])을 내부적으로 가지고 있음
-String과 달리 내용을 변경할 수 있음
StringBuffer sb= new StringBuffer("abc");
sb.append("123");
-배열은 길이 변경 불가. 공간이 부족하면 새로운 배열을 생성해야함
1. 새로운 배열 생성(보통 2배짜리) 2. 내용복사 3. 참조 변경
- StringBuffer는 저장할 문자열의 길이를 고려해서 적절한 크기로 생성해야함
public StringBuffer(int length){ //length에 적절한 크기를 지정해야함
value= new char[length];
shared=false;
}
public StringBuffer(){
this.(16); // 버퍼의 크기를 지정하지 않으면 버퍼의 크기는 16이됨(의미있는숫자는아님)
}
public StringBuffer(string str){
this(str.lengh()+16);//지정한 문자열의 길이보다 16이 더 크게 버퍼생성
append(str);
}
-StringBuffer는 내용변경 가능
-append는 지정된 내용을 StringBuffer에 추가후 StringBuffer의 참조를 반환
StringBuffer sb2 = sb.append("ZZ"); //sb의 내용뒤에 "ZZ"를 추가
//sb = abc123ZZ
//sb2= abc123ZZ
//append의 반환타입이 StringBuffer이기때문에 아래와 같이 쓸 수 있음
sb.append("123").append("ZZ");
//아래와 동일 (성능차이 X)
sb.append("123");
sb.append("ZZ");
-StringBuffer는 equals()가 오버라이딩되어있지 않아 주소비교함(Sting는 오버라이딩 되어있어 내용비교)
-StringBuffer는 String으로 변환 후에 equals()로 비교해야함
StringBuffer의 생성자와 메서드
- StringBuffer() : 16문자를 담을수 있는 버퍼를 가진 StringBuffer 인스턴스 생성
- StringBuffer(int length) : 지정된 개수의 문자를 담을 수 있는 버퍼를 가진 StringBuffer인스턴스 생성
- StringBuffer(String str) : 지정된 문자열 값을 갖는 SringBuffer 인스턴스를 생성
StringBuffer sb= new StringBuffer(); StringBuffer sb= new StringBuffer(10); StringBuffer sb= new StringBuffer("Hi"); - StringBuffer append(*) : 매개변수르 입력된 값을 문자열로 변환하여 StringBuffer인스턴스가 저장하고 있는 문자열 뒤에 덧붙임
StringBuffer sb = new StringBuffer("abc"); StringBuffer sb2 = sb.append(true); sb.append('d').append(10.0f); StringBuffer sb3 =sb.append("ABC").appemd(123); //sb= "abctrued10.0ABc123" //sb2= "abctrued10.0ABc123" //sb3= "abctrued10.0ABc123" //sb,sb2,sb3가 모두 같은 객체를 가리킴 - int capacity() : StringBuffer 인스턴스의 버퍼크기를 알려줌.
- int length() : 버퍼에 담긴 문자열의 길이를 알려줌
StringBuffer sb = new StringBuffer(100); sb.append("abcd"); int bufferSize = sb.capacity(); //100 int stringSize = sb.length();//4 - char charAt(int index) : 지정된 위치에 있는 문자를 반환
StringBuffer sb = new StringBuffer("abc"); char c = sb.charAt(2); //c='c' - StringBuffer delete(int start, int end) : 시작위치부터 끝 위치 사이에 있는 문자 제거
StringBuffer sb = new StringBuffer("0123456"); StringBuffer sb2= sb.delete(3,6); //sb="0126" //sb2="0126" - StingBuffer deleteCharAt(int index) : 지정된 위치의 문자 제거
StringBuffer sb = new StringBuffer("0123456"); sb.deleteCharAt(3); //sb ="012456" - StringBuffer insert() : 두번째 매개변수로 받을 값을 문자열로 변환하여 지정된 위치에 추가
StringBuffer sb = new StringBuffer("0123456"); sb.insert(4,','); //sb="0123.456" - StringBuffer replace(int start, int end, String str) : 지정된 범위의 문자들을 주어진 문자열로 바꿈 (start<=x<end)
StringBuffer sb = new StringBuffer("0123456"); sb.replace(3,6,"AB"); //sb="012AB6" - StringBuffer reverse() : StringBuffer인스턴스에 저장되어있는 문자열의 순서를 거꾸로 나열
StringBuffer sb = new StringBuffer("0123456"); sb.reverse(); //sb="6543210" - void setCharAt(int index, char ch) : 지정된 위치의 문자를 주어진 문자로 바꿈
StringBuffer sb = new StringBuffer("0123456"); sb.setCharAt(5,'o'); //sb= "01234o6" - void setLength(int newLength) : 지정된 길이로 문자열의 길이를 변경함. 길이를 늘리는 경우에 나머지 빈공간을 널문자로 채움
StringBuffer sb = new StringBuffer("0123456"); sb.setLength(5); StringBuffer sb2 = new StringBuffer("0123456"); sb2.setLength(5); String str = sb2.toString().trim(); //sb= "01234" //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으로 뽑아서 반환. 시작위치만 지정하면 시작위치로부터 문자열 끝까지 뽑아서 반환
StringBuffer sb = new StringBuffer("0123456"); String st = sb.substring(3); String str2 =sb.substring(3,5); //str="3456" //str2="34"
class Ex9_12 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("01");
StringBuffer sb2 = sb.append(23); //sb와 sb2는 같은 객체를 가리킴
sb.append('4').append(56); //메서드 체어닝 : 메서드를 연결해서 호출 // append가 StringBuffer를 반환하기 때문에 가능
StringBuffer sb3 = sb.append(78);
sb3.append(9.0);
System.out.println("sb ="+sb); //0123456789.0
System.out.println("sb2="+sb2);//0123456789.0
System.out.println("sb3="+sb3);//0123456789.0
System.out.println("sb ="+sb.deleteCharAt(10)); //01234567890
System.out.println("sb ="+sb.delete(3,6));//01267890
System.out.println("sb ="+sb.insert(3,"abc"));//012abc67890
System.out.println("sb ="+sb.replace(6, sb.length(), "END"));//012abcEND
System.out.println("capacity="+sb.capacity());//18
System.out.println("length="+sb.length());//9
}
}문자열 버퍼를 초기화할 때 기본 용량 (capacity)을 할당하게 되는데, 기본 용량은 일반적으로 작게 설정되어 있습니다. 이것은 메모리를 효율적으로 관리하기 위한 것입니다. 그런 다음 문자열을 추가하면 버퍼의 크기를 필요에 따라 동적으로 늘리며, 그 때마다 용량이 두 배씩 늘어납니다.
예를 들어, "012abcEND"라는 문자열을 저장하기 위해 초기 버퍼의 크기는 18로 설정되었을 것입니다. 문자열을 추가하면서 동적으로 확장되었으며, 그 결과로 sb.capacity()가 18이 됩니다.
capacity() 메서드는 문자열 버퍼의 현재 용량을 반환하며, length() 메서드는 버퍼에 저장된 문자열의 길이를 반환합니다. 이 두 메서드를 사용하여 문자열 버퍼의 실제 크기와 저장된 데이터의 길이를 확인할 수 있습니다.
StringBuilder
- StringBuffer는 동기화 되어있음. 동기화는 멀티 쓰레드에 안전하게 하는 것
- 멀트 쓰레드 프로그램이 아닌 경우, 동기화는 불필요한 성능 저하 -> 이럴땐 StringBuilder를 사용하면 성능 향상
//StringBuffer 사용
StringBuffer sb;
sb= new StringBuffer();
sb.apend("abc");
//StringBuilder 사용
StringBuilder sb;
sb= new StringBuilder();
sb.apend("abc"); //append그대로 사용가능
Math클래스
-수학 관련 static메서드의 집합 : 메서드밖에 없어서 static 메서드 . iv가 없으니까 객체를 만들 필요가 없음
Math 클래스는 정적(static) 메서드만으로 구성 -> 클래스 레벨에서 메서드를 직접 호출할 수 있으며 객체를 생성할 필요가 없음을 의미함.
클래스의 인스턴스(객체)를 만들 때, 일반적으로 객체 내에 상태를 저장하고 그 상태에 대한 작업을 수행할 수 있는 인스턴스 변수와 메서드가 있음. 그러나 Math 클래스는 수학 연산을 수행하는 유틸리티 클래스로, 상태를 저장할 필요가 없으며 많은 수학적 연산이 독립적으로 실행될 수 있음. 따라서 Math 클래스는 정적(static) 메서드를 사용하여 계산을 수행하고 결과를 반환하는 방식으로 구현됨.
- 두개의 상수 (public static final double) E, PI를 가짐
Math클래스의 메서드
- static double abc(double a ) , static double abc(float f), static double abc(int f), static double abc(long f) : 주어진 값의 절댓값 반환
int i = Math.abs(-10); //i=10 - static double ceil(double a) : 주어진 값을 올림하여 반환
double d = Math.cell(10.1); //d=11.0 - static double floor(double a) : 주어진 값을 버림하여 반환
double d = Math.floor(10.8); //d=10.0 - static double max(double a, double b) , static float max(float a, float b), static int max(int a, int b), static long max(long a, long b) : 주어진 두 값을 비교하여 큰 쪽 반환
double d = Math.max(9.5,9.50001); int i =Math.max(0,-1); //d=9.50001 //i=0 - static double min(double a, double b),static float min( float a, float b), static int min( int a, int b), static long min( long a, long b) : 주어진 두 값을 비교하여 작은쪽 반환
double d = Math.min(9.5,9.50001); int i =Math.min(0,-1); //d=9.5 //i=-1 - static double random() : 0.0~1.0범위의 임의의 double값을 반환함
double d = Math.random(); int i =(int)(Math.random()*10)+1) - static double rint(double a ): 주어진 double값과 가장 가까운 정수값을 double형으로 반환 (.5는 짝수반환) -> 오차 줄어듦
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 long round(double a) , static long round(float a) : 소수점 첫째자리에서 반올림한 정숫값을 반환. 두 정수의 정가운데 있는 값을 항상 큰 정수를 반환
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); //l=1 //l=3 //l3=4 //l4=5 //d =90.7552 //d2=90.76
래퍼(wrapper) 클래스
- 8개의 기본형을 객체로 다뤄야 할 때 사용하는 클래스
- 객체 지향 언어인 java에 기본형이 존재하는 이유는 성능 때문/ 기본형은 직접접근이 가능함
class Ex9_14 {
public static void main(String[] args) {
Integer i = new Integer(100); //100이라는 값을 갖는 래퍼클래스
Integer i2 = new Integer(100);
System.out.println("i==i2 ? "+(i==i2)); //false
System.out.println("i.equals(i2) ? "+i.equals(i2)); //true : equals가 오버라이딩 되어있음
System.out.println("i.compareTo(i2)="+i.compareTo(i2)); //0 (같으면 0/ 오른쪽 값이 크면 음수)
System.out.println("i.toString()="+i.toString()); //100
System.out.println("MAX_VALUE="+Integer.MAX_VALUE);//2147483647
System.out.println("MIN_VALUE="+Integer.MIN_VALUE);//-2147483648
System.out.println("SIZE="+Integer.SIZE+" bits"); //32
System.out.println("BYTES="+Integer.BYTES+" bytes");//4
System.out.println("TYPE="+Integer.TYPE);//int
}
}래퍼클래스는 기본적으로 int값을 가지고 있지만 타입의 크기같은 정보들도 가지고 있음
Number 클래스
- 모든 숫자 래퍼 클래스의 조상 (추상 클래스)
*Value(intValue,longValue등) : 래퍼객체의 값을 기본형으로 바꿀때 쓰는 메서드를 가지고 있음
intValue() 메서드는 기본 자료형(int)과 래퍼 클래스(Integer) 사이의 변환을 수행하는 메서드.
래퍼 클래스를 기본 자료형으로 변환하는 과정을 "언박싱"이라고 함. 이 때, 래퍼 클래스에서 기본 자료형 값으로 변환하는 작업이 수행
경고가 뜨는 이유는 언박싱은 기본적으로 불필요한 오버헤드를 발생시킬 수 있고, 프로그램의 가독성을 저해할 수 있기 때문. 일반적으로, 언박싱은 필요한 경우에만 수행하는 것이 좋음
따라서 가능한 경우에는 intValue()를 사용하기보다는, 원래의 래퍼 클래스 객체를 사용하거나, 래퍼 클래스를 기본 자료형으로 변환하는 대신 다른 방식을 고려하는 것이 좋음.
문자열을 숫자로 변환하기
- 문자열을 숫자로 변환하는 다양한 방법
int i = new Integer("100").intValue(); //floatValue(), longValue(),
int i2 = Integer.parseInt("100"); //문자열을 integer로 바꾸는 가장 많이쓰는 방법
Integer i3 = Integer.valueOf("100"); //래퍼클래스로 변환가능 Integer대신 Int를 써도됨문자열 -> 기본형은 parse*()를 사용
문자열 -> 래퍼클래스: valueOf();를 사용 또는 래퍼클래스의 생성자를 사용 (Byte b= new Byte("100");
(래퍼크래스 -> 문자열은 toString사용)
- n진법의 문자열 숫자로 변환하는법 (기본적으로 parseInt는 10진수 변환)
int i = Interger.parseInt("100",*) // *에 바꾸려고 하는 진수 입력
//EX
int i4 = Interger.parseInt("100",2) //2진수 4로 변경
오토박싱 & 언박싱
오토박싱 : int -> Integer // 기본형을 래퍼클래스로
언박싱 : Integer -> int // 래퍼클래스를 기본형으로
- JDK1.5 이전에는 기본형과 참조형간의 연산이 불가능했음 -> 이후엔 오토박싱, 언박싱이 되어 연산 가능
int i =5;
Integer iObj = new Integer(7);
int sum = i+iObj; //JDK 1,5이전에는 에러
int sum = i +iObj.intValue(); //JDK1.5 이후 컴파일러 후의 코드 (Integer->int (언박싱))- 기본형의 값을 객체로 자동변환하는것을 오토박싱, 그 반대는 언박싱이라고함
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(10); //오토박싱 10 -> new Integer(10)
int value =list.get(0); //언박싱 new Integer(10) ->10
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);
}
}
.
.
.
if(pv.getValue()==null){
LOGGER.log(Level.INFO,"NULL");
}
else {
//int newPriority=Util.tryParseNumber(pv.getValue().toString(), FAULT_NUMBER).intValue();
int newPriority=Inter.parseInt(String.valueOf(Utill.tryParseNumber(String.valueOf(pv.getValue()),FAULT_NUMBER)));
intValue는 integer객체에서 int형 값을 뽑아내는 메소드
parseInt는 static으로 integer생성안하고 string형 객체에서 int형 값을 뽑아내는 메소드(null로 초기화가 불가능함)
inValue는 null값으로 처리가 가능해 SQL에 용이하게 쓰인다
null 또는, 데이터를 wrapper 할 경우에는 integer를 사용해야한다
toString()은 NPE 발생 가능 /String.valueOf()은 파라미터가 null이면 null인 문자열을 반환
'Study > java' 카테고리의 다른 글
| chapter 13 (0) | 2023.09.09 |
|---|---|
| chapter 12 (0) | 2023.08.31 |
| chapter 11 (0) | 2023.08.07 |
| chapter 8 (0) | 2023.08.05 |
| chapter 7 -2 (0) | 2023.07.29 |
