API(Application Programming Interface)

💁‍♀️ API(Application Programming Interface)이란,
응용 프로그램에서 사용할 수 있도록 운영체제나 프로그래밍 언어가 제공하는 기능을 제어할 수 있게 만든 인터페이스

---

👀 Object

◼ Book Class

public class Book {
	
	private int number;
	private String title;
	private String author;
	private int price;
	
	public Book() {}

	public Book(int number, String title, String author, int price) {
		super();
		this.number = number;
		this.title = title;
		this.author = author;
		this.price = price;
	}

	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getAuthor() {
		return author;
	}
	public void setAuthor(String author) {
		this.author = author;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}

	@Override >>> Object의 메소드를 오버라이딩
	public String toString() {
		return "Book [number=" + number + ", title=" + title + ", author=" + author + ", price=" + price + "]";
	}

	@Override
	public int hashCode() {
		return Objects.hash(author, number, price, title);
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Book other = (Book) obj;
		return Objects.equals(author, other.author) && number == other.number && price == other.price
				&& Objects.equals(title, other.title);
	}
}

◼ Application1 Class

public class Application1 {

	public static void main(String[] args) {
		
		Book book1 = new Book(1, "홍길동전", "허균", 50000);
		Book book2 = new Book(2, "목민심서", "정약용", 30000);
		Book book3 = new Book(3, "칭찬은 고래를 춤추게 한다", "고래", 40000);
		
		>>> java.lang.Object 클래스의 toString 메소드는
		>>> 인스턴스가 생성될 때 사용한 full class name과 @ 그리고 16진수 해쉬코드가 '문자열'로 반환됨
		>>> 16진수 해쉬코드는 인스턴스의 주소를 가리키는 값으로 인스턴스마다 모두 다름
        
		System.out.println("book1.toString() : " + book1.toString());
		System.out.println("book2.toString() : " + book2.toString());
		System.out.println("book3.toString() : " + book3.toString());
		
		>>> 레퍼런스 변수만 출력하는 경우도 toString() 호출과 '동일한 결과' 출력 
		>>> 이 말은 자동으로 toString() 메소드를 호출한다는 뜻
		>>> 이러한 점을 이용해서 toString() 메소드를 재정의해서 사용함
        
		System.out.println("book1 : " + book1);
		System.out.println("book2 : " + book2);
		System.out.println("book3 : " + book3);
	}
}

◼ Application2 Class

🙋‍ 잠깐 ! 동일 객체와 동등 객체가 뭔가요?

• 동일 객체 : 주소가 동일한 인스턴스
• 동등 객체 : 주소는 다르더라도 필드 값이 동일한 객체

public class Application2 {

	public static void main(String[] args) {
		
		>>> java.lang.Object의 equals는 매개변수로 전달받은 인스턴스와 == 연산하여 true or false를 반환
		>>> 즉, 동일한 인스턴스인지 비교하는 기능
		
		>>> 경우에 따라서는 동등 객체를 판단해야하는 상황이 있는데,
		>>> 그때 equals를 오버라이딩하여 각각의 필드가 동일한 값을 가지는지 확인하고 
        >>> 모든 필드 값이 같은 값을 가지는 경우 true, 아닌 경우 false를 반환
        
		// 필드 값이 동일한 객체 생성
		Book book1 = new Book(1, "홍길동전", "허균", 50000);
		Book book2 = new Book(1, "홍길동전", "허균", 50000);
		
		System.out.println("두 인스턴스의 == 연산 비교 : " + (book1 == book2));
        							>>> 주소값을 비교하는 것이기 때문에 당연히 False
		System.out.println("두 인스턴스의 eqauls() 비교 : " + (book1.equals(book2)));
        							>>> Book클래스에 equals메소드를 오버라이딩 하지 않았다면, false 출력
                                    >>> Book클래스에 equals메소드를 오버라이딩 후, true 출력 (동등 객체 확인)
    }
}

◼ Application3 Class

📌 Ref.

* Object 클래스의 명세에 작성된 일반 규약에 따르면 'equals 메소드를 재정의하는 경우', 
  반드시 'hashCode 메소드도 재정의(오버라이딩)' 해야함.
  만약 hashCode를 재정의하지않으면 같은 값을 가지는 동등 객체는 같은 해쉬코드 값을 가져야 한다는 
  규약에 위반 (강제성까지는 없으나 규약대로 작성하는 것이 좋음)

public class Application3 {

