java

java를 공부하며 기록한 내용입니다.

JAVA의 동작과정

 

객체지향 언어의 장점

1. 상속 기능을 통해 코드의 재사용성을 높일 수 있다.

2. 일상생활 모습의 구조가 객체에 자연스럽게 녹아들어 있기 때문에 생각하고 있는 것을 그대로 자연스럽게 구현할 수 있다.

3. 잘 설계된 클래스를 만들어서 독립된 객체를 사용함으로써 개발의 생산성을 향상시킬 수 있음.

 

객체지향 언어의 단점

1. 객체가 처리하려는 것에 대한 정확한 이해가 필요하기에 설계단계부터 많은 시간이 소모된다.

2. 객체지향 언어는 대체적으로 실행속도가 느리다.

3. 다중상속이 지원되는 c++의 경우에는 너무 복잡해져 코딩의 난이도가 상승할 수 있다.

 

자바 프로그램 실행과정

1. 자바컴파일러(javac)에 의해서 .java 소스코드를 자바 바이트코드(.class)로 변환시킨다.

2. Class Loader를 통해 class 파일들을 jvm으로 로딩한다.

3. 로딩된 class 파일들은 Execution engine을 통해 해석된다.

4. 해석된 바이트코드는 Runtime Data Areas에 배치되어 실질적인 수행이 이루어지게 된다.

5. 이러한 실행과정 속 jvm은 필요에 다라 Thread Synchronization 과 GC같은 관리작업을 수행한다.

 

JVM의 구조

jvm은 크게 클래스 로더(Class Loader), 실행엔진(Execution Engine), 런타임 데이터 영역(Runtime Data Area)로 구성되어 있습니다. 

클래스로더는 class 파일을 jvm내로 로드하는 역할을 수행하며, 실행엔진은 로드된 class 파일을 jvm 내부에서 기계가 실행할 수 있는 기계어로 변경됩니다. 이때 인터프리터와 Just In Time 방식이 있습니다. 해석된 바이트코드(.class파일)은 런타임 데이터 영역 에 배치되어 실질적인 수행이 이루어지게 됩니다. 또한 런타임 데이터 영역의 heap 영역은 GC의 대상이 됩니다.

• Class Loader
  • jvm내로 클래스 파일을 로드하고, 링크를 통해 배치하는 작업을 수행하는 모듈
• Execution Engine(실행 엔진)
  • 클래스를 실행시키는 역할.
  • 자바 바이트코드(.class)는 기계가 바로 수행할 수 있는 언어보다는 비교적 인간이 보기 편한 형태로 기술된 것.
  • 실행 엔진은 이와 같은 바이트코드를 실제로 jvm내부에서 기계가 실행할 수 있는 형태로 변경한다. 이 때 두가지 방식을 사용
    • Interpreter(인터프리터)
      • 실행 엔진은 자바 바이트코드를 명령어 단위로 읽어서 실행한다. 이 방식은 인터프리터 언어의 단점을 그대로 갖고 있다. 한 줄씩 수행하기 때문에 느리다는 것
    • JIT(Just-In-Time)
      • 인터프리터 방식의 단점을 보완
      • 인터프리터 방식으로 실행하다가 적절한 시점에 바이트코드 전체를 컴파일하여 네이티브 코드로 변경하고, 이후에는 더 이상 인터프리팅 하지 않고 네이티브 코드로 직접 실행하는 방식이다. JIT컴파일러가 컴파일하는 과정은 바이트 코드를 인터프리팅하는 것 보다 훨씬 오래 걸리므로 한 번 만 실행되는 코드라면 컴파일하지 않고 인터프리팅 하는것이 유리하다.

