[Java] 요약 정리

실무에서 사용중인 C#은 코딩테스트 언어에 포함되지않는 경우가 많다.

때문에 배우기도 쉽고 데이터형을 다루는 것도 직관적이고, 입출력도 쉽운 Python을 선택하여 학습하였다.

하지만, 시험 7일 전에 안내된 내용에 Python이 없었다.

적어도 2가지 언어를 준비 해야한다는걸 깨달았고, C#과 비슷한 객체지향 언어인 Java로 다시 학습하고자한다.

 

Java 학습 순서는 코딩테스트를 풀어보면서 느낀것을 바탕으로 아래와 같은 순서로 진행한다.

1. 입출력 하는 방법(시간초과 안걸리는 입출력 방식 중요)

2. 데이터형을 다루는 방법(List, Hash Map 사용법 중요)

3. 알고리즘 구현(DFS, BFS 중요)

4. 그 동안 Python으로 풀었던 문제들을 Java로 다시 풀어보기

---

개발환경 구축

Intellij 무료버전 설치

- 설치링크: https://www.jetbrains.com/ko-kr/idea/download/download-thanks.html?platform=windows&code=IIC 

IntelliJ IDEA를 다운로드해 주셔서 감사합니다!

---

입출력

입출력을 System이나 Scanner로 하는 것보다 BufferedReader,Writer,StringTokenizer를 사용하는것이 더욱 빠르다.

이부분은 단순 암기해야할 부분들이 많다.

 

입력

1. 복잡하게 BufferedReader,BufferedWriter 등 import 에 하나하나 적는 것보다 아래 2줄로 * 전체를 import하는 것으로 퉁치자
   import java.io.*;
   import java.util.*;
2. main() 에 throws IOException 해준다.
3. BufferedReader 입력담당 버퍼 선언
   BufferedReader br = new BufferReader(new InputStreamReader(System.in));
4. 입력받을 변수들은 static 데이터형과 함께 전역변수로 미리 정해주자.
5. main함수 안에서 static으로 선언했던 변수들에 입력값을 넣는다.
   6-1) String일 경우: N = br.readLine();
   6-2) int형일 경우: N = Integer.parse(br.readLine());
   
6. 공백을 통해 한줄로 여러개의 값을 입력하는 경우라면 StringTokenizer를 사용한다.
   br.nextToken()로 공백으로 구분된 값들을 순차적으로 변수에 넣는다
   (리스트인 경우는 for문과 함께사용)
   StringTokenizer st = new StringTokenizer(br.readLine());
   7-1) String일 경우: String a = st.nextToken(); String b = st.nextToken();
   7-2) int형 일 경우: int a = Integer.parseInt(st.nextToken()); int b = Integer.parseInt(st.nextToken());

출력

1. BufferWriter 출력담당 버퍼 선언
   BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
2. bw.write(N); 으로 출력한다.
   String형이 아닐경우 String.valueOf(N) 을 사용하여 String형으로 변환시킨다.
3. bw.flush(); 로 남아있는 문자열을 모두 내보낸다.(필수)
4. bw.close(); 로 버퍼를 닫는다.(필수)
5. 개행이 필요하다면 write(N+'\n') 하던지 bw.newLine(); 해주면된다.

예시.

import java.io.*;
import java.util.*;

public class Main {
    static int N,M;
    static boolean[][] graph;   //사용할 전역 변수를 미리 static으로 선언
    public static void main(String[] args) throws IOException {
        //입력 버퍼 압력받은 값은 String형이므로 숫자로 사용하려면 Integer,parseInt() 해줘야함
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //출력 버퍼
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        N = Integer.parseInt(br.readLine());
        M = Integer.parseInt(br.readLine());

        graph = new boolean[N+1][N+1];  //new와 함께 작성해줘야함

        //M개 만큼 입력받음, 공백을 구분자로 입력 받을 때
        for(int i=0;i<M;i++){   //M만큼 입력 받음
            StringTokenizer st = new StringTokenizer(br.readLine());   //공백 이용을 위해 StringTokenizer 사용
            int a = Integer.parseInt(st.nextToken());   //ex)1 3 첫번째 값 -> 1
            int b = Integer.parseInt(st.nextToken());   //ex)1 3 두번째 값 -> 3
            graph[a][b] = true;
            graph[b][a] = true;
        }
        bw.write(String.valueOf(graph[1][2]));
        bw.flush();
        //bw.newLine();
        bw.close();//스트림을 닫음


    }
}

 

---

데이터형

String

String str = "Hello, World!";
int len = str.length(); //13
char ch = str.charAt(7); // 'W'
String subStr = str.substring(0, 5); // "Hello"
int index = str.indexOf("World"); // 7
String upperCaseStr = str.toUpperCase(); // "HELLO, WORLD!"
String lowerCaseStr = str.toLowerCase(); // "hello, world!"

Array

// 배열 선언 및 초기화
int[] arr = {1, 2, 3, 4, 5};