	public static void main(String[] args) {
		
		>>> equals와 hashCode는 페어로 보고 동등객체 판단을 위해 오버라이딩 (필드 값 동일)

		Book book1 = new Book(1, "홍길동전", "허균", 50000);
		Book book2 = new Book(1, "홍길동전", "허균", 50000);
		
		System.out.println("book1의 hashcode : " + book1.hashCode());
		System.out.println("book2의 hashcode : " + book2.hashCode()); >> 서로 다른 주소값
       
        >>> 필드값은 동일하지만 주소값은 다른 '동등 객체'
        >>> Book클래스에 hashCode메소드도 오버라이딩 하면 '주소값 또한 통일'됨
	}
}

---

🙋‍ 잠깐 ! String과 StringBuilder의 차이점부터 알아봅시다!

• String 👉 불변
  : 문자열에 + 연산으로 합치기 하는 경우, 기존 인스턴스를 수정하지않고 새로운 인스턴스를 반환
  • 문자열 변경이 자주 일어나는 경우 성능 면에서 좋지 않음
  • 변하지 않는 문자열을 자주 읽어 들이는 경우 좋은 성능을 기대할 수 있음
• StringBuilder 👉 가변
  : 문자열에 append() 메소드를 이용하여 합치기 하는 경우 기존 인스턴스를 수정하고 새로운 인스턴스를 생성하지 않음
  • 잦은 문자열 변경이 일어나는 경우 String 보다 성능이 좋음

---

👀 String (불변)

👉 String 클래스의 자주 사용되는 메소드

1) charAt()

charAt() : 해당 문자열의 특정 인덱스에 해당하는 문자를 반환
인덱스는 0부터 시작하는 숫자 체계를 의미하며, 인덱스를 벗어난 정수를 인자로 전달하는 경우에는 IndexOutOfBoundsException이 발생

String str1 = "apple";
		
for(int i = 0; i < str1.length(); i++) {
	System.out.println("charAt(" + i + ") : " + str1.charAt(i));
}

2) compareTo()

compareTo() : 인자로 전달된 문자열과 사전 순으로 비교를 하여 두 문자열이 같다면 0을 반환, 인자로 전달된 문자열보다 작으면 음수를, 크면 양수를 반환
(단, 이 메소드는 대소문자를 구분하여 비교)

String str2 = "java";
String str3 = "java";
String str4 = "JAVA";
String str5 = "oracle";
		
>>> 같으면 0을 반환
System.out.println("compareTo() : " + (str2.compareTo(str3)));
		
>>> 대문자와 소문자는 32만큼 차이가 남
System.out.println("compareTo() : " + (str2.compareTo(str4)));
System.out.println("compareTo() : " + (str4.compareTo(str2)));
		
>>> jklmno j부터 o까지 5만큼 차이가 남
System.out.println("compareTo() : " + (str2.compareTo(str5))); // -5 출력
System.out.println("compareTo() : " + (str5.compareTo(str2))); // 5 출력
		
>>> 구체적으로 어떤 값이 나오는지보다 양수인지 음수인지를 판단할 목적으로 주로 사용

>>> 대소문자를 구분하지 않고 비교 (compareToIgnoreCase())
System.out.println("compareToIgnoreCase() : " + str3.compareToIgnoreCase(str4));

3) concat()

concat() : 문자열에 인자로 전달 된 문자열을 합치기해서 새로운 문자열을 반환 (원본 문자열에 영향 X)

System.out.println("concat() : " + (str2.concat(str5)));	// javaoracle
System.out.println("str2 : " + str2);						// java

4) indexOf()

indexOf() : 문자열에서 특정 문자를 탐색하여 처음 일치하는 인덱스 위치를 정수형으로 반환 (단, 일치하는 문자가 없는 경우 -1을 반환)

String indexOf = "java oracle";
System.out.println("indexOf('a') : " + indexOf.indexOf('a')); // 1
System.out.println("indexOf('z') : " + indexOf.indexOf('z')); // -1

5) lastIndexOf()

lastIndexOf() : 문자열 탐색을 뒤에서부터 하고 처음 일치하는 위치의 인덱스를 반환 (단, 일치하는 문자가 없는 경우 -1을 반환)

System.out.println("lastIndexOf('a') : " + indexOf.lastIndexOf('a')); // 7
System.out.println("lastIndexOf('z') : " + indexOf.lastIndexOf('z')); // -1

6) trim()

trim() : 문자열 앞 뒤에 공백을 제거한 문자열을 반환 (원본 문자열에 영향 X)