• 런타임 데이터 영역(Runtime Data Area)
  • 힙 영역(Heap)
    • 객체와 배열, 인스턴스 변수가 할당되는 영역
    • 모든 thread에서 공유되는 특징이 있음. gc가 동작하는 영역
    • young 영역과 old 영역으로 나뉘며, young 영역은 eden 영역과 2개의 survivor 영역으로 나뉘어짐
  • 스택 영역(Stack)
    • 메서드 호출 시 지역 변수, 매개변수, 함수 호출내역 등이 저장되는 영역.
    • 각 스레드마다 개별적으로 생성되며, 메서드 호출 시 생성되었다가 메서드가 종료되면 사라짐.
  • 메서드 영역(Method Area) (=클래스=스태틱)영역
    • 클래스, 메소드 정보와 클래스 변수(static int) 정보 저장
    • 모든 스레드가 공유하는 영역
  • PC 레지스터
    • 각 스레드마다 jvm이 수행할 명령어의 주소가 저장되는 영역
  • 네이티브 메서드 스택
    • 자바가 아닌 다른 언어로 실행된 메서드들을 실행하기 위한 스택영역

 

GC의 동작 과정

• gc는 크게 가비지 컬렉션이 될 대상 객체를 식별하는 mark과정과 이를 제거하는 sweep 과정이 반복됩니다. heap 메모리의 young영역(Eden, Survivor0, Survivor1)에 대해서 minor gc가 수행되고 old영역으로 promotion 된 객체들에 대해서 major gc가 진행됩니다. 이때 old영역이 young영역보다 크기때문에 major gc에 많은 시간이 걸리게 됩니다. 따라서 major gc순간 어플리케이션의 성능이 저하될 수 있습니다.

1. 처음 생성된 객체는 Young Generation의 Eden 영역에 위치
2. Eden영역이 다차게 되면 minor gc가 수행
3. mark 동작을 통해서 unreachable한 객체를 탐색
4. Eden영역에서 reachable인 객체는 survivor 영역으로 이동
5. Eden영역에서 unreachable인 객체의 메모리를 해제(sweep)
6. 살아남은 모든 객체의 age 값이 증가
7. 또다시 Eden영역이 다차게 되면 minor gc가 수행
8. Old Generation 영역이 다차게 되면 major gc가 수행

자바에서는 개발자가 마음대로 객체를 소멸시킬 수 없습니다.

가비지 컬렉터가 적절한 시점에 자동으로 수집하여 가용 메모리에 반환시킵니다.

 

자바가 가비지를 어떻게 알아낼까?
참조하는 래퍼런스가 하나도 없는 객체나 배열을 가비지로 판단합니다.

 

가비지 컬렉션 강제 요청 

System.gc(); // 가비지 컬렉션 강제 요청

하지만 이 문장을 호출한다고 해서 즉시 가비지 컬렉터가 작동하는 것은 아닙니다.

(가비지 컬렉션이 필요하다는 요청에 불과합니다.)

가비지 컬렉션은 자바 플랫폼이 전적으로 판단하여 적절한 시점에 작동시킵니다.

❗System.gc() 메서드를 호출하는 것은 시스템의 성능에 매우 큰 영향을 끼치므로 절대로 사용해서는 안된다고 합니다. (https://d2.naver.com/helloworld/1329)

 

 

---

JAVA의 특징과 메서드

 

객체지향 프로그래밍

장점 : 블록 형태의 모듈화된 프로그래밍이 가능, 신뢰성 높은 프로그래밍 가능, 추가/수정/삭제 용이, 재사용성 높다.

OOP is A PIE

A (Abstraction) : 추상화, 현실 세계의 객체를 추상화해서 클래스를 구성한다.

P (Polymorphism) : 다형성, 하나의 객체를 여러가지 타입으로 참조할 수 있다. 여기서는 상속 관계의 다형성을 이야기

I (Inheritance): 상속, 부모 클래스의 자산을 물려받아 자식을 정의함으로 코드의 재사용이 가능하다.

E (Encapsulation) : 데이터 은닉과 보호, 데이터를 외부에 직접 노출시키지 않고 메서드를 이용해 보호할 수 있다

 

 

현실 세계 객체, 클래스, 프로그램의 객체의 관계

현실의 객체가 갖는 속성과 기능은 추상화 되어 클래스에 정의된다.

클래스는 구체화 되어 프로그램의 객체가 된다.

Object : 실세계에 존재하는 것, 유일성을 가짐

Class : 실세계에 존재하는 것을 컴퓨터로 가져오기 위해 Class를 사용

Instance : new클래스(생성자)를 통해 프로그램의 객체를 생성

 

자바 : static type (변수를 선언할 때 데이터 타입을 사전에 선언해야 함)

파이썬 : dynamic type

 

자바는 배열을 객체로 다룹니다.

배열에 length 필드가 있음)

 

 

