Notice
Recent Posts
Recent Comments
Link
일 | 월 | 화 | 수 | 목 | 금 | 토 |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 | 18 | 19 | 20 | 21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 |
29 | 30 | 31 |
Tags
- 주린이
- S&P500
- mco
- 현금흐름표
- 객체지향
- etf
- 백준
- 무디스
- javascript
- 그리디 알고리즘
- 기업분석
- 제태크
- 미국주식
- 오버라이딩
- Java
- XLF
- 프로그래머스
- 자바
- 배당성장
- 잉여현금흐름
- 금리인하
- 주식
- 금리인상
- 알고리즘
- object
- FCF
- 접근제어자
- 다형성
- StringBuffer
- 인플레이션
Archives
- Today
- Total
오늘의하루
[자바의 정석] Object, String, StringBuffer 클래스 정리 본문
Object Class
Object class는 모든 클래스의 최고 조상이며 오직 11개의 메서드만을 가지고 있다.
- equals(Object obj), hashCode(), toString()은 상황에 맞게 적절히 오버 라이딩해야 한다.
Object class에 있는 11개의 메서드에 대해 알아보기
- protected Object clone()
- 객체 자신의 복사본을 반환한다.
- public boolean equals(Object obj)
- 객체 자신과 객체 obj가 같은 객체인지 알려준다.
- protected void finalize()
- 객체가 소멸될 때 가비지 컬렉터에 의해 자동적으로 호출
- 이때 수행되어야 하는 코드가 있는 경우에만 오버 라이딩한다.
- public Class getClass()
- 객체 자신의 클래스 정보를 담고 있는 Class 인스턴스를 반환한다.
- public int hashCode()
- 객체 자신의 해시 코드를 반환한다.
- public String toString()
- 객체 자신의 정보를 문자열로 반환한다.
- public void notify()
- 객체 자신을 사용하려고 기다리는 스레드를 하나만 깨운다.
- public void notifyAll()
- 객체 자신을 사용하려고 기다리는 모든 쓰레드를 깨운다.
- public void wait()
- public void wait(long timeout)
- public void wait(long timeout, int nanos)
- 다른 스레드가 notify() 혹은 notifyAll()을 호출할 때까지 현재 스레드는 무한히 또는 지정된 시간(timeout, nanos) 동안 기다리게 한다.
public boolean equals(Object obj)
객체 자신과 주어진 객체(obj)를 비교하여 같으면 true를 반환한다.
- Object 클래스에서 정의된 equals()는 참조 변수 값( 객체의 주소 )을 비교한다.
- equals()를 오버 라이딩해서 인스턴스 변수의 값을 비교하도록 한다.
- equals()를 오버 라이딩하면 hashCode()도 같이 오버 라이딩해줘야 한다.
- equals()의 결과가 true이면 두 객체의 해시 코드 또한 같아야 하기 때문이다.
class Person{
long id;
public boolean equals(Object obj){
if(obj != null && obj instanceof Person){
return id == ((Person)obj).id;
}else{
return false;
}
}
Person(long id){
this.id = id;
}
}
Person p1 = new Person(80110811111222L);
Person p2 = new Person(80110811111222L);
System.out.println(p1 == p2); // false
System.out.println(p1.equals(p2)); // true
// 아직 hashCode()를 오버라이딩 해주지 않아서 해시코드가 다르게 나온다.
System.out.println(p1.hashCode()); // ex) 250075633
System.out.println(p2.hashCode()); // ex) 358699161
public int hashCode()
객체의 해시 코드를 반환하는 메서드이며 다량의 데이터를 저장 및 검색하는 해싱 기법으로 사용됩니다.
- Object 클래스의 hashCode()는 객체의 내부 주소를 반환한다.
public String toString()
객체의 정보를 문자열로 제공할 목적으로 정의된 메서드이다.
- 객체를 toString메서드를 사용해서 출력하면 "클래스명+@+주소 값을 int형으로 변환한 값"이 나온다.
- 오버 라이딩을 통해 원하는 형태로 바꿔줄 수 있다.
// toString 메서드 코드
public String toString(){
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
// 예제
class Card{
String kind;
int number;
Card(){this("SPADE", 1);}
Card(String kind, int number){
this.kind = kind;
this.number = number;
}
// toString 오버라이딩 x
}
class Card2 extends Card{
Card2(){
super("SPADE", 1);
}
Card2(String kind, int number){
super(kind, number);
}
public String toString(){ // toString 오버라이딩 O
return "kind = " + kind + ", number = " + number;
}
}
public class CardToString{
public static void main(String[] args){
Card c1 = new Card();
Card c2 = new Card();
System.out.println(c1.toString()); // ex) Card@e553
System.out.println(c2.toString()); // ex) Card@c10f
Card2 c3 = new Card2();
Card2 c4 = new Card2();
System.out.println(c3.toString()); // kind = SPADE, number = 1
System.out.println(c4.toString()); // kind = SPAED, number = 1
}
}
public Class getClass()
객체 자신의 클래스 정보(설계도 정보)를 담고 있는 Class 인스턴스를 반환한다.
- Class객체는 클래스의 모든 정보와 생성을 담고 있으며, 클래스당 단 1개만 존재한다.
- 소스파일을 컴파일하면 *. class 파일이 생성된다.
- *.class 파일을 실행하면 해당 파일명의 객체가 생성되고 이게 설계도가 된다.
Card.class >>> ClassLoader >>> Class객체
String Class
문자형 배열(char [])과 그에 관련된 메서드들이 정의되어 있다.
// String 클래스 기본 형태
public final class String implements java.io.Serializable, Comparable{
// ....
private char[] value;
// ....
}
- final 클래스이며 private 이기 때문에 String 인스턴스의 내용은 절대 변경할 수 없다.
String str = "ABC"와 String str = new String("ABC")의 비교
String str1 = "abc";
String str2 = "abc";
String str3 = new String("abc"); // 새로운 String 객체를 만든다.
String str4 = new String("abc"); // 새로운 String 객체를 만든다.
System.out.println(str1 == str2); // true
System.out.println(str3 == str4); // false
System.out.println(str1.equals(str2)); // true
System.out.println(str3.equals(str4)); // true
빈 문자열(empty string)
내용이 없는 문자열이며 크기가 0인 char형 배열을 저장하는 문자열을 말한다.
- 크기가 0인 배열을 생성하는 것은 어느 타입이나 가능하다.
char[] cArr = new char[0]; // 크기가 0인 char배열
int[] iArr = {}; // 크기가 0인 int배열
String은 빈 문자열("")이 가능하지만 char의 경우 빈문자('')가 불가능하다.
- String은 참조형의 기본값인 null보다는 빈 문자열("")로 초기화하는 게 좋다.
- char은 기본값인 '\u0000'보다는 공백(' ')으로 초기화하는게 좋다.
String s = ""; // 빈문자열로 초기화
char c = ' '; // 공백으로 초기화
String 클래스의 생성자와 메서드
- String(String s)
- 주어진 문자열(s)을 갖는 String인스턴스를 생성한다.
String s = new String("Hello");
// 결과 >> s = "Hello"
- String(char [] value)
- 주어진 문자열(value)을 갖는 String인스턴스를 생성한다.
char[] c = {'H','e','l','l','o'};
String s = new String(c);
// 결과 >> s = "Hello"
- String(StringBuffer buf)
- StringBuffer인스턴스가 갖고 있는 문자열과 같은 내용의 String인스턴스를 생성한다.
StringBuffer sb = new StringBuffer("Hello");
String s = new String(sb);
// 결과 >> s = "Hello"
- char charAt(int index)
- 지정된 위치(index)에 있는 문자를 알려준다.
- index는 0부터 시작한다.
String s = "Hello";
String n = "0123456";
char c1 = s.charAt(1);
char c2 = n.charAt(1);
// 결과 >> c1 = 'e', c2 = '1'
- String concat(String str)
- 문자열(str)을 뒤에 덧붙인다.
String s1 = "Hello";
String s2 = s1.concat(" world");
// 결과 >> s2 = "Hello world"
- boolean contains(CharSequence s)
- 지정된 문자열(s)이 포함되었는지 검사한다.
String s = "abcdefg";
boolean b = s.contains("bc");
// 결과 >> b = true
- boolean endWith(String suffix)
- 지정된 문자열(suffix)로 끝나는지 검사한다.
String file = "Hello.txt";
boolean b = file.endWith("txt");
// 결과 >> b = true
- boolean equals(Object obj)
- 매개변수로 받은 문자열(obj)과 String인스턴스의 문자열을 비교한다.
- obj가 String이 아니거나 문자열이 다르면 false를 반환한다.
String s = "Hello";
boolean b1 = s.equals("Hello");
boolean b2 = s.equals("hello");
// 결과 >> b1 = true, b2 = false
- boolean equalsIgnoreCase(String str)
- 문자열과 String인스턴스의 문자열을 대소문자 구분 없이 비교한다.
String s = "Hello";
boolean b1 = s.equalsIgnoreCase("HELLO");
boolean b2 = s.equalsIgnoreCase("HeLlo");
// 결과 >> b1 = true, b2 = true
- int indexOf(char ch)
- 주어진 문자(ch)가 문자열에 존재하는지 확인하여 위치(index)를 알려준다.
- 주어진 문자(ch)가 없는 경우 -1을 반환한다.
- int indexOf(String str)
- 주어진 문자열(str)이 존재하는지 확인하여 위치(index)를 알려준다.
- 문자열(str)의 첫 번째 문자가 있는 위치를 반환하는 것이다.
- 주어진 문자열(str)이 없는 경우 -1을 반환한다.
- 주어진 문자열(str)이 존재하는지 확인하여 위치(index)를 알려준다.
String s1 = "Hello";
int idx1 = s1.indexOf('o');
int idx2 = s1.indexOf('k');
// 결과 >> idx1 = 4, idx2 = -1
String s2 = "ABCDEFG";
int idx3 = s2.indexOf("CD");
// 결과 >> idx3 = 2
- String intern()
- 문자열을 constant pool에 등록한다.
- 이미 constant pool에 같은 내용의 문자열이 있을 경우 그 문자열의 주소 값을 반환한다.
Stirng s1 = new String("abc");
String s2 = new String("abc");
boolean b1 = (s1 == s2);
boolean b2 = s1.equals(s2);
boolean b3 = (s1.intern() == s2.intern());
// 결과 >> b1 = false, b2 = true, b3 = true
- int lastIndexOf(char ch)
- 지정된 문자 또는 문자코드를 문자열의 오른쪽 끝에서 부터 탐색한다.
- 문자 또는 문자코드가 있다면 그 위치를 반한 한다.
- 없는 경우 -1을 반환한다.
- int lastIndexOf(String str)
- 지정된 문자열을 인스턴스의 오른쪽 끝에서 부터 탐색한다.
- 있다면 문자열(str)이 시작하는 지점을 반환하고 없다면 -1을 반환한다.
String s1 = "java.lang.Object";
int idx1 = s1.lastIndexOf('.');
int idx2 = s1.indexOf('.');
// 결과 >> idx1 = 9, idx2 = 4
String s2 = "java.lang.java";
int idx3 = s2.lastIndexOf("java");
int idx4 = s2.indexOf("java");
// 결과 >> idx3 = 10, idx4 = 0
- int length()
- 문자열의 길이를 알려준다.
String s = "Hello";
int length = s.length();
// 결과 >> length = 5
- String replace(char old, char new)
- 문자열 중의 문자(old)를 새로운 문자(new)로 바꾼 문자열을 반환한다.
- String replace(CharSequence old, CharSequence new)
- 문자열 중의 문자열(old)을 새로운 문자열(new)로 바꾼 문자열을 반환한다.
- String replaceAll(String regex, String replacement)
- 문자열 중에서 지정된 문자열(regex)과 일치하는 것을 새로운 문자열(replacement)로 모두 변경한다.
- replace와 차이점은 replaceAll에서는 정규식을 사용할 수 있다는 것이다.
- String replaceFirst(String regex, String replacement)
- 문자열 중에서 지정된 문자열(regex)과 일치하는 것 중 첫 번째 것만 새로운 문자열(replacement)로 변경한다.
String s1 = "Hellollo";
String s2 = s1.replace('o','k');
// 결과 >> s2 = "Hellkllk"
String s3 = "Hellollo";
String s4 = s3.replace("ll","LL");
// 결과 >> s4 = "HeLLoLLo"
String s5 = "AABBAABB";
String s6 = s5.replaceAll("BB","bb");
// 결과 >> s6 = "AAbbAAbb"
String s7 = "abcabcdabcdee";
String s8 = s7.replaceAll("[abc]", "왕");
String s9 = s7.replace("a","왕").replace("b", "왕").replace("c", "왕");
// 결과 >> s8 = "왕왕왕왕왕왕d왕왕왕dee";
// 결과 >> s9 = "왕왕왕왕왕왕d왕왕왕dee";
String s7 = "AABBAABB";
String s8 = s7.replaceFirst("BB","bb");
// 결과 >> s8 = "AAbbAABB"
- String [] split (String regex)
- 문자열을 지정된 분리자(regex)로 나누어 문자열 배열에 담아 반환한다.
- String[] split (String regex, int limit)
- 문자열을 지정된 분리자(regex)로 나누어 문자열 배열에 담아 반환한다.
- 단, 문자열 전체를 지정된 수(limit)로 자른다.
String animals1 = "dog,cat,bear";
String[] arr1 = animals1.split(",");
// 결과 >> arr1[0] = "dog", arr1[1] = "cat", arr1[2] = "bear"
String animals2 = "dog,cat,bear";
String[] arr2 = animals2.split(",",2);
// 결과 >> arr2[0] = "dog", arr2[1] = "cat,bear"
- boolean startsWith (String prefix)
- 주어진 문자열(prefix)로 시작하는지 검사한다.
String s = "java.lang.Object";
boolean b1 = s.startsWith("java");
boolean b2 = s.startsWith("lang");
// 결과 >> b1 = true, b2 = false
- String substring (int begin)
- String substring (int begin, int end)
- 주어진 시작 위치(begin)부터 끝 위치(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 toUpperCase()
- String 인스턴스에 저장되어 있는 모든 문자열을 대문자로 변환하여 반환한다.
String s1 = "Hello";
String s2 = s1.toLowerCase();
String s3 = s1.toUpperCase();
// 결과 >> s2 = "hello", s3 = "HELLO"
- String toString()
- String 인스턴스에 저장되어 있는 문자열을 반환한다.
String s1 = "Hello";
String s2 = s1.toString();
// 결과 >> s2 = "Hello"
- String trim()
- 문자열의 왼쪽 끝과 오른쪽 끝에 있는 공백을 없앤 결과를 반환한다.
- 이때 문자열 중간에 있는 공백은 제거되지 않는다.
String s1 = " Hello World ";
String s2 = s1.trim();
// 결과 >> s2 = "Hello World"
- static String valueOf (boolean b)
- static String valueOf (char c)
- static String valueOf (int i)
- static String valueOf (long l)
- static String valueOf (float f)
- static String valueOf (double d)
- static String valueOf (Object o)
- 지정된 값을 문자열로 변환하여 반환한다.
- 참조 변수의 경우, toString()을 호출한 결과를 반환한다.
String b = String.valueOf(true);
String c = String.valueOf('a');
String i = String.valueOf(100);
String l = String.valueOf(100L);
String f = String.valueOf(10.0f);
String d = String.valueOf(10.0);
java.util.Date dd = new java.util.Date();
String date = String.valueOf(dd);
/*
결과
b = "true"
c = "a"
i = "100"
l = "100"
f = "10.0"
d = "10.0"
date = "Fri Oct 21 01:11:52 GMT 2022"
*/
문자열과 기본형 간의 변환
기본형 값을 문자열로 바꾸는 방법에는 2가지가 있다.
- 속도의 경우 2번 방법이 더 빠르다.
int i = 100;
String str1 = i + ""; // 결과 >> "100" 방법1
String str2 = String.valueOf(i); // 결과 >> "100" 방법2 (속도 빠름)
문자열을 기본형 값으로 변환하는 방법에는 2가지가 있다.
int i1 = Integer.parseInt("100"); // 결과 100 방법1
int i2 = Integer.valueOf("100"); // 결과 100 방법2 (JDK 1.5이후)
char c = "A".charAt(0); // 결과 'A'
// String을 char배열로 만들고 index 0을 반환하라는 코드이다.
문자열을 기본형으로 변환하는 방법 | |
boolean | Boolean.getBoolean(String s) |
byte | Byte.parseByte (String s) |
short | Short.parseShort (String s) |
int | Integer.parseInt (String s) |
long | Long.parseLong (String s) |
float | Float.parseFloat (String s) |
double | Double.parseDouble (String s) |
StringBuffer Class
String처럼 문자열 배열(char [])을 내부적으로 가지고 있다.
// 기본 코드
public final class StringBuffer implements java.io.Serializable{
// ....
private char[] value;
// ....
}
하지만 String 클래스와 달리 내용을 변경할 수 있습니다.
StringBuffer sb = new StringBuffer("abc");
sb.append("123");
인스턴스를 생성할 때 버퍼(배열)의 크기를 충분히 지정해주는 것이 좋다.
- 버퍼가 작으면 성능이 저하되기 때문에 작업 중에 더 큰 배열의 생성이 필요하다.
String 클래스와 달리 equals()를 오버 라이딩하지 않는다.
StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb1 == sb2); // false
System.out.println(sb1.equals(sb2)); // false
String s1 = sb1.toString();
String s2 = sb2.toString();
System.out.println(s1.equals(s2)); // true
StringBuffer 클래스의 생성자와 메서드
- StringBuffer()
- 16 문자를 담을 수 있는 버퍼를 가진 StringBuffer 인스턴스를 생성한다.
StringBuffer sb = new StringBuffer();
// 결과 >> sb = ""
- StringBuffer(int length)
- 지정된 개수의 문자를 담을 수 있는 버퍼를 가진 StringBuffer 인스턴스를 생성한다.
StringBuffer sb = new StringBuffer(10);
// 결과 >> sb = ""
- StringBuffer(String str)
- 지정된 문자열(str)을 갖는 StringBuffer 인스턴스를 생성한다.
StringBuffer sb = new StringBuffer("Hi");
// 결과 >> sb = "Hi"
- StringBuffer append (boolean b)
- StringBuffer append (char c)
- StringBuffer append (char [] str)
- StringBuffer append (double d)
- StringBuffer append (float f)
- StringBuffer append (int i)
- StringBuffer append (long l)
- StringBuffer append (Object obj)
- StringBuffer append (String str)
- 매개변수로 입력된 값을 문자열로 변환하여 StringBuffer 인스턴스가 저장하고 있는 문자열의 뒤에 덧붙인다.
StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = sb1.append(true);
sb1.append('d').append(10.0f);
StringBuffer sb3 = sb1.append("ABC").append(123);
/*
결과
sb1 = "abctrued10.0ABC123"
sb2 = "abctrued10.0ABC123"
sb3 = "abctrued10.0ABC123"
*/
- int capacity()
- StringBuffer인스턴스의 버퍼 크기를 알려준다.
- length()는 버퍼에 담긴 문자열의 크기를 알려준다.
StringBuffer sb = new StringBuffer(100);
sb.append("abcd");
int bufferSize = sb.capacity();
int StringSize = sb.length();
// 결과 >> bufferSize = 100, StringSize = 4
// sb에 담긴 문자열이 "abcd"이기 때문이다.
- char charAt(int index)
- 지정된 위치(index)에 있는 문자를 반환한다.
StringBuffer sb = new StringBuffer("abcd");
char c = sb.charAt(2);
// 결과 >> c = 'c'
- StringBuffer delete (int start, int end)
- 시작 위치(start)부터 끝 위치(end) 사이에 있는 문자를 제거한다.
- 단, 끝 위치의 문자는 제외한다.
StringBuffer sb1 = new StringBuffer("0123456");
StringBuffer sb2 = sb1.delete(3,6);
// 결과 >> sb1 = "0126", sb2 = "0126"
- StringBuffer deleteCharAt(int index)
- 지정된 위치(index)의 문자를 제거한다.
StringBuffer sb = new StringBuffer("0123456");
sb.deleteCharAt(3);
// 결과 >> sb = "012456"
- StringBuffer insert (int pos, boolean b)
- StringBuffer insert (int pos, char [] str)
- StringBuffer insert (int pos, float f)
- StringBuffer insert (int pos, double d)
- StringBuffer insert (int pos, Object obj)
- StringBuffer insert (int pos, char c)
- StringBuffer insert (int pos, int i)
- StringBuffer insert (int pos, long l)
- StringBuffer insert (int pos, String str)
- 두 번째 매개변수로 받은 값을 문자열로 반환하여 지정된 위치(pos)에 추가한다.
- 인덱스는 0부터 시작한다.
StringBuffer sb = new StringBuffer("0123456");
sb.insert(4, '.');
// 결과 >> sb = "0123.456"
- int length()
- StringBuffer인스턴스에 저장되어 있는 문자열의 길이를 반환한다.
StringBuffer sb = new StringBuffer("0123456");
int length = sb.length();
// 결과 >> legnth = 7
- StringBuffer replace(int start, int end, String str)
- 지정된 범위(start ~ end)의 문자들을 주어진 문자열(str)로 바꾼다.
- end위치의 문자는 포함되지 않는다.
StringBuffer sb = new StringBuffer("0123456");
sb.replace(3,6,"AB");
// 결과 >> sb = "012AB6"
- StringBuffer reverse()
- StringBuffer인스턴스에 저장되어 있는 문자열의 순서를 거꾸로 나열한다.
StringBuffer sb = new StringBuffer("0123465");
sb.reverse()
// 결과 >> sb = "6543210"
- void setLength(int newLength)
- 지정된 크기(newLength)로 문자열의 길이를 변경한다.
- 크기를 늘리는 경우에 나머지 빈 공간은 널문자('\u0000')로 채운다.
StringBuffer sb1 = new StringBuffer("0123456");
sb1.setLength(5);
StringBuffer sb2 = new StringBuffer("0123456");
sb2.setLength(10);
String str = sb2.trim();
/*
결과
sb1 = "012345"
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으로 뽑아서 반환한다.
- 시작 위치(start)만 지정하면 시작 위치부터 문자열 끝까지 뽑아서 반환한다.
StringBuffer sb = new StringBuffer("0123456");
String str1 = sb.substring(3);
String str2 = sb.substring(3,5);
// 결과 >> str1 = "3456", str2 = "34"
Math & wrapper Class
- staitc int abs(int f)
- static float abs(float f)
- static double abs(double d)
- static long abs(long l)
- 주어진 값의 절댓값을 반환한다.
int i = Math.abs(-10);
double d = Math.abs(-10.0);
// 결과 >> i = 10, d = 10.0
- static double ceil(double d)
- 주어진 값을 무조건 올림 하여 반환한다.
double d1 = Math.ceil(10.1);
double d2 = Math.ceil(-10.1);
double d3 = Math.ceil(10.0000015);
// 결과 >> d1 = 11.0, d2 = -10.0, d3 = 11.0
- static double floor(double d)
- 주어진 값을 무조건 버림 하여 반환한다.
double d1 = Math.floor(10.8);
double d2 = Math.floor(-10.8);
// 결과 >> d1 = 10.0, d2 = -11.0
- static int max(int a, int b)
- static long max(long a, long b)
- static float max(float a, float b)
- static double max(double a, double b)
- 주어진 두 값을 비교해서 큰 쪽을 반환한다.
double d = Math.max(9.5, 9.50001);
int i = Math.max(0, -1);
// 결과 >> d = 9.50001, i = 0
- static int min(int a, int b)
- static long min(long a, long b)
- static float min(float a, float b)
- staitc double min(double a, double b)
- 주어진 두 값을 비교하여 작은 쪽을 반환한다.
double d = Math.min(9.5, 9.500001);
int i = Math.min(0, -1);
// 결과 >> d = 9.5, i = -1
- static double random()
- 0.0 ~ 1.0 범위의 임의의 double 값을 반환한다.
- 0.0은 포함되지만 1.0은 포함되지 않는다.
double d = Math.random();
int i = (int)(Math.random() * 10) + 1;
/*
결과
d = 0.0 <= x < 1.0의 실수
i = 1 <= x < 11의 정수
*/
- static double rint(double d)
- 주어진 double값과 가장 가까운 정수 값을 double형으로 반환한다.
double d1 = Math.rint(5.55);
double d2 = Math.rint(5.11);
double d3 = Math.rint(-5.55);
double d4 = Math.rint(-5.11);
// 결과 >> d1 = 6.0, d2 = 5.0, d3 = -6.0, d4 = -5.0
- static long round(double d)
- static long round(float f)
- 소수점 첫째 자리에서 반올림한 정수 값(long)을 반환한다.
long l1 = Math.round(5.55);
long l2 = Math.round(5.11);
long l3 = Math.round(-5.55);
long l4 = Math.round(-5.11);
double d1 = 90.7552;
double d2 = Math.round(d1*100)/100.0;
// 결과 >> l1 = 6, l2 = 5, l3 = -6, l4 = -5, d2 = 90.76
wrapper class
기본형을 클래스로 정의한 것으로 기본형 값도 객체로 다뤄져야 할 때 가 있다.
기본형 | wrapper class | 생성자 | 활용 예제 |
boolean | Boolean | Boolean (boolean vlaue) Boolean (String s) |
Boolean b1 = new Boolean(true); Boolean b2 = new Boolean("true"); |
char | Character | Character (char value) | Character c = new Character('a'); |
byte | Byte | Byte (byte value) Byte (String s) |
Byte b1 = new Byte(10); Byte b2 = new Byte("10"); |
short | Short | Short (short value) Short (String s) |
Short s1 = new Short(10); Short s2 = new Short("10"); |
int | Integer | Integer (int value) Integer (String s) |
Integer i1 = new Integer(10); Integer i2 = new Integer("10"); |
long | Long | Long (long value) Long (String s) |
Long l1 = new Long(100); Long l2 = new Long("100"); |
float | Float | Float (double value) Float (float value) Float (String s) |
Float f1 = new Float(1.0); Float f2 = new Float(1.0f); Float f3 = new Float("1.0f"); |
double | Double | Double (double value) Double (String s) |
Double d1 = new Double(10.0); Double d2 = new Double("10.0"); |
wrapper class는 값을 비교하도록 내부적으로 equlas()가 오버 라이딩되어있다.
- 내부적으로 equals()를 값을 비교하도록 오버 라이딩한 것은 String 클래스가 있다.
Integer i1 = new Integer(100);
Integer i2 = new Integer("100");
System.out.println(i1 == i2); // false
System.out.println(i1.equals(i2)) // true
'JAVA' 카테고리의 다른 글
[Java] 성적 조회 프로그램 만들기 (0) | 2022.11.03 |
---|---|
[자바의 정석] 날짜와 시간, 형식화 정리 (0) | 2022.10.25 |
[자바의 정석] 예외처리 (0) | 2022.10.19 |
[자바의 정석] 추상클래스 인터페이스 내부클래스 정리 (0) | 2022.10.19 |
[자바의 정석] 제어자 & 다형성 (0) | 2022.10.18 |
Comments