String trimStr = "   java   ";
		
System.out.println("trimStr : #" + trimStr + "#");			// #   java   #
System.out.println("trim() : #" + trimStr.trim() + "#"); 	// #java#
System.out.println("trimStr : #" + trimStr + "#");			// #   java   #

7) toLowerCase() & toUpperCase()

toLowerCase() : 모든 문자를 소문자로 변환
toUpperCase() : 모든 문자를 대문자로 변환
(원본 문자열에 영향 X)

String caseStr = "JavaOracle";
System.out.println("toLowerCase() : " + caseStr.toLowerCase()); // javaoracle
System.out.println("toUpperCase() : " + caseStr.toUpperCase()); // JAVAORACLE
System.out.println("caseStr : " + caseStr);						// JavaOracle

8) substring()

substring() : 문자열의 일부를 잘라내어 새로운 문자열을 반환 (원본 문자열에 영향 X)

String javaoracle = "javaoracle";
		
System.out.println("substring(3, 6) : " + javaoracle.substring(3, 6));	// aor >>> 3,4,5 번째 문자열만 반환
System.out.println("substring(3) : " + javaoracle.substring(3));		// aoracle
System.out.println("javaoracle : " + javaoracle);						// javaoracle

9) replace()

replace() : 문자열에서 대체할 문자열로 기존 문자열을 변경해서 반환 (원본 문자열에 영향 X)

System.out.println("replace() : " + javaoracle.replace("java", "python"));	// pythonoracle
System.out.println("javaoracle : " + javaoracle);							// javaoracle

10) length()

length() : 문자열의 길이를 정수형으로 반환

System.out.println("length() : " + javaoracle.length());	// 10
System.out.println("빈 문자열 길이 : " + ("".length()));		// 0

11) isEmpty()

isEmpty() : 문자열의 길이가 0이면 true를 반환, 아니면 false를 반환 (길이가 0인 문자열은 null과는 다름)

System.out.println("isEmpty() : " + "".isEmpty());		// true
System.out.println("isEmpty() : " + "abc".isEmpty());	// false
		
String str = "";
		
System.out.println(str == null);	// false
System.out.println(str.isEmpty());	// true
>>> 빈 문자열은 null이 아님

👉 문자열 객체 사용 방법

[1] "" 리터럴 형태 & new String("문자열")

"" 리터럴 형태 : 동일한 값을 가지는 인스턴스를 단일 인스턴스로 관리
new String("문자열") : 매번 새로운 인스턴스를 생성

String str1 = "java";
String str2 = "java";
String str3 = new String("java");
String str4 = new String("java");
		
System.out.println(str1 == str2); // true
System.out.println(str2 == str3); // false
System.out.println(str3 == str4); // false
		
>>> 1, 2의 주소값은 같고 3, 4의 주소값은 다르지만 모두 동일한 hashCode 값 출력
>>> 동일한 문자열은 동일한 hashCode 값을 반환하도록 String 클래스에 재정의 되어있기 때문
System.out.println("str1 hashCode : " + str1.hashCode());
System.out.println("str2 hashCode : " + str2.hashCode());
System.out.println("str3 hashCode : " + str3.hashCode());
System.out.println("str4 hashCode : " + str4.hashCode());
>>> string 클래스에도 필드값이 같으면 같은 주소값이 반환되도록 hashCode 메소드가 
>>> 오버라이딩 되어있기 때문에 모두 같은 주소값 출력

[2] 문자열은 "불변"

>>> 문자열은 "불변"이라는 특징을 가지고 있어
>>> 기존 문자열에 + 연산자를 수행하는 경우 문자열을 수정하는 것이 아니라 '새로운 문자열을 할당'

str2 += "oracle";

>>> str1, str2는 동일 인스턴스였지만 수정 후에는 다른 인스턴스가 된 것을 확인
System.out.println("str1 == str2 : " + (str1 == str2)); // false 
														>>> str2의 주소값이 달라짐

[3] 각각 주소값이 다른 문자열을 equals로 비교

>>> str1, str3, str4 각각 주소값 다 다름. 
>>> 하지만, 인스턴스의 비교가 아니라 문자열 값을 비교하여 동일한 값을 가지면 true, 
>>> 다른 값을 가지면 false를 반환하도록 오버라이딩 되어있기 때문에 모두 true 출력

		System.out.println("str1.equals(str3) : " + str1.equals(str3)); // true
		System.out.println("str3.equals(str4) : " + str3.equals(str4)); // true
	}
}