메소드 오버로딩(=정적바인딩)

• 메소드 이름이 동일하여아 합니다.
• 매개변수의 개수나 타입이 서로 달라야 합니다.

class Test{
	public int getSum(int i,int j){
		return i+j;    
    }
    public double getSum(int i,int j){ // 메소드 오버로딩 실패, 컴파일 오류 발생
    	return (double)(i + j);
    }

}

리턴타입은 메소드를 구분하는 기준으로 사용하지 않는다.

 

static이나 private 또는 final로 선언된 메소드는 서브 클래스에서 오버라이딩(=동적바인딩) 할 수 없다.

 

오버라이딩(=동적바인딩)

실행할 메소드를 컴파일 시에 결정하지 않고 실행 시(런타임)에 결정하는 것을 말함.

이를 통해 자바는 오버라이딩된 메소드가 항상 실행되도록 보장한다.

 

자바는 semi boolean(1 은 참, 0 은 거짓과 같은 bool은 아니지만 bool처럼 사용가능한 경우)을 지원하지 않는다 ⇒ true false만 지원한다

 

int(4byte) 는 -20억 ~ 20억 까지 표현가능

 

묵시적 형 변환 : 작은 크기의 타입은 큰 크기의 타입으로 자동 형 변환됨.

명시적 형 변환 : 큰 크기의 타입을 작은 크기의 타입으로 변환하려면 명시적으로 표시해줘야 함(데이터가 손실될 수 있음)

 

정수형의 기본은 int이다.

int i1 = Integer.MAX_VALUE;
long l1 = (long)(i1 + 1);
System.out.println(l1);

값이 깨진다 (연산의 기본단위는 int이기 때문에 이미 값이 깨진 상태로 연산이 수행된다)

int i1 = Integer.MAX_VALUE;

long l2 = (long)i1 + 1;
System.out.println(l2);

값이 깨지지 않고 실행된다.

 

 

실수형의 기본은 double이다.

• float(4byte)
• double(8byte)

public class A {
	
		public static void main(String[] args) {
			
			float f1 = 2.0f; // f를 적어줘야 한다 (2.0으로 적으면 double형이 기본)
			float f2 = (float)2.0; // 혹은 타입 캐스팅을 해주면 된다.
			double d1 = 4.0;
			
		}
	
	}

 

실수의 연산은 부정확하다.

실수는 근삿값으로 계산한다.

실수를 정수로 바꿔서 계산하고 다시 실수로 바꾸는 방식으로 정확성을 해결할 수 있다.

double d1 = 2.0;
double d2 = 1.1;

double result = ((int)(d1*100)-(int)(d2*100))/100.0;

 

문자 '0' : 48

문자 'A'는 65

 

shift 연산

정수에서만 쓰인

<< 한 번은 곱하기 2

>> 한 번은 나누기 2

(s = s<<10) == (s*=1024)

 

클래스변수(=static변수)

public class Solution {

	static int[] a ;

	public static void main(String[] args) {

		
		System.out.println(a);
	
	}

}

출력으로 null이 나온다.

클래스 변수의 경우 초기화되어 있지 않으면 기본적으로 'null'값을 가짐.

 

Arrays.copyOf()

int[][] originalArray = {{1,2,3},{4,5,6},{7,8,9}};

int[][] copiedArray = new int[originalArray.length][];

for(int i=0;i<originalArray.length;i++){
	copiedArray[i] = Arrays.copyOf(originalArray[i],originalArray[i].length);
}

깊은복사를 수행해준다.

(여기서 처럼 2차원 배열 copiedArray를 생성할 때 행 부분만 크기를 설정해줄 수 도 있다.)

Arrays.copyOfRange()

int[] arr = {0,1,2,3,4,5};

int[] arr1 = Arrays.copyOfRange(arr,0,3);
// [0,1,2]

int[] arr2 = Arrays.copyOfRange(arr,3,arr.length);
// [3,4,5]

특정 인덱스를 기준으로 배열 자르는 함수

 

 

하나의 클래스에 대해 백개를 인스턴스화 해도 method는 하나만 만들어진다.

 

