Java - API

API

* API : Application Programming Interface
* '라이브러리'라고도 함.

Math클래스

* 수학과 관련된 유용한 기능을 제공하는 클래스
* java.lang.math에 위치해 있음.
* 모든 메소드들이 static, 모든 필드들이 상수필드임
* => 객체 생성을 할 필요가 없음.
*
* Math m = new Math();
* [오류] The constructor Math() is not visible
* Ctrl키를 누르고 Open declaration을 보면 생성자가 private로 되어있음
*
* static : 프로그램 실행과 동시에 메모리 영역에 올려놓음.
* 		   공유(재사용)의 개념이 강함.
* 		   => 싱글톤 패턴(클래스의 객체를 API문서에 단 한번 생성하고, 이를 사용함)

package com.kh.chap01_math.run;
// import java.lang.Math; => 생략가능(항상 import되어있음)

public class MathRun {
	public static void main(String[] args) {
//		상수
//		파이(원주율) => Math클래스 내에 상수필드로 정의되어 있음.
		System.out.println("파이 : "+ Math.PI);
		
//		메소드
//		객체명.메소드명(매개변수) : 반환형
//		1. 올림처리 => Math.ceil(double) : double
		double num1 = 4.349;
		System.out.println("올림 : "+Math.ceil(num1)); // 5.0
		
//		2. 반올림처리 => Math.round(double) : long
		System.out.println("반올림 : "+Math.round(num1)); // 4
		
//		3. 버림처리 => Math.floor(double) : double
		System.out.println("버림 : "+Math.floor(num1)); // 4.0
		
//		4. 절대값(absolute) => Math.abs(int,double,long,float) : int, double, long, float(오버로딩 되어있음.)
		int num2 = -10;
		System.out.println("절대값 : "+Math.abs(num2)); // 10
		
//		5. 최소값 => Math.min(int,int) : int
		System.out.println("최소값 : "+Math.min(5, 10)); // 5
		
//		6. 최대값 => Math.max(int,int) : int
		System.out.println("최대값 : "+Math.max(5, 10)); // 10
		
//		7. 제곱근(square root) => Math.sqrt(double) : double
		System.out.println("4의 제곱근 : "+Math.sqrt(4)); // 2.0
		
//		8. 제곱 => Math.pow(double, double) : double
		System.out.println("2의 10제곱 : "+Math.pow(2, 10)); // 1024.0
	}
}

String클래스

상수풀(String Pool)

* String은 "불변클래스"(변하지 않는 클래스)라고 불림.
* => String 객체 기준으로 값이 수정되는 순간, 기존에 담긴 공간의 값이 변경되는 것이 아닌, 
* => 새로운 곳에서 새로운 문자열이 생기고 그 위치를 참조함.
*
* String 객체를 만들때, 리터럴을 제시하는 방식으로 객체를 만들면
* 그 내용물이 heap영역에 있는 "상수풀(StringPool)"의 영역에 올라가게 됨.
* 이 영역에서는 중복되는 내용이 있다면, 중복된 내용을 빼는 대신, 같은 주소값을 참조하게 함.

package com.kh.chap02_String.controller;