👉 split()과 StringTokenizer

[1] split()의 활용

// 각 문자열의 의미는 사번/이름/주소/부서 를 의미
String emp1 = "100/홍길동/서울/영업부";		// 모든 값 존재
String emp2 = "200/유관순//총무부";			// 주소 없음
String emp3 = "300/이순신/경기도/";			// 부서 없음
		
// split()을 이용해서 3명의 문자열을 정보별로 분리
String[] empArr1 = emp1.split("/"); 
String[] empArr2 = emp2.split("/");
String[] empArr3 = emp3.split("/");

for(int i = 0; i < empArr1.length; i++) {
	System.out.println("empArr1[" + i + "] : " + empArr1[i]);	// 정상 출력
}
		
for(int i = 0; i < empArr2.length; i++) {
	System.out.println("empArr2[" + i + "] : " + empArr2[i]);	// empArr2[2] : 공백
}
		
for(int i = 0; i < empArr3.length; i++) {
	System.out.println("empArr3[" + i + "] : " + empArr3[i]);	// empArr3[3] 자체가 출력 X
}

[2] 마지막 구분자 사이에 값이 존재하지 않는 경우, 이후 값도 추출하고 싶을 때

>>> 마지막 구분자 사이에 값이 존재하지 않는 경우, 이후 값도 추출하고 싶을 때
>>> 몇 개의 토큰으로 분리할 것인지 한계치를 두번째 인자로 넣어줄 수 있음
>>> 이 때, 음수를 넣게 되면 마지막 구분자 뒤의 값이 존재하지 않는 경우 빈 문자열로 토큰을 생성

String[] empArr4 = emp3.split("/", -1); 
		
for(int i = 0; i < empArr4.length; i++) {
	System.out.println("empArr4[" + i + "] : " + empArr4[i]);		
}											// 위와 달리 empArr4[3] : 가 공백으로 출력이 됨

[3] 반면 StringTokenizer의 경우 공백으로 존재하는 값을 무시

StringTokenizer st1 = new StringTokenizer(emp1, "/");
StringTokenizer st2 = new StringTokenizer(emp2, "/");
StringTokenizer st3 = new StringTokenizer(emp3, "/");
		
while(st1.hasMoreTokens()) {	>>> : 얘 토큰을 더 가지고 있니? true일 경우 while문 진행
	System.out.println("st1 : " + st1.nextToken());
}
		
while(st2.hasMoreTokens()) {
	System.out.println("st2 : " + st2.nextToken());
}
		
while(st3.hasMoreTokens()) {
	System.out.println("st3 : " + st3.nextToken());
}
		
>>> nextToken()으로 토큰을 꺼내면 해당 StringTokenizer의 토큰을 재사용하는 것이 불가능
while(st1.hasMoreTokens()) {
	System.out.println("st1 : " + st1.nextToken());
}

[4] split은 정규표현식 이용(문자열 패턴), StringTokenizer는 구분자 문자열 이용

String colorStr = "red*orange#blue/yellow green"; >>> *, #, , /로 단어 구분
		
>>> "*#/ " 이라는 문자열이 구분자로 존재하지 않아서 에러 발생
//String[] colors = colorStr.split("*#/ ");
		
>>> 대괄호로 묶은 문자열은 문자열이 아닌 각 문자들의 패턴으로 볼 수 있음
>>> 따라서 '순서 상관 없이' 존재하는 문자들을 이용해서 구분자로 사용 가능
String[] colors = colorStr.split("[/*# ]");		>>> 대괄호로 묶어야함
		
for(int i = 0; i < colors.length; i++) {
	System.out.println("colors[" + i + "] : " + colors[i]);	
}
		
>>> StringTokenizer의 두번째 인자 문자열 자체는 연속 된 문자열이 아닌 하나하나를 구분자로 이용하겠다는 의미
StringTokenizer colorStringTokenizer = new StringTokenizer(colorStr, "*#/ ");
		
while(colorStringTokenizer.hasMoreTokens()) {
	System.out.println(colorStringTokenizer.nextToken());
}

👉 이스케이프 문자

[1] 개행 문자

\n

System.out.println("안녕하세요.\n저는 효연입니다.");

[2] 탭 문자

\t

System.out.println("안녕\t하세요. 저는 수민입니다.");

[3] 홑따옴표 문자

' ' \'

System.out.println("안녕하세요 저는 '효연'입니다.");