reference type과 wrapper 클래스 비교

reference type은 primitive type이 아닌 모든 유형을 나타냄

wrapper클래스는 primitive type을 객체로 표현하는 기능을 제공

즉 wrapper클래스는 reference type이지만, 모든 reference type이 wrapper 클래스는 아님.

 

오버라이딩 : 상위 클래스가 가지고 있는 메서드를 하위 클래스가 재정의해서 사용

오버로딩 : 같은 이름의 메서드 여러개를 가지면서 매개변수의 유형과 갯수가 다르도록 하는 기술

 

HashSet자료구조는 내부적으로 HashMap 으로 구성되어 있다.

 

ArrayList의 contains는 시간복잡도가 O(n)이고 HashSet의 경우 시간복잡도가 O(1) 이다. 

 

메서드

String 

String은 immutable하다.

String str = "mincheol";

// 빈 문자열 체크
str.isEmpty(); 

// 문자 찾기
str.charAt(0); // 'm' : char 문자 반환
str.indexOf("m"); // 0 : 인덱스 반환
str.lastIndexOf("h") // 4 : 마지막으로 문자가 속한 인덱스 반환

// 문자 자르기
str.substring(1,3); // "in" : 인덱스 1 이상 3미만 위치의 문자열 반환
str.substring(3); // "min" : 인덱스 3 미만 위치의 문자열 반환

// 문자 비교
/**
* str이 "mincheoz"와 같으면 0
* str이 "mincheoz"보다 사전순으로 앞이면 -1
* str이 "mincheoz"보다 사전순으로 뒤면 1
*/
str.compareTo("mincheoz"); // -1

// 문자 포함여부 판단
str.contains("min");

// 문자열 분리
str.split(" "); // 공백으로 구분된 문자열 str을 분리하여 String[] 배열로 변환
str.split(""); // 띄어쓰기 없는 문자열 str을 한 문자씩 분리하여 String[] 배열로 변환

// 문자 앞뒤 공백 제거
str.trim(); // str의 앞뒤 공백을 제거. 문자열 사이의 공백은 제거하지 않음

// 문자 <-> 숫자 변환
Integer.parseInt("100");
Integer.toString(100);

 

StringBuilder

String은 immutable 하기 때문에 한 번 만들어지면 문자를 추가하거나 삭제할 수 없습니다.

따라서 변경이 필요한 경우 StringBuilder를 사용할 수 있습니다.

StringBuilder sb = new StringBuilder();

sb.append("apple");

// 특정 인덱스에 문자 삽입
sb.insert(2,"oo"); // "apoople"

// 문자열 삭제
sb.delete(0,2); // "oople"

// 특정인덱스 문자 삭제
sb.deleteCharAt(2); // "oole"

// 특정인덱스 문자 변경
sb.setCharAt(1,'p'); // "ople"

// 문자열 뒤집기
sb.reverse(); // "elpo"

// 문자열 길이 줄이기
sb.setLength(2); // "el"

// 문자열 길이 늘리기 (뒤에 문자는 공백으로 채워짐)
sb.setLength(4); // "el  "

 

List 관련 메소드

List<Integer> list = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();

list.add(0);

// 특정 인덱스에 요소 삽입
list.add(0, 1); 
System.out.println(list.toString()); // [1, 0]

// 리스트 병합(추가되는 리스트가 뒤로 옴)
list.addAll(list2);

// 특정 요소의 첫번째 인덱스 반환
list.indexOf(0); // 1

// 특정 요소의 마지막 인덱스 반환
list.lastIndexOf(0); // 1

// 특정 인덱스의 값 삭제
list.remove(0); // 결과 : [0]

// 특정 요소의 값 삭제
list.remove(Integer.valueOf(0)); // 결과 : [1]

// 리스트 차집합
list.removeAll(list2); // list에서 list2에 있는 모든 값을 삭제

// 리스트 교집합
list.retainAll(list2); // list에서 list2에 있는 값을 제외한 모든 값을 삭제

// 포함여부 체크
list.contains(1);

// 리스트에 다른 리스트 요소가 전부 포함되어 있는지 여부 체크
list.containAll(list2); // list에 list2의 모든 값이 포함되어 있으면 true