public class A_StringPoolTest {

//	String형태의 객체 만들기
//	1. 생성자를 통해서 문자열 담기 => String str = new String();
	public void method1() {
		String str1 = new String("Hello");
		String str2 = new String("Hello");
//		Stack				Heap
//		
//		0123	-------->	Hello
//		str1				0123
//		
//		1234	-------->	Hello
//		str2				1234
		System.out.println(str1 == str2); // false, 주소값 비교
		System.out.println(str1/*.toString*/);	// Hello
//		왜 toString인데도 주소값이 아닌 실제값이 나오는가?
//		Object클래스의 toString()메소드와 달리,
//		String클래스의 toString()메소드의 경우
//		오버라이딩을 하여 실제 담겨있는 주소값이 아닌, 실제 담겨있는 문자열을 반환하게끔 함.
		System.out.println(str1.equals(str2));	// true, 실제 문자열 비교
//		String 클래스의 equals()메소드의 경우,
//		원래는 실제 담겨있는 주소값을 비교하는 역할에서
//		실제 담겨있는 문자열을 비교할 수 있게끔 오버라이딩 한 것임.
		
		System.out.println(str1.hashCode()); // 69609650
		System.out.println(str2.hashCode()); // 69609650
//		참조형변수(객체)에서 주소값을 10진수의 형태로 반환해주는 메소드
//		str1과 str2의 주소값이 같게 나옴.
//		이유는 String클래스의 hashcode()메소드의 경우
//		실제 담겨있는 주소값을 10진수 형태로 내보내는 역할은 맞으나,
//		이 역할에서 실제 담겨있는 문자열 기반으로 해시코드를 10진수 형태로 만들어서 내보내게끔 오버라이딩함.
//		즉, 둘다 "Hello"로 문자열이 동등하기 때문에, 같은 주소값이 나옴.
		
//		그렇다면 진짜 주소값의 해시코드를 알고싶다면?
//		System.identityHashCode(참조형변수명)
//		=> 해당 객체의 실제 주소를 해시코드로 출력
		System.out.println(System.identityHashCode(str1));
		System.out.println(System.identityHashCode(str2));
	}

//	2. 값을 리터럴로써 대입해버리기 => String str = "~";
	public void method2() {
		String str1 = "hello";
		String str2 = "hello";
//									  ┌> hello(중복된 내용)
//		Stack				Heap     ─┘
//						   [상수풀]
//		0123	──────────> hello
//		str1				0123
//							 ↑
//		1234	─────────────┘	
//		str2
		
//		String 객체를 만들때, 리터럴을 제시하는 방식으로 객체를 만들면
//		그 내용물이 heap영역에 있는 "상수풀(StringPool)"의 영역에 올라가게 됨.
//		이 영역에서는 중복되는 내용이 있다면, 중복된 내용을 빼는 대신, 같은 주소값을 참조하게 함.
		
		System.out.println(str1 == str2); // true, 주소값 비교
		System.out.println(str1/*toString*/);
		System.out.println(str2/*toString*/);
		System.out.println(str1.equals(str2)); // true, 실제값 비교
		
		System.out.println(str1.hashCode());
		System.out.println(str2.hashCode()); // 실제 내용물(문자열)을 기반으로 10진수화
		
		System.out.println(System.identityHashCode(str1));
		System.out.println(System.identityHashCode(str2));	// 실제 주소값을 반환
	}

//	불변클래스
//	=> 기존의 내용물이 변하지 않고, 새로운 주소에 새로운 내용을 추가하고, 참조하는 주소를 바꿈.
	public void method3() {
		String str = "hello";
		System.out.println(System.identityHashCode(str));
		
		str = "goodbye";
		System.out.println(System.identityHashCode(str));
		
		str += "abc";
		System.out.println(str);
		System.out.println(System.identityHashCode(str));
		
//										 ┌> hello(0123), goodbye(1234) => 연결이 끊겨, 언젠가 GC가 지워줌.
//		Stack				Heap		─┘
//						  [상수풀]
//		2345			  goodbyeabc
//		str				  2345	
//						  
		/*
		 * 기존의 상수풀의 연결이 끊긴 문자열들은 GC에 의해 정리됨.
		 * "불변"이라고 해서 수정이 아예 안되는 것이 아니라(이 경우는 "상수"임)
		 * 기존의 그 자리에서 수정되는 개념이 아닌, 매번 새로운 주소값을 참조하는 개념
		 */
	
	}
}

String 메소드

package com.kh.chap02_String.controller;

import java.util.Arrays;
import java.util.Scanner;