//System.out.println(''');	>>> 홑따옴표 문자와 문자 리터럴 기호가 중복되어 출력 X
System.out.println('\'');	>>> ' 정상 출력. 이스케이프 문자를 사용해서 구분해줌

[4] 쌍따옴표 문자

\"

//System.out.println("안녕하세요 저는 "치즈"입니다.");
System.out.println("안녕하세요 저는 \"치즈\"입니다.");

[5] 역슬래시 문자

\\

//System.out.println("안녕하세요 저는 \수민\입니다."); 
					>>> 역슬래시를 문자열에 표현하고싶지만 이스케이프 문자와 겹침
System.out.println("안녕하세요 저는 \\수민\\입니다."); 

---

👀 StringBuilder (가변)

👉 StringBuilder의 특징

StringBuilder sb = new StringBuilder("java");

[1] toString이 이미 오버라이딩 되어있어 가지고 있는 문자열을 출력

System.out.println("sb : " + sb); 	>>> 주소값이 아닌 문자열 반환
									>>> StringBuilder도 toString이 오버라이딩 되어있음

[2] hashCode는 오버라이딩 되어있지 않음

즉, 동일한 값을 가지는 경우 같은 해쉬코드를 반환하지않고, 인스턴스가 동일해야 같은 해쉬코드를 반환 (String과의 차이점)

System.out.println("sb의 hashCode : " + sb.hashCode());

[3] 문자열이 수정됨 (가변)

// oracle 문자열 추가
sb.append("oracle"); 
		
System.out.println("sb : " + sb); // javaoracle

>>>  문자열을 수정해도 기존의 인스턴스와 동일한 주소 값을 가짐
>>> 즉, 문자열을 추가해도 새로운 인스턴스가 생성된 것 X, 인스턴스의 값 자체가 변경됨
 
 System.out.println("sb의 hashCode : " + sb.hashCode());
>>> oracle 문자열이 추가되면서 다른 문자열이 되었지만 '같은 주소값 출력'

👉 StringBuilder의 자주 사용되는 메소드

🙋‍ 잠깐 ! 왜 StringBuilder를 사용하나요?

• String은 불변이므로 값을 계속 추가하거나 변경시킬경우, 비효율적으로 객체 생성을 많이 하게 됨
  하지만 StringBuilder는 값이 변경되면 heap에 있는 객체의 값 자체가 변경되기 때문에 보다 효율적
  따라서, 값이 많이 변경되는 문자열을 다룰 경우 StringBuilder를 사용

---

// StringBuilder 기본 생성자로 인스턴스 생성
StringBuilder sb1 = new StringBuilder();

1) capacity()

capacity() : 용량(현재 버퍼 크기)을 정수형으로 반환하는 메소드 (문자열 길이 + 16이 기본 용량)

System.out.println(sb1.capacity());	// 16

2) append()

append() : 인자로 전달된 값을 문자열로 변환 후 기존 문자열의 마지막에 추가. 기본 용량을 초과하는 경우 (기존 문자열 + 1) * 2를 하여 용량을 확장시킴

for(int i = 0; i < 50; i++) {
	sb1.append(i);
			
	System.out.println("sb1 : " + sb1);
    
	System.out.println("capacity : " + sb1.capacity());
    >>>16 -> 34 -> 70 -> 142 순서로 수용량을 늘려감 (2n + 2씩 증가)
    
	System.out.println("hashCode : " + sb1.hashCode());
    >>> hashCode는 변화 X. 객체가 변경되는 것이고 새로 생기는 것이 아님 (동일 인스턴스)
}

💻 Mini Console

sb1 : 0
capacity : 16
hashCode : 1365202186 // 1회차
sb1 : 01
capacity : 16
hashCode : 1365202186 // 2회차
sb1 : 012
capacity : 16
hashCode : 1365202186 // 3회차
sb1 : 0123
capacity : 16
hashCode : 1365202186 ......
// 49회까지 계속 출력

3) delete()

delete() : 시작 인덱스와 종료 인덱스를 이용해서 문자열에서 원하는 부분의 문자열 제거
deleteCharAt() : 문자열의 인덱스를 이용해서 문자 하나 제거
(원본 문자열에 영향 O)

// 새로운 StringBuilder 인스턴스 생성
StringBuilder sb2 = new StringBuilder("javaoracle");

System.out.println("delete() : " + sb2.delete(2, 5)); // jaracle
					>>> 2번부터 5번까지 제거(2,3,4 제거) = ja(vao)racle