// 배열 길이
int length = arr.length;

// 배열 요소 접근
int element = arr[index];

// 배열 요소 변경
arr[index] = newValue;

//Arrays.stream(배열).
int max = Arrays.stream(arr).max().getAsInt(); // 최대값: 5
int min = Arrays.stream(arr).min().getAsInt(); // 최소값: 1

int[] intArray = {5, 2, 8, 1, 9};
String strArray = Arrays.toString(intArray); // "[5, 2, 8, 1, 9]"
int[] copyArray = Arrays.copyOf(intArray, 3); // [5, 2, 8]
Arrays.sort(intArray); // [1, 2, 5, 8, 9]
int index = Arrays.binarySearch(intArray, 5); // 2
boolean isEqual = Arrays.equals(intArray, copyArray); // false

 

List

// List 선언 및 초기화
List<Integer> list = new ArrayList<>(); // 또는 LinkedList<>

// 요소 추가
list.add(value);

// 요소 조회
int element = list.get(index);

// 요소 변경
list.set(index, newValue);

// 요소 제거
list.remove(index);

// 리스트 크기
int size = list.size();

ArrayList

// ArrayList 선언 및 초기화
ArrayList<String> arrayList = new ArrayList<>();

// 요소 추가
arrayList.add("Item");

// 요소 조회
String element = arrayList.get(index);

// 요소 변경
arrayList.set(index, newValue);

// 요소 제거
arrayList.remove(index);

// 리스트 크기
int size = arrayList.size();

LinkedList

import java.util.LinkedList;

public class LinkedListCRUD {
    public static void main(String[] args) {
        // LinkedList 생성
        LinkedList<String> linkedList = new LinkedList<>();

        // Create: 요소 추가
        linkedList.add("Apple");
        linkedList.add("Banana");
        linkedList.add("Cherry");

        // Read: 요소 조회
        System.out.println("Read:");
        for (String fruit : linkedList) {
            System.out.println(fruit);
        }

        // Update: 요소 수정
        linkedList.set(1, "Orange"); // 인덱스 1의 요소 수정

        // Read (수정 후):
        System.out.println("\nUpdated:");
        for (String fruit : linkedList) {
            System.out.println(fruit);
        }

        // Delete: 요소 삭제
        linkedList.remove("Apple"); // 값으로 삭제
        linkedList.remove(1);       // 인덱스로 삭제

        // Read (삭제 후):
        System.out.println("\nAfter Deletion:");
        for (String fruit : linkedList) {
            System.out.println(fruit);
        }
    }
}

HashMap

// HashMap 선언 및 초기화
HashMap<String, Integer> hashMap = new HashMap<>();

// 값 추가
hashMap.put("Key", value);

// 값 조회
int value = hashMap.get("Key");

// 값 변경
hashMap.put("Key", newValue);

// 값 제거
hashMap.remove("Key");

// 키 집합 조회
Set<String> keys = hashMap.keySet();

keySet() 메서드를 사용하여 HashMap의 키(key) 순회

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> ages = new HashMap<>();
        ages.put("Alice", 25);
        ages.put("Bob", 30);
        ages.put("Charlie", 28);

        // keySet() 메서드를 사용하여 HashMap의 키(key) 순회
        for (String name : ages.keySet()) {
            int age = ages.get(name);
            System.out.println(name + ": " + age);
        }
    }
}

HashMap의 keySet(). values() 메소드로 key값만 가져오기, value값만 가져오기

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Collection;

public class HashMapKeysValuesExample {
    public static void main(String[] args) {
        HashMap<String, Integer> ages = new HashMap<>();
        ages.put("Alice", 25);
        ages.put("Bob", 30);
        ages.put("Charlie", 28);

        // keys(): 해시맵의 모든 키(key)를 배열로 반환
        String[] keysArray = ages.keySet().toArray(new String[0]);

        System.out.print("Keys: ");
        for (String key : keysArray) {
            System.out.print(key + " ");
        }
        //Keys: [Alice, Bob, Charlie]
        System.out.println();

        // values(): 해시맵의 모든 값(value)을 배열로 반환
        Integer[] valuesArray = ages.values().toArray(new Integer[0]);

        System.out.print("Values: ");
        for (Integer value : valuesArray) {
            System.out.print(value + " ");
        }
        //Values: [25, 30, 28]
        System.out.println();
    }
}

---

형변환

String -> Array

String str = "Hello";
char[] charArray = str.toCharArray();

 

Array -> String (Char[])

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str1 = new String(charArray);
String str2 = String.valueOf(charArray);

Array -> String(String[]) Join 사용

public class ArrayToString {
    public static void main(String[] args) {
        String[] strArray = {"Hello", "World", "Java"};

        // String.join() 메서드를 사용하여 배열을 문자열로 결합
        String result = String.join(" ", strArray); // 빈칸(" ")을 구분자로 사용

        System.out.println(result); // "Hello World Java"
    }
}

import java.io.*;
import java.util.*;
public class Solution{