public class B_StringMethodTest {
	public void method() {
		String str1 = "Hell world";
		
//		메소드명(매개변수) : 반환형
		
//		1. 문자열.charAt(int index) : char
//		=> 문자열로부터 전달받은 index 위치의 문자 하나만을 추출해주는 메소드
		char ch = str1.charAt(3);
		System.out.println("ch : "+ch);	// l
		
//		2. 문자열.concat(String str) : str
//		=> 문자열과 전달된 또 다른 문자열을 하나로 합쳐서 반환해줌.
//		=> 문자열 = 문자열 + str과 같은 역할
//		=> 단, 두 뭉텅이로만 묶을 수 있음.
		String str2 = "!!!";
		System.out.println(str1.concat(str2));
		System.out.println(str1 + str2);
		
//		3. 문자열.length() : int
//		=> 현재 문자열의 길이를 반환해줌.
		System.out.println("str1의 길이 : "+str1.length()); // 10(띄어쓰기 포함)
		
//		4-1. 문자열.substring(int 시작index) : String
//		=> 문자열의 시작index위치에서부터 끝까지의 부분문자열을 추출하여 반환해주는 메소드임.
		System.out.println("Str1의 부분문자열 : "+str1.substring(6)); // orld
		
//		4-2. 문자열.substring(int 시작index, int 끝index) : String  => 오버로딩
//		=> 문자열의 시작index위치에서부터 끝 index의 위치의 부분문자열을 추출하여 반환해주는 메소드임.
		System.out.println("str1의 부분문자열 : "+str1.substring(0,6)); // Hell w (0 <= 인덱스 범위 < 6)
		
//		5. 문자열.replace(char old, char new) : String
//		=> old에 해당하는 문자열을 new로 변환시켜서, 해당 문자열을 반환시켜주는 메소드
		String str3 = str1.replace('l', 'c');
		System.out.println("str3 : "+str3);
		
//		6. 문자열.trim() : String
//		=> 문자열에서의 앞뒤 공백을 제거한 문자열을 반환해주는 메소드
		String str4 = "    JA VA    ";
		System.out.println("str4.trim()적용 : " + str4.trim()); // JA VA
//		QUIZ) 중간의 공백을 없애고 싶다면?
		System.out.println((str4).replace(" ", ""));
		
//		7-1. 문자열.toUpperCase() : String
//		=> 해당 문자열을 모두 대문자로 변경 후, 그 문자열을 반환시켜줌.
		System.out.println("대문자 : " + str1.toUpperCase());
//		7-2. 문자열.toLowerCase() : String
//		=> 해당 문자열을 모두 소문자로 변경 후, 그 문자열을 반환시켜줌.
		System.out.println("소문자 : " + str1.toLowerCase());
		
		/*
		 * 사용자로부터
		 * 종료를 원하면 Y를 입력하시오. 라고 유도
		 */
		System.out.println("---------------------------------------------------");
		
		Scanner sc = new Scanner(System.in);
		System.out.println("종료하시겠습니까? (Y,N) : ");
		
//		첫번째 방법
		char answer1 = sc.nextLine().charAt(0); // 'y' / 'Y'
			if(answer1 == 'y' || answer1 =='Y') {
				System.out.println("시스템을 종료합니다.");
			}else {
				System.out.println("시스템을 종료하지 않습니다.");
			}
		
		
//		두번째 방법
		char answer2 = sc.nextLine().toUpperCase().charAt(0);
//		직접접근연산자(.)로 우선순위가 모두 같기 때문에 왼쪽에서부터 실행됨.
//		사용자입력 => 대문자 => 문자추출(메소드 Chaining)
		if(answer2 =='Y') {
			System.out.println("시스템을 종료합니다.");
		}else {
			System.out.println("시스템을 종료하지 않습니다.");
		}
		
		System.out.println("---------------------------------------------------");
//		문자열 => char[]
//		str1문자열 기준으로 문자열 하나하나를 추출해서 문자 배열에 담겠다.
		char[] arr = new char[str1.length()];
		for(int i=0; i<arr.length; i++) {
			arr[i] = str1.charAt(i);	
		}
		System.out.println(Arrays.toString(arr));
		
//		8. 문자열.toCharArray() : char[]
//		=> 문자열의 각 문자들을 char배열에 옮겨담아
//		=> 그 배열 자체를 반환해주는 메소드
		char[] arr2 = str1.toCharArray();
		System.out.println(Arrays.toString(arr2));
		
//		char[] => 문자열
		char[] arr3 = {'a','p','p','l','e'};
		String result = "";
		for(int i=0; i<arr3.length; i++) {
			result = result+arr3[i];	// 문자열형 + 다른자료형 = 문자열형
		}
		System.out.println("result : "+ result);
		
//		9. static valueOf(char[] data) : String
//		=> 전달된 char배열에 담긴 문자들을 하나의 문자열로 연이어서 반환해주는 메소드
		System.out.println("메소드 사용 후 : "+String.valueOf(arr3));
		
	}
}

StringTokenizer

package com.kh.chap02_String.controller;

import java.util.StringTokenizer;