System.out.println("deleteCharAt() : " + sb2.deleteCharAt(0)); // aracle
		
System.out.println("sb2 : " + sb2); // aracle
									>>> 원본 변경됨

4) insert()

insert() : 인자로 전달된 값을 문자열로 변환 후 지정한 인덱스 위치에 추가 (원본 문자열에 영향 O)

System.out.println("insert() : " + sb2.insert(1, "vao"));	// avaoracle
System.out.println("insert() : " + sb2.insert(0, "j")); 	// javaoracle
		
System.out.println("sb2 : " + sb2); // javaoracle 
									>>> insert를 이용하여 원본으로 복구

5) reverse()

reverse() : 문자열 인덱스 순번을 역순으로 재배열 (원본 문자열에 영향 O)

System.out.println("reverse() : " + sb2.reverse());	// elcaroavaj
System.out.println("sb2 : " + sb2); 				// elcaroavaj

---

👀 Wrapper 클래스

💁‍♀️ Wrapper 클래스란,
상황에 따라 기본 타입의 데이터를 인스턴스화 해야하는 경우들이 발생할 때, 기본 타입 데이터를 먼저 인스턴스로 변환한 후 사용해야함. 이때, 8가지에 해당하는 기본 타입의 데이터를 인스턴스화 할 수 있도록 하는 클래스

---

💁‍♀️ Boxing & UnBoxing이란,

• Boxing : 본 타입을 래퍼 클래스의 인스턴스로 인스턴스화 하는 것
• UnBoxing : 래퍼 클래스 타입의 인스턴스를 기본 타입으로 변경하는 것

---

👉 Wrapper 클래스의 활용

[1] Boxing & UnBoxing

int intValue = 20;

Integer boxingNumber1 = new Integer(intValue);		>>> 인스턴스화(Boxing) => 생성자 이용
Integer boxingNumber2 = Integer.valueOf(intValue);	>>> 인스턴스화(Boxing) => static 메소드 이용
		
int nuBoxingNumber1 = boxingNumber1.intValue();     >>> 언박싱(UnBoxing) => intValue 메소드 이용

[2] Auto Boxing & Auto UnBoxing

💁‍♀️ Boxing과 UnBoxing이 필요한 상황에서 자바 컴파일러가 자동으로 처리

Integer boxingNumber3 = intValue;
int unBoxingNumber2 = boxingNumber3;

[3] Wrapper 클래스 값 비교

int inum = 20;
Integer integerNum1 = new Integer(20);	>>> 생성자로 인스턴스 생성
Integer integerNum2 = new Integer(20);
Integer integerNum3 = 20; 				>>> 오토 박싱되어 인스턴스 생성
Integer integerNum4 = 20;

[4] 기본 타입과 레퍼런스 클래스 타입은 == 연산으로 비교 가능

System.out.println("int와 Integer 비교 : " + (inum == integerNum1)); >>> 값 비교가 되어 true 출력
System.out.println("int와 Integer 비교 : " + (inum == integerNum3)); >>> 값 비교가 되어 true 출력

[5] 생성자를 이용해 생성한 값과 오토 박싱으로 생성한 값을 == 연산자로 비교 (주소 값 비교)

• 생성자를 이용해 생성한 값의 경우 ==로 비교 X
• 오토 박싱으로 생성한 값은 ==로 비교 O

System.out.println("Integer와 Integer 비교 : " + (integerNum1 == integerNum2)); // false
										>>> 참조하고 있는 객체가 다르므로 주소값을 비교했을 때, false
System.out.println("Integer와 Integer 비교 : " + (integerNum1 == integerNum3)); // false
										>>> 위와 동일한 이유로, false
System.out.println("Integer와 Integer 비교 : " + (integerNum3 == integerNum4)); // true 
								   		>>> 오토박싱되어 주소값을 비교했을 때, true

[6] equals()

equals() : 래퍼 클래스 타입의 인스턴스의 "값"을 비교할 때 사용 (래퍼 클래스에도 equals가 오버라이딩 되어있음)

System.out.println("equals() : " + (integerNum1.equals(integerNum2)));
System.out.println("equals() : " + (integerNum1.equals(integerNum3)));
System.out.println("equals() : " + (integerNum3.equals(integerNum4)));

👉 parsing

parseByte() parseShort() parseInt() parseLong() parseFloat() parseDouble() parseBoolean()

💁‍♀️ parsing이란,
문자열(String) 값을 기본 자료형 값으로 변경하는 것

---