// 람다식 사용해서 요소들 제거
list.removeIf(x -> x%2==0) // list에서 짝수인 수를 모두 제거

 

배열 <-> 리스트

// 배열을 리스트로 변환
String[] temp = {"apple", "banana", "lemon"};
List<String> list = new ArrayList<>(Arrays.asList(temp));


// 리스트를 배열로 변환
List<String> list = new ArrayList<>();
String[] temp = list.toArray(new String[0]); // new String[0] 해주면 알아서 사이즈 맞게 배열 생성

// List를 int배열로 변환
List<Integer> list = new ArrayList<>();
int[] temp = list.stream().mapToInt(x -> x).toArray();

Arrays.asList의 return 값은 java.util.Arrays.ArrayList 로, java.util.ArrayList와 다르다. 

그리고 immutable하다.

 

따라서

List<String> list = Arrays.asList("a","b","c");

와 같이 생성한 ArrayList는 immutable하므로 변경할 수 없다.

List<String> list = new ArrayList<>(Arrays.asList("a","b","c"));

와 같이 해줘야 한다.

 

리스트 생성과 동시에 초기화

List<String> list = new ArrayList<>(){{
	add("a");
    add("b");
    add("c");
}};

 

Collections 관련 메소드

Integer[] arr = {1,2,3,10,28};
List<Integer> list = new ArrayList<>(Arrays.asList(arr));

// 정수형 List 원소 중 최대, 최소값
Collections.max(list);
Collections.min(list);

// List 정렬
Collections.sort(list);
Collections.sort(list,Collections.reverseOrder());

// List 뒤집기
Collections.reverse(list);

// List 내 원소의 갯수 반환
Collections.frequency(list,3);

// 이진탐색
Collections.binarySearch(list,10);

Collections.max()의 시간복잡도는 O(n)입니다.

 

Deque

Deque<Integer> q = new ArrayDeque<>();
q.offer(1);
q.offer(2);
q.offer(5);


q.contains(1); // true

q.remove(5);

contains 함수가 있다.

remove함수도 있다. 시간복잡도는 O(n).

PriorityQueue함수도 remove함수가 있다. 시간복잡도는 삭제하는 시간 n과 삭제 후 다시 우선순위로 정렬하는 시간 logn의 시간이 걸려서 O(n + logn) 인데 n이 지배하므로 O(n)이 된다.

 

HashMap

HashMap<Integer,String> hashMap = new HashMap<>();

hashMap.put(1,"딸기");
hashMap.put(2,"바나나");
hashMap.put(3,"사과");

hashMap.remove(1); // key가 1인 요소 삭제

hashMap.containsKey(1); // key 포함여부 확인

hashMap.containsValue("사과"); // value 포함여부 확인

for(Integer key : hashMap.keySet()){
	System.out.println(key + " " + hashMap.get(key));
}

for(String value : hashMap.values()){
	System.out.println(value);
}

keySet() : key값들 다 

values() : value값들 다

 

hashMap의 value로 hashMap을 활용하는 알고리즘 문제가 있어서 적음

		Map<String, Object> genresMap = new HashMap<>();//<장르, 곡 정보> 
        Map<String, Integer> playMap = new HashMap<>(); //<장르, 총 장르 재생수>
        List<Integer> resultAL = new ArrayList<>();

        for(int i = 0; i < genres.length; i++){
            String key = genres[i];
            HashMap<Integer, Integer> infoMap;       // 곡 정보 : <곡 고유번호, 재생횟수>

            if(genresMap.containsKey(key)){ // 해당 장르가 genreMap에 있으면?
                 infoMap = (HashMap<Integer, Integer>)genresMap.get(key);
            }else {
                infoMap = new HashMap<Integer, Integer>();
            }

            infoMap.put(i, plays[i]);
            genresMap.put(key, infoMap);

 

genreMap의 경우 value값으로 또 다른 HashMap을 가지고 있음.

장르 별 곡 정보를 가진  genreMap은 <장르 : 곡 정보>

곡 정보를 Object형으로 선언한 뒤, 형 변환을 해주고 있다.

곡정보 infoMap는 <곡 고유번호 : 재생횟수> 이다.