public class C_StringTokenizerTest {
	public void method1() {
		
		String str = "Java,Oracle,JDBC,HTML,Server,Spring";
		
//		[방법1]
//		1. 구분자를 제시해서 해당 문자열을 단어 단위로 분리
//		분리된 문자열들을 String배열에 차곡차곡 담아서 관리
		String[] arr = str.split(",");
//		split이라는 문자열을 쪼개주는 메소드를 활용(String 클래스)
//		[표현법] 문자열.split(String구분자) : String[]
		
//      2. 각 인덱스의 값이 빈 배열을 만들어 주기
		for(int i=0; i<arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
		
		System.out.println();

//		3. 배열을 이용하여 값을 출력하기
//		배열의 경우, for문을 다음과 같이 쓸 수 있음(향상된 for문, for each문)
//		[표현법]
//		for(값을 담아줄 변수 선언문 : 순차적으로 접근하고 싶은 배열명 또는 컬렉션명) { 반복적으로 실행할 코드 } 
		for(String s : arr) {	// 주의사항 : 해당 배열의 타입에 맞게 변수선언문을 작성해야 함!!
//			arr[0] = s => system.out.print(s) : Java
//			arr[1] = s => system.out.print(s) : Oracle
//			arr[2] = s => system.out.print(s) : JDBC
//			...
//			arr[5] = s => system.out.print(s) : Spring
			
//			내부적으로 s라는 문자열 타입의 변수에 arr[i] 방에 들은 값이 순차적으로 담기면서, 코드를 실행함.
//			값을 이미 뽑아서 변수에 담아 제공되는 형식이라, 배열에 들은 값을 변경하는 용도로는 불가능
//			단지, 배열의 값을 출력해주는 용도로만 사용함.
			System.out.print(s+" ");
		}
		
		System.out.println();
		System.out.println("-----------------------------------------");
//		[방법2] 
//		분리된 각각의 문자열들을 "토큰"이라는 단위로 취급하는 방법
//		여기서 토큰이란? 단어의 한 뭉텅이를 말하는 것임.

//		1. StringTokenizer 클래스 활용(java.util.StringTokenizer)
//		[표현법]
//		StringTokenizer 객체명 = new StringTokenizer(분리시키고자 하는 문자열, 구분자);
		StringTokenizer stn = new StringTokenizer(str, ",");
		
//		2. countTokens();
//		분리되어 존재하는 문자열의 뭉탱이 개수를 반환해줌.
		System.out.print("분리된 문자열의 개수 : "+stn.countTokens() + "개"); // 6개
		
//		3. nextToken();
//		Java, Oracle, JDBC, HTML, Server, Spring
//		쪼개진 단어를 순차적으로 반환해줌.
//		System.out.println();
		System.out.println(stn.nextToken());	// Java
		System.out.println(stn.nextToken()); 	// Oracle
		System.out.println(stn.nextToken());	// JDBC
		System.out.println(stn.nextToken());	// HTML
		System.out.println(stn.nextToken());	// Server
		System.out.println(stn.nextToken());	// Spring
		System.out.println(stn.nextToken());
//		[오류메세지]
//		java.util.NoSuchElementException
//		현재 남아있는 객체로부터, 토큰 개수의 범위를 벗어나면 발생하는 오류임.
		System.out.println();
		System.out.println("현재 담겨있는 토큰의 개수 : "+stn.countTokens() + "개"); // 0개
//		nextToken으로 뽑아내면, 현재의 토큰 개수가 감소함
		
//		토큰이 출력될수록 countTokens()의 결과값이 -1씩 되서,
//		미리 변수에 담아놓고, 이를 조건식에 사용하여 반복을 시작해야 함.
		int end = stn.countTokens();
		for(int i=0; i<end; i++) {
			System.out.print(stn.nextToken()+" ");
		}
		
//		더이상 뽑아낼 토큰이 있나?라는 조건을 제시하면 while문 사용 가능
//		StingTokenizer클래스에서 제공하는 hasMoreTokens()메소드를 사용
//		=> StringTokenizer 객체로부터 뽑아낼 토큰이 있는 경우에 true를 반환
		while(stn.hasMoreTokens()) {	// true면 출력문을
			System.out.print(stn.nextToken()+" ");
		} 	// false면 벗어남.
		
	}
}

Wrapper 클래스

* 자료형 => 기본자료형(8가지), 참조자료형(1가지)
* 기본자료형은 Stack에 실제값을 바로 담았었음.
* 기본자료형은 .메소드() 호출이 불가함.
*
* 참조자료형은 Stack에 주소값, Heap에 실제값을 담았었음.
* 참조자료형은 .메소드() 호출이 가능했음.
* 
* Wrapper클래스
* 기본자료형을 객체형식으로 포장해주는 클래스를 Wrapper클래스라고 함.
* 	
* 기본자료형	<------->	Wrapper클래스
* boolean					Boolean	
* char						Character
* byte 						Byte
* short 					Short
* int 						Integer
* long						Long
* float 					Float
* double					Double
* 
* => 기본자료형을 Wrapper클래스 형태로 바꾸어주는 작업을 Boxing이라고 함.
* => Wrapper클래스를 기본자료형으로 바꾸어주는 작업을 UnBoxing이라고 함.