posted by 귀염둥이채원 2019. 4. 29. 14:45

# Enum이란?

1. 클래스처럼 보이게 하는 상수

2. 서로 관련있는 상수들끼리 모아 상수들을 대표할 수 있는 이름으로 타입을 정의하는 것

3. Enum 클래스 형을 기반으로 한 클래스형 선언 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
public enum DevelopType {
    MOBILE("안드로이드"), WEB("스프링"), SERVER("리눅스");
     
    final private String name;
 
    // enum에서 생성자 같은 역할
    private DevelopType(String name){
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
enum ResourceType {
    CPU("CPU Usage""%"), 
    MEMORY("Memory Usage""%");
    
    final private String name;
    final private String value;
    
    private ResourceType(String name, String value) {
        this.name = name;
        this.value = value;
    }
    
    public String getName() {
        return name;
    }
    
    public String getValue() {
        return value;
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class EnumTest {
    public DevelopType type;
 
    public static void main(String[] args){
        System.out.println("--------------------------");
        System.out.println(DevelopType.valueOf("MOBILE"));
        System.out.println(DevelopType.valueOf("MOBILE").getName());
         
        for(DevelopType type : DevelopType.values()){
            System.out.println(type.ordinal()+ " -> " +type +": " +type.getName());
        }
        
        System.out.println("--------------------------");
        for(ResourceType resource : ResourceType.values()){
            System.out.println(resource.ordinal()+ " -> " +resource +":" +resource.getName()+":"+resource.getValue());
        }
    }
}
cs


# 실행 결과

1
2
3
4
5
6
7
8
9
--------------------------
MOBILE
안드로이드
0 -> MOBILE: 안드로이드
1 -> WEB: 스프링
2 -> SERVER: 리눅스
--------------------------
0 -> CPU:CPU Usage:%
1 -> MEMORY:Memory Usage:%
cs


# 참고사이트

https://limkydev.tistory.com/66

https://opentutorials.org/module/1226/8025

https://www.w3schools.com/java/java_enums.asp

posted by 귀염둥이채원 2019. 3. 4. 21:20

TreeSet, TreeMap은 이진 트리(binary tree)를 이용해서 계층적 구조(Tree 구조)를 가지면서 객체를 저장합니다.


# TreeSet

- 하나의 노드는 노드 값인 value와 왼쪽과 오른쪽 자식 노드를 참조하기 위한 두 개의 변수로 구성

- TreeSet에 객체를 저장하면 자동으로 정렬되는데 부모값과 비교해서 낮은 것은 왼쪽 노드에, 높은 것은 오른쪽 노드에 저장

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
public class TreeSetExam1 {
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<Integer>();
         
        for (int i = 1; i <= 10; i++) {
            treeSet.add(new Integer(i*10));
        }
 
        Integer score = null;
 
        score = treeSet.first();
        System.out.println("가장 낮은 점수: " + score);
 
        score = treeSet.last();
        System.out.println("가장 높은 점수: " + score);
 
        score = treeSet.lower(new Integer(90));
        System.out.println("90점 아래 점수: " + score);
 
        score = treeSet.higher(new Integer(90));
        System.out.println("90점 위 점수: " + score);
    }
}
 
/********* 결과 *********
가장 낮은 점수: 10
가장 높은 점수: 100
90점 아래 점수: 80
90점 위 점수: 100
*/
cs


# TreeMap

- TreeSet과 차이점은 키와 값이 저장된 Map.Entry를 저장한다는 점

- TreeMap에 객체를 저장하면 자동으로 정렬되는데, 기본적으로 부모 키값과 비교해서 키 값이 낮은 것은 왼쪽 노드에, 키 값이 높은 것은 오른쪽 노드에 Map.Entry에 저장

★★API 그림 추가

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
32
33
34
35
36
37
38
39
40
41
42
43
import java.util.Map;
import java.util.TreeMap;
 
public class TreeMapExam1 {
    public static void main(String[] args) {
        TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>();
 
        treeMap.put(new Integer(90), "Jack");
        treeMap.put(new Integer(77), "Mike");
        treeMap.put(new Integer(82), "Jolie");
        treeMap.put(new Integer(93), "Sminoph");
        treeMap.put(new Integer(67), "Neil");
        treeMap.put(new Integer(55), "Max");
 
        Map.Entry<Integer, String> entry = null;
 
        entry = treeMap.firstEntry();
        System.out.println("가장 낮은 점수: " + entry.getKey() + "-" + entry.getValue());
 
        entry = treeMap.lastEntry();
        System.out.println("가장 높은 점수: " + entry.getKey() + "-" + entry.getValue());
 
        entry = treeMap.lowerEntry(new Integer(95));
        System.out.println("95점 아래 점수: " + entry.getKey() + "-" + entry.getValue());
 
        while (!treeMap.isEmpty()) {
            entry = treeMap.pollFirstEntry();
            System.out.println(entry.getKey() + "-" + entry.getValue() + " (남은 객체 수: " + treeMap.size() + ")");
        }
    }
}
 
/********* 결과 *********
가장 낮은 점수: 55-Max
가장 높은 점수: 93-Sminoph
95점 아래 점수: 93-Sminoph
55-Max (남은 객체 수: 5)
67-Neil (남은 객체 수: 4)
77-Mike (남은 객체 수: 3)
82-Jolie (남은 객체 수: 2)
90-Jack (남은 객체 수: 1)
93-Sminoph (남은 객체 수: 0)
*/
cs


# 참고사이트

★★https://palpit.tistory.com/657

https://lapan.tistory.com/61

https://hackersstudy.tistory.com/26

https://12bme.tistory.com/91

posted by 귀염둥이채원 2019. 3. 3. 21:48

# Scanner

- Scanner는 사용하기 편리지만 속도가 느리다.

- 공란과 줄바꿈을 입력값의 경계로 사용하며, 입력받은 즉시 자료형이 확정된다.


# BufferedReader

- 일반적으로 라인단위로 입력을 받는다.

- 입력받은 값이 String 타입이므로 타입변환이 필요해서 불편함이 존재

- throws Exception 혹은 try ~ catch 를 이용해서 Exception을 따로 처리가 필요


하지만 많은 양의 데이터를 입력받을경우 BufferedReader를 통해 입력받는 것이 효율면에서 훨씬 낫습니다.알고리즘 문제를 풀때는 BufferedReader를 사용하는 것이 좋다.


# 성능 차이 참고

https://algospot.com/forum/read/2496/


# Scanner 예제 소스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Scanner;
 
public class ScannerPractice {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        // Integer Type Input
        int intValue = sc.nextInt();
 
        // Long Type Input
        long longValue = sc.nextLong();
        
        // Double Type Input
        double doubleValue = sc.nextDouble();
 
        // String Type Input
        String strValue = sc.next();
 
        // Boolean Type Input
        boolean boolValue = sc.nextBoolean();
    }
}
 
cs


# BufferedReader 예제 소스

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class BufferedReaderTest {
    // BufferedReader는 Exception이 처리를 따로 해줘야 하기 때문에 throws를 해주거나 
    // try ~ catch로 예외처리를 해줘야합니다.
    public static void main(String[] args) throws Exception {
        // BufferedReader 객체 생성
        // new InputStreamReader 및 System.in
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 
        // StringTokenizer 객체 선언
        StringTokenizer st = null;
 
        // String Line이므로 Integer.parseInt를 이용하여 형변환해야함
        int n = Integer.parseInt(br.readLine());
 
        // "1 3 5 7" 식으로 공란 포함 String Line일시 StringTokenizer 이용
        int[] arrays = new int[n + 1];
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= n; i++) {
            // 배열에다 토큰을 하나씩 불러서 입력해줌
            arrays[i] = Integer.parseInt(st.nextToken());
        }
    }
}
 
cs


# BufferedReader + StringBuiler 예제 소스

알고리즘 풀때는 한꺼번에 모아서 입력을 받고 한꺼번에 모아서 출력하는 것이 성능이 좋다.

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
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class Main {
    public static void main(String[] args) throws IOException{
 
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
 
        int N = Integer.parseInt(br.readLine());
        int[] arr = new int[10010];
 
        for (int i = 0; i< N;i++){
            arr[Integer.parseInt(br.readLine())]++;
        }
 
        for(int i =0; i<= 10000; i++){
            while(arr[i] != 0){
                sb.append(""+i+"\n");
                arr[i]--;
            }
            
        }
        System.out.println(sb.toString());
    }
}
 
 
출처: https://lifeignite.tistory.com/34 [게임 && PS ignite]
cs


# 참고사이트

https://cocomo.tistory.com/507

https://coding-factory.tistory.com/251

https://mygumi.tistory.com/236

https://code0xff.tistory.com/5

https://lifeignite.tistory.com/34

posted by 귀염둥이채원 2019. 3. 3. 21:18

자바는 String을 token단위로 끊어주는 StringTokenizer 클래스를 제공한다.


# 생성자

1. StringTokenizer(String str)

- str : 분석할 문자열

- 기본 분리 문자를 사용합니다. 