     public static void main(String []args){
        String[] str= {"C","B","A","E","D","G","F"};
        System.out.println(String.join("",str));
        Arrays.sort(str);
        System.out.println(String.join("",str));
     }
}

Arrays.sort(str) 이후  join으로 String[] -> String 변환

Array - > List

String[] array = {"A", "B", "C"};
List<String> list = Arrays.asList(array);

 

List -> Array

List<String> list = new ArrayList<>();
String[] array = list.toArray(new String[0]); // 또는 list.toArray(new String[list.size()]);

import java.io.*;
import java.util.*;
public class Solution{

     public static void main(String []args){
       
        Integer[] num = {2,4,1,3,5};
        System.out.println(Arrays.toString(num));
        
        Arrays.sort(num);
        System.out.println(Arrays.toString(num));
        
        //Array를 List로 변환해야 Collections.reverse를 사용할 수 있음
        List<Integer> numList = Arrays.asList(num);
        Collections.reverse(numList);
        //List를 다시 Array로 변환
        num = numList.toArray(new Integer[num.length]);
        System.out.println(Arrays.toString(num));
     }
}

 

---

Arrays.stream(Array[]) 메소드들

import java.util.Arrays;

public class ArrayStreamExamples {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 9};

        // max(): 배열 요소 중 최대값 찾기
        int max = Arrays.stream(numbers)
                .max()
                .orElse(0); // 최대값이 없을 경우의 기본값
        System.out.println("Max: " + max);

        // min(): 배열 요소 중 최소값 찾기
        int min = Arrays.stream(numbers)
                .min()
                .orElse(0); // 최소값이 없을 경우의 기본값
        System.out.println("Min: " + min);

        // sum(): 배열 요소들의 합 구하기
        int sum = Arrays.stream(numbers)
                .sum();
        System.out.println("Sum: " + sum);

        // filter()와 count(): 특정 조건을 만족하는 요소들 개수 세기
        long count = Arrays.stream(numbers)
                .filter(num -> num % 2 == 0)
                .count();
        System.out.println("Even numbers count: " + count);
    }
}

---

class Solution {
    public int solution(int n) {
        String str = Integer.toString(n,3);
        String str_reverse = ""; 
        for(int i=str.length()-1; i>=0;i--){
            str_reverse += str.charAt(i);
        }
        n = Integer.parseInt(str_reverse,3);
        
        int answer = n;
        return answer;
    }
}

---

Stack

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        // push(): 스택에 요소 추가
        stack.push(1);
        stack.push(2);
        stack.push(3);

        System.out.println("Stack: " + stack); // [1, 2, 3]

        // pop(): 스택에서 요소 제거하고 반환
        int poppedElement = stack.pop(); // 3이 제거됨
        System.out.println("Popped: " + poppedElement);
        System.out.println("Stack: " + stack); // [1, 2]

        // peek(): 스택의 맨 위 요소 반환 (제거하지 않음)
        int topElement = stack.peek(); // 2 반환
        System.out.println("Top: " + topElement);
        System.out.println("Stack: " + stack); // [1, 2]

        // empty(): 스택이 비어있는지 확인
        boolean isEmpty = stack.empty(); // false
        System.out.println("Is Empty: " + isEmpty);

        // search(): 요소의 위치(인덱스) 검색 (존재하지 않을 경우 -1 반환)
        int position = stack.search(1); // 1이 있는 위치는 2번째
        System.out.println("Position of 1: " + position);
        
        //contians(): 값을 포함하는지
        boolean isContain = stack.contains(1);
        
        //size(): 스텍 크기 체크
        int stack_size = stack.size();
        
        //clear(): 스텍 비우기
        stack.clear();
    }
}

 

Queue

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();

        // add(): 큐에 요소 추가
        queue.add("Apple");
        queue.add("Banana");
        queue.add("Cherry");

        System.out.println("Queue: " + queue); // [Apple, Banana, Cherry]

        // remove(): 큐에서 요소 제거하고 반환
        String removedElement = queue.remove(); // Apple이 제거됨
        System.out.println("Removed: " + removedElement);
        System.out.println("Queue: " + queue); // [Banana, Cherry]

        // peek(): 큐의 맨 앞 요소 반환 (제거하지 않음)
        String frontElement = queue.peek(); // Banana 반환
        System.out.println("Front: " + frontElement);
        System.out.println("Queue: " + queue); // [Banana, Cherry]

        // poll(): 큐에서 요소 제거하고 반환 (큐가 비어있으면 null 반환)
        String polledElement = queue.poll(); // Banana 제거됨
        System.out.println("Polled: " + polledElement);
        System.out.println("Queue: " + queue); // [Cherry]

        // isEmpty(): 큐가 비어있는지 확인
        boolean isEmpty = queue.isEmpty(); // false
        System.out.println("Is Empty: " + isEmpty);

        // size(): 큐의 요소 개수 반환
        int size = queue.size(); // 1
        System.out.println("Size: " + size);
    }
}