byte b = Byte.parseByte("1");
System.out.println("b : " + b);
		
short s = Short.parseShort("2");
System.out.println("s : " + s);
		
>>> 숫자로 parsing 처리할 때 불가능한 문자열을 전달 받으면 아래와 같은 오류 발생
>>> java.lang.NumberFormatException: For input string: "안뇽"

//int i = Integer.parseInt("안뇽");
int i = Integer.parseInt("4");
System.out.println("i : " + i);
		
long l = Long.parseLong("8");
System.out.println("l : " + l);
		
float f = Float.parseFloat("4.0");
System.out.println("f : " + f);
		
double d = Double.parseDouble("8.0");
System.out.println("d : " + d);
		
>>> boolean으로 파싱 될 수 없는 문자가 전달되면 모두 false로 파싱 (문자열도)
//boolean bl = Boolean.parseBoolean("빠이"); // false
boolean bl = Boolean.parseBoolean("true");
System.out.println("bl : " + bl);
		
>>> Character는 parsing 기능 제공 X
>>> 따라서, charAt()을 사용해야함
char c = "abc".charAt(0);
System.out.println("c : " + c);

👉 valueOf() & toString()

valueOf() : 기본자료형 값을 Wrapper 클래스 타입으로 변환시키는 메소드
toString() : 필드 값을 문자열로 반환하는 메소드

>>> parsing과 반대로 기본자료형 값을 문자열로 변경하는 경우도 필요
		
String b = Byte.valueOf((byte)1).toString();
System.out.println("b : " + b);
		
String s = Short.valueOf((short)2).toString();
System.out.println("s : " + s);
		
String i = Integer.valueOf(4).toString();
System.out.println("i : " + i);
		
String l = Long.valueOf(8L).toString();
System.out.println("l : " + l);
		
String f = Float.valueOf(4.0f).toString();
System.out.println("f : " + f);
		
String d = Double.valueOf(8.0).toString();
System.out.println("d : " + d);
		
String bl = Boolean.valueOf(true).toString();
System.out.println("bl : " + bl);
		
String c = Character.valueOf('a').toString();
System.out.println("c : " + c);
		
>>> String 클래스의 valueOf 메소드를 사용할 수도 있음
String str = String.valueOf(10);
System.out.println("str : " + str);
		
>>> 문자열 합치기를 이용해 String으로 변환할 수도 있음
String str2 = 123 + "";
System.out.println("str2 : " + str2);

---

👀 Calendar

👉 Date 클래스 (대부분의 메소드가 Deprecated)

[1] 기본 생성자

// 운영체제의 날짜와 시간 정보를 이용해서 인스턴스 생성
Date today = new Date();
		
>>> toString() 메소드가 오버라이딩 되어있어 쉽게 필드 값을 출력해 볼 수 있음
>>> 주소값이 출력되지 않는 것을 보면 Date도 toString을 오버라이딩 하고 있음을 알 수 있음
System.out.println(today); // Tue Jan 03 15:08:03 KST 2023 

>>> getTime() : 1970년 1월 1일 0시 0분 0초 이후 지난 시간을 millisecond로 계산해서 long 타입으로 반환
System.out.println(today.getTime());

[2] 매개변수 생성자

// 전달하는 long 타입의 숫자 기준의 날짜로 인스턴스 생성
Date time = new Date(0L);

System.out.println(time); // Thu Jan 01 09:00:00 KST 1970 (한국 시간 기준으로 출력)

👉 Calendar 클래스

💁‍♀️ Calendar 클래스란,
JDK 1.1부터 새롭게 제공되는 시간과 날짜에 관한 처리를 담당하는 클래스. Calendar 클래스가 추가되면서 Date의 많은 메소드는 Deprecated.

---

📍 Calendar 클래스를 이용한 인스턴스 생성 방법

1) getInstance() static 메소드를 이용하여 인스턴스 반환
2) GregorianCalendar 메소드를 이용하여 인스턴스 생성

---

>>> Calendar 클래스는 추상 클래스. 따라서 생성자를 통해 인스턴스 생성 X
//Calendar calendar = new Calendar();

[1] getInstance() static 메소드를 이용하여 인스턴스 반환

Calendar calendar = Calendar.getInstance();
		
>>> toString이 오버라이딩 되어있어서 모든 필드의 값을 확인 가능
>>> Date 클래스에 비해 매우 많은 필드값이 있으며 생성된 인스턴스 타입은 GregorianCalendar 타입