  기본 분리 문자에는 공백문자, 탭문자, 개행문자, 캐리지리턴문자가 있습니다.


2. StringTokenizer(String str , String delim)

- str : 분석할 문자열

- delim : 분리 문자로 사용할 문자


3. StringTokenizer(String str , String delim , boolean returnDelims)

- str : 분석할 문자열

- delim : 분리 문자로 사용할 문자

- returnDelims : 분리 문자까지 분리해서 출력할지 여부


# 주요함수

countTokens(): 토큰의 갯수를 리턴한다.

nextToken(): 다음 토큰을 리턴한다. 이전 토큰은 제거한다.

nextToken(String delim): 구획문자(delimiter)를 delim으로 바꾼 후 바뀐 다음 토큰을 리턴한다.

hasMoreTokens(): 리턴할 다음 토큰이 있으면 true를 다음 토큰이 없으면 false를 리턴한다.


# 예제 소스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Main {
    public static void main(String[] args) {
            String str = "this is my string"
            StringTokenizer st = new StringTokenizer(str); 
            System.out.println(st.countTokens()); 
            
            while(st.hasMoreTokens()) { 
                System.out.println(st.nextToken()); 
            }
            System.out.println(st.countTokens());
    }
}
 
/*********** 결과 ***************
4
this
is
my
string
0
*/
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.StringTokenizer;
 
public class Main {
    public static void main(String[] args) {
        String str = "this%^is%^my%^string"
        
        StringTokenizer st = new StringTokenizer(str,"%^");
        System.out.println(st.nextToken()); 
        System.out.println(st.nextToken());
        System.out.println(st.nextToken());
        System.out.println(st.nextToken());
    }
}
 
/*********** 결과 ***************
this
is
my
string
*/
cs


# 참고사이트

https://arer.tistory.com/48

https://dlfma1985.tistory.com/52

posted by 귀염둥이채원 2019. 3. 3. 20:52

# String

- String 객체는 한번 생성되면 할당된 메모리 공간이 변하지 않는다.

  + 연산자 또는 concat 메서드를 사용할 경우 새로운 String 객체를 생성 --> 메모리 낭비

- 문자열 연산이 많은 경우 성능이 좋지 않다.

- synchronization(동기화) 없이도 데이터가 안전하게 공유 가능 (Thread-safe)


# StringBuffer

- mutable 가변클래스 &&  synchronization(동기화) 보장, 멀티 스레드 보장

- 문자열에 대해 변경을 시도할 경우 새로운 객체를 생성하지 않고 기존문자열을 수정하여 문자열을 변경


# StringBuilder

- mutable 가변클래스 && 단일 스레드에서만 보장