System.out.println(calendar); >>> toString 오버라이딩 되어있어 주소값이 아닌 필드값 출력

[2] GregorianCalendar 메소드를 이용하여 인스턴스 생성

>>> 위 방법과 값은 동일하게 출력

Calendar gregorianCalendar = new GregorianCalendar(); 
							>>> GregorianCalendar은 Calander의 후손 클래스

System.out.println(gregorianCalendar);

[3] 년, 월, 일, 시, 분, 초 정보를 이용해서 인스턴스 생성

int year = 2023;
int month = 6 - 1;		>>> 월은 0~11로 사용하기 때문에 주의 (6월을 표현하려면 6-1월)
int dayOfMonth = 9;
int hour = 15;
int min = 10;
int second = 30;
		
Calendar endDay = new GregorianCalendar(year, month, dayOfMonth, hour, min, second);
System.out.println(endDay);

[4] 특정 일자를 기준으로 한 Date 타입의 인스턴스가 필요한 경우

getTimeInMillis() : 먼저 GregorianCalendar를 이용해서 특정 날짜/시간 정보로 인스턴스를 생성한 후, 1970년 1월 1일 0시 0분 0초를 기준으로 지난 시간을 millisecond으로 계산해서 long형으로 반환하는 메소드

System.out.println(endDay.getTimeInMillis());
		
Date date = new Date(endDay.getTimeInMillis());
System.out.println(date); // Fri Jun 09 09:10:30 KST 2023 출력

[5] 생성된 인스턴스의 필드 정보를 Calendar 클래스에 있는 get() 메소드를 사용하여 반환 받을 수 있음

int endYear = endDay.get(1);		// 2023
int endMonth = endDay.get(2);		// 5
int endDayOfMonth = endDay.get(5);	// 9
		
System.out.println(endYear);
System.out.println(endMonth);
System.out.println(endDayOfMonth);

[6] 인자로 전달하는 정수에 따라 필드 값을 반환 받는데 각 필드에 매칭되는 정수를 외우고 있을 수는 없으므로 해당 값을 '상수 필드' 형태로 제공

Calendar.YEAR Calendar.MONTH Calendar.DATE Calendar.DAY_OF_WEEK

System.out.println(Calendar.YEAR);	// 1
System.out.println(Calendar.MONTH); // 2
System.out.println(Calendar.DATE); 	// 5

>>> get() 메소드의 인자로 정수를 넣는 것 대신, 상수 필드 값을 호출하는 식으로 코드를 개선하면 
>>> 보다 의미 전달이 쉬운 코드가 됨
System.out.println("year : " + endDay.get(Calendar.YEAR)); 		 	   // 2023
System.out.println("month : " + endDay.get(Calendar.MONTH)); 	 	   // 5
System.out.println("dayOfMonth : " + endDay.get(Calendar.DATE)); 	   // 9
System.out.println("dayOfWeek : " + endDay.get(Calendar.DAY_OF_WEEK)); // 6 => 금요일
												>>> 요일(일-1, 월-2, ..., 토-7)의 의미

[7] endDay가 어떤 요일인지 O요일로 출력하기

String day = "";
switch(endDay.get(Calendar.DAY_OF_WEEK)) {
case Calendar.SUNDAY : day = "일"; break;
case Calendar.MONDAY : day = "월"; break;
case Calendar.TUESDAY : day = "화"; break;
case Calendar.WEDNESDAY : day = "수"; break;
case Calendar.THURSDAY : day = "목"; break;
case Calendar.FRIDAY : day = "금"; break;
case Calendar.SATURDAY : day = "토"; break;
}
		
System.out.println(day + "요일"); // 금요일

[8] 시간과 관련된 상수 필드

Calendar.AM_PM Calendar.HOUR_OF_DAY Calendar.HOUR Calendar.MINUTE Calendar.SECOND

System.out.println("ampm : " + endDay.get(Calendar.AM_PM)); //  1
															>>> 0은 오전, 1은 오후
System.out.println(endDay.get(Calendar.AM_PM) == Calendar.AM ? "오전" : "오후"); // 오후
		
System.out.println("hourOfDay : " + endDay.get(Calendar.HOUR_OF_DAY));	// 15 => 24시간 체계
System.out.println("hour : " + endDay.get(Calendar.HOUR));				// 3 => 12시간 체계
		
System.out.println("min : " + endDay.get(Calendar.MINUTE));			// 10
System.out.println("second : " + endDay.get(Calendar.SECOND));		// 30

---