- 문자열에 대해 변경을 시도할 경우 새로운 객체를 생성하지 않고 기존문자열을 수정하여 문자열을 변경


정리하자면, 읽기용이나 공유용도로 문자열을 사용해야 한다면, String 타입을 ...

(단일 문자열 참조일 경우)


문자열 수정을 해야 하면서 멀티 스레드 환경이라면, StringBuffer를 ... 

(동기화 기능 O  -> 멀티 스레드 환경에서 안정성 보장)


문자열 수정을 해야 하면서 싱글 스레드 환경이라면, StringBuffer를 ... 

(동기화 기능 X  -> 싱글 스레드 환경에서 사용 권장)


# String/StringBuffer/StringBuilder 성능비교 포스팅 참조

https://kutar37.tistory.com/51


3개의 성능을 비교해보면 StringBuilder > StringBuffer > String 순으로 StringBuilder가 제일 빠르다.

알고리즘 문제를 푸는 경우에는 StringBuilder를 사용하자!!

StringBuffer/StringBuiler 클래스는 여러가지 문자열 조작을 위한 api를 제공한다.


# StringBuffer/StringBuiler에서 reverse()로 문자열 뒤집기가 가능하다.

StringBuilder aa = new StringBuilder("ABCDE");

System.out.printf("%s\n", aa.reverse());  --> EDCBA

System.out.printf("%s\n", aa); --> EDCBA


# 문자열 비교시 StringBuiler -> String으로 변환해서 해야함!!

Ex) if(input.toString().equals(reverse.toString())


# StringBuiler 사용 예제

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
32
package Blog;
 
public class Main {
    public static void main(String[] args) {
        // 1. 생성
        StringBuilder sb = new StringBuilder();
        
        // 2. 문자열 추가
        sb.append("안녕하세요 ");
        sb.append("오늘은").append(2).append("월 입니다.");
        System.out.println(sb);
        
        // 3. 값 원하는 위치(index)에 삽입.
        sb.insert(6"useStringBuilder!!!");
        System.out.println(sb);
        
        // 4. 삭제
        sb.delete(1113);
        System.out.println(sb);
        
        // 5. 문자열을 역순으로 만들기
        sb.reverse();
        System.out.println(sb);
    }
}
 
/********** 결과 ***************
안녕하세요 오늘은2월 입니다.
안녕하세요 useStringBuilder!!!오늘은2월 입니다.
안녕하세요 useStngBuilder!!!오늘은2월 입니다.
.다니입 월2은늘오!!!redliuBgntSesu 요세하녕안
*/
cs


# 참고사이트

https://limkydev.tistory.com/119

https://hackersstudy.tistory.com/12

https://handcoding.tistory.com/44

https://jsnote.tistory.com/22

posted by 귀염둥이채원 2019. 3. 3. 20:07

자바에서 String to int, int to String 변환하는 방법이다.


# String값을 int형의 값으로 바꾸는 방법

int numInt = Integer.parseInt(numStr);


# int형의 값을 String으로 바꾸는 방법

String numStr2 = String.valueOf(numInt);


1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
    public static void main(String arg[]) throws Exception {
        String numStr = "100";
 
        // String값을 int형의 값으로 바꾸는 방법
        int numInt = Integer.parseInt(numStr);
        System.out.println(numInt);
 
        // int형의 값을 String으로 바꾸는 방법
        String numStr2 = String.valueOf(numInt);
        System.out.println(numStr2);
    }
}
cs


posted by 귀염둥이채원 2019. 2. 28. 20:44

static은 '정적인, 움직이지 않는다'라는 뜻이다.


# static 변수

* static 변수를 “정적 변수”라고도 한다.

* static 키워드를 이용하여 선언한 변수는 해당 클래스의 모든 객체들에 의해 공유된다.

* static으로 선언한 변수는 메모리할당이 한 번만 이루어진다. (메모리 효율적)

* 모든 객체의 공통으로 사용하는 데이터를 관리할때 사용한다.


멤버변수에 static 키워드가 붙으면 인스턴스화를 하지 않고 사용이 가능하다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class B {
    static int count = 0;
    int cnt = 0;
 
    public B() {
        count++;
        cnt++;
        System.out.println("static B : "+count);
        System.out.println("B : "+cnt);
    }
 
    public static void main(String[] args) {
        B b1 = new B();
        B b2 = new B();
        B b3 = new B();
    }
}
cs

결과는 count=3, cnt=1이다.

count는 static 변수라 메모리가 공유되어 있어서 증가가 되지만

cnt는 b1, b2, b3가 각각 새로운 클래스 인스턴스화 되어 메모리 영역이 다르다.


# static 메소드

* static 메소드를 “정적 메소드” 라고도 한다.

* 정적 메소드는 객체가 생성되지 않는 상태에서 호출되는 메소드이다.

* 정적 메소드 안에서는 정적 변수와 지역 변수만 사용할 수 있다.

* 정적 메소드 안에서는 인스턴스 메소드를 호출하지 못한다.

* 정적 메소드는 this 키워드를 사용할 수 없다. this를 참조할 인스턴스가 없기 때문이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class E {
    int e=3;
    static int r =4;
 
    public static void e() {
        System.out.println("hello");
        //e=4;   (e는 인스턴스 변수이므로 클래스 인스턴스화를 해야 사용가능하다)
        new E().e=4;
        r =5//static 변수이므로 사용가능
    }
    public static void main(String[] args) {
        E.e();
    }
}
cs

static 변수는 static 메서드에서 사용가능하지만 

인스턴스 변수는 static 메서드에서 사용 불가능하다.


# static 키워드의 사용범위

1. 모든 인스턴스에 공통적으로 사용해야 할 경우 static을 붙인다.

인스턴스를 생성하면, 서로 독립적이기 때문에 서로 다른 값을 유지하므로 각 인스턴스들이 공통값을 유지하기 위해서는 static을 사용한다.


2. static 키워드가 붙은 멤버변수나 메서드는 인스턴스(객체화)를 생성하지 않아도 사용할 수 있다.

static 변수와, 메서드는, 클래스가 메모리에 올라갈 때 자동으로 생성된다.


3. static이 붙은 메서드에서는 인스턴스 변수(not static)를 사용할 수 없다.


4. 메서드 내에서 인스턴스 변수를 사용하지 않는다면 static을 사용하는 것을 고려한다.

메서드 작업하면서 인스턴스 변수가 필요 하다면 static을 사용할 수 없지만, 인스턴트 변수가 필요 없다면 static을 사용한다. 

왜냐하면 메서드 호출시간이 짧기때문에 효율성이 좋아지기 때문이다.



# 참고사이트

https://mainia.tistory.com/83

https://dev-jangwon.github.io/java/2017/06/26/java-static/

https://includestdio.tistory.com/14

https://clairdelunes.tistory.com/43

posted by 귀염둥이채원 2019. 2. 28. 20:08

자바에서의 final 키워드는 Immutable/Read-only 속성을 선언하는 지시어이다.

final은 해당 entity가 오로지 한 번 할당될 수 있음을 의미이다.

즉 final 필드에 초기값을 저장하면 그 값이 최종값이 되어 수정이 불가능하다.


# final 제어자의 효과

* 클래스: 다른 클래스에서 상속을 하지 못 한다.

* 메소드: 상속 받은 클래스에서 오버라이딩 하지 못한다.

* 클래스 변수: 선언과 동시에 값을 지정하여야하며 이후 수정이 불가하다.

* 인스턴스 변수: 선언과 동시에 초기화하거나 생성자 내에서 값을 지정할 수 있다. 

                      이후에는 수정이 불가하다.

* 지역 변수: 선언과 동시에 초기화하거나 그 이후에 값을 지정할 수 있다. 이후에는 수정이 불가하다.


1. 클래스의 final 멤버 변수

1.1 선언과 함께 정의한 경우

상수이다. 주로 변수명은 모두 대문자로 구성되어야 한다. 아래와 같이 다시 값을 대입하려고 하면 컴파일 에러가 발생한다.

public class Solution {
	final int LIMIT = 10;
	void foo(){
		LIMIT = 11; //Error: cannot assign a value to final variable LIMIT
	}
}

1.2 선언만 하고 정의하지 않은 경우

반드시 constructor내에서 값이 초기화 되어야 한다.

public class Solution {
    final int limit;
    public Solution(final int limit) {
        this.limit = limit;	//OK
    }
    ...
}

constructor외의 메소드에서 값을 초기화하는 것은 안된다.

public class Solution {
    final int limit;
    public Solution(final int limit) {
		setLimit(limit);
    }
    public void setLimit(final int limit) {
        this.limit = limit; //Error: cannot assign a value to final variable LIMIT
    }
    ...
}

2. static final 변수

2.1 선언과 함께 정의한 경우

상수이다. 주로 변수명은 모두 대문자로 구성되어야 한다.

public class Solution {
    final static int LIMIT = 10;

    public static void main(String[] args) {
        System.out.println(Solution.LIMIT);
    }
}

아래와 같이 다시 값을 대입하려고 하면 컴파일 에러가 발생한다.

public class Solution {
    final static int LIMIT = 10;

    public static void main(String[] args) {
        System.out.println(Solution.LIMIT);
        Solution.LIMIT = 11; //Error: cannot assign a value to final variable LIMIT
    }
}

2.2 선언만하고 정의하지 않은 경우

반드시 static block에서 초기화 되어야 햔다.

public class Solution {
    final static int LIMIT;
    
    static {
    	LIMIT = 10;
    }

    public static void main(String[] args) {
        System.out.println(Solution.LIMIT);
    }
}

3. 메소드의 final 파라미터

const와 같은 의미이다. 값을 대입할 수 없다.

public class Solution {
    void tryToChagne(final int count, int length) {
        count = 10;	//Error: cannot assign a value to final variable count
        length = 10; //OK
    }
}

4. final Collection 변수

Collection instance를 다시 정의 할 수는 없다.

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Solution {
    public static void main(String[] args) {
        final List<Integer> list = new ArrayList<>();
        list = new LinkedList<>(); //Error: cannot assign a value to final variable list
    }
}

하지만, 삽입이나 삭제는 가능하다.

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public static void main(String[] args) {
         final List<Integer> list = new ArrayList<>();
         list.add(1);
         list.add(2);
         list.remove(0);
    }
}

5. final 메소드

5.1 일반

final 메소드는 오버라이드를 할 수 없다는 의미이다.

class Parent {
    final void thisIsFinal() {
    }
    void thisIsNotFinal() {
    }
}

public class Solution extends Parent {
    @Override
    void thisIsFinal() { //Error: thisIsFinal() in Solution cannot override thisIsFinal() in Parent
  overridden method is final
    }

    @Override
    void thisIsNotFinal() {	//OK    
    }
}

5.2 final constructor

constructor는 final일수 없다!!!

public class Solution {
    final public Solution() { //Error: modifier final not allowed here
    }
}

6. final 클래스

final class는 상속할 수 없다.

final class Parent {
}

public class Solution extends Parent { //Error: cannot inherit from final Parent
}

7. interface

7.1 final로 선언되지 않은 변수들

interface의 변수의 값을 바꾸려 하면 아래와 같이 final 변수를 바꾸려는 시도이기 때문에 안된다고 한다. 즉, interface의 멤버 변수들은 모두 final이다.

interface Solvable {
    int LIMIT = 10;
}

public class Solution implements Solvable {
    void tryToChange(){
        LIMIT = 1; //Error: cannot assign a value to final variable LIMIT
    }
}

7.2 final로 선언된 메소드 선언

interface의 메소드 선언은 final을 허용하지 않는다.

interface Solvable {
    public final void hey(); //Error: modifier final not allowed here
}

public class Solution implements Solvable {
    public void hey() {
    }
}

# 참고사이트

http://hochulshin.com/java-final-keyword/

https://djkeh.github.io/articles/Why-should-final-member-variables-be-conventionally-static-in-Java-kor/

https://library1008.tistory.com/1

posted by 귀염둥이채원 2019. 2. 28. 19:02

프로그래밍을 하다보면 특정 소스 코드 구간의 시간을 측정해야 하는 경우 생긴다.

알고리즘을 문제를 풀다보면 시간복잡도가 중요하기 때문에 알고리즘에 대한 속도를 측정하는 것이 필요하다.

또는 개발한 프로그램의 성능이 잘 안나오는 경우 어느 부분이 병목인지 확인이 필요할수도 있다.


자바(Java)에서 System 함수인 System.currentTimeMillis() 함수를 이용하면 쉽게할 수 있다.

시작 구간과 끝나는 구간에 각각 해당 함수를 써서 시간을 저장한 후,

두 시간간의 차이를 계산하면 ms 단위의 시간차를 구할 수 있다.


아래의 코드는 특정 부분의 로직에 걸리는 시간을 테스트 할때 사용하면 좋다.


# 샘플 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class TEST {
    public static void main(String arg[]) throws Exception {
        long beforeTime = System.currentTimeMillis();
        long count = 0;
        for (int i = 0; i < 1000000; i++) {
            for (int j = 0; j < 1000000; j++) {
                count++;
            }
        }
        System.out.println("count= " + count);
        long afterTime = System.currentTimeMillis();
        long secDiffTime = (afterTime - beforeTime);
        System.out.println("시간차이(msec) : " + secDiffTime);
    }
}
cs

# 참고 사이트

https://hijuworld.tistory.com/2

http://www.topcredu.com/bbs/board.php?bo_table=LecJava&wr_id=736

posted by 귀염둥이채원 2019. 2. 28. 15:54

# 자바 기본 타입(Primitive)

- 정수타입: byte(1바이트), short(2바이트), char(2바이트), int(4바이트), long(8바이트)

- 실수타입: float(4바이트), double(8바이트)

- 논리타입: Boolean(1바이트)


# 소스코드

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
public class TEST {
    public static void main(String[] args) throws Exception {
        System.out.println("##### byte 타입의 값");
        System.out.println("MIN: " + Byte.MIN_VALUE);
        System.out.println("MAX: " + Byte.MAX_VALUE + "\n");
 
        System.out.println("##### short 타입의 값");
        System.out.println("MIN: " + Short.MIN_VALUE);
        System.out.println("MAX: " + Short.MAX_VALUE + "\n");
 
        System.out.println("##### int 타입의 값");
        System.out.println("MIN: " + Integer.MIN_VALUE);
        System.out.println("MAX: " + Integer.MAX_VALUE + "\n");
 
        System.out.println("##### long 타입의 값");
        System.out.println("MIN: " + Long.MIN_VALUE);
        System.out.println("MAX: " + Long.MAX_VALUE + "\n");
 
        System.out.println("##### float 타입의 값");
        System.out.println("MIN: " + Float.MIN_VALUE);
        System.out.println("MAX: " + Float.MAX_VALUE + "\n");
 
        System.out.println("##### double 타입의 값");
        System.out.println("MIN: " + Double.MIN_VALUE);
        System.out.println("MAX: " + Double.MAX_VALUE + "\n");
    }
}
cs


# 결과

##### byte 타입의 값

MIN: -128

MAX: 127


##### short 타입의 값

MIN: -32768

MAX: 32767


##### int 타입의 값

MIN: -2147483648

MAX: 2147483647


##### long 타입의 값

MIN: -9223372036854775808

MAX: 9223372036854775807


##### float 타입의 값

MIN: 1.4E-45

MAX: 3.4028235E38


##### double 타입의 값

MIN: 4.9E-324

MAX: 1.7976931348623157E308