코딩테스트를 위한 자바 주요 문법 정리

향상된 for 루프문(String, int타입 배열을 출력하는코드) 

 

String[] str = { "John", "Doe", "30" }를 System.out.print(str)을 하면 객체의 메모리 주소가 리턴된다

왜냐하면 String 타입 객체이기 때문이다. 아래처럼 향상된 for루프를 사용하면 이를 해결할 수 있다

 

예시

String[] info = { "John", "Doe", "30" };

// 위에서 정의한 배열 info의 각 요소(element)를 하나씩 가져와서 반복합니다.
// 배열의 크기만큼 자동으로 반복합니다.
for (String element : info) {
    // 각 요소를 순회할 때마다 실행되는 코드 블록입니다.

    // 현재 요소(element)를 출력하고 뒤에 공백(" ")을 추가합니다.
    System.out.print(element + " ");
}

 

int[] 배열의 경우는 아래처럼 작성하자

public class Main {
    public static void main(String[] args) {
        int[] numbers = { 1, 2, 3, 4, 5 };
        for (int number : numbers) {
            System.out.print(number + " ");
        }
    }
}

 

String[], int[] 배열을 ArrayList에 넣어야하는 상황이라면

asList를 사용해야한다

ArrayList를 선언할 때 asList를 사용하여 String, int 배열을 삽입한다

 

예시

String data = "apple,banana,orange,grape";

ArrayList<String> fruitsList = new ArrayList<>(Arrays.asList(data));

System.out.print(fruisList); 
// [apple, banana, orange, grape] 출력

 

ArrayList

동적 배열을 생성하기 위한 메서드이다

 

선언 방식

ArrayList<타입> 변수명 = new ArrayList<>();

 

선언 예시

ArrayList<Integer> integers1 = new ArrayList<Integer>(); // 타입 지정
ArrayList<Integer> integers2 = new ArrayList<>(); // 타입 생략 가능
ArrayList<Integer> integers3 = new ArrayList<>(10); // 초기 용량(Capacity) 설정
ArrayList<Integer> integers4 = new ArrayList<>(integers1); // 다른 Collection값으로 초기화
ArrayList<Integer> integers5 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5)); // Arrays.asList() 다른 리스트를 추가할 수 있다
ArrayList<ArrayList<String>> st = new ArrayList<>(); // 이중 배열 선언

 

주요 메서드

 

add : 리스트에 값을 추가하는 메서드

1. add(value) : 리스트의 끝에 값을 추가한다

ArrayList<String> list = new ArrayList<>();
list.add("사과");
list.add("바나나");
list.add("오렌지");
// list = ["사과", "바나나", "오렌지"]

2. add(index, value) : 지정한 인덱스에 값을 추가한다

ArrayList<String> list = new ArrayList<>();
list.add("사과");
list.add(1, "바나나"); // "바나나"를 인덱스 1에 삽입하고, "오렌지"는 인덱스 2로 이동합니다.

 

get : 인덱스에 해당하는 값을 리턴하는 메서드. ArrayList의 경우 array[i]가 아닌 get(i)로 값을 확인할 수 있다

1. get(index) : 인덱스에 해당하는 값을 리턴한다

ArrayList<String> list = new ArrayList<>();
list.add("사과");
list.add("바나나");
String 과일 = list.get(1); // "바나나"를 반환

 

set : 인덱스에 해당하는 값을 교체하는 메서드

1. set(index, value)

ArrayList<String> list = new ArrayList<>();
list.add("사과");
list.add("바나나");
list.set(0, "오렌지"); // "사과"를 "오렌지"로 대체

size : 리스트의 크기를 리턴하는 메서드

1. size()

ArrayList<String> list = new ArrayList<>();
list.add("사과");
list.add("바나나");
int n = list.size(); // 2를 반환

 

 

isEmpty : 리스트가 비어있는지 리턴하는 메서드

1. isEmpty()

ArrayList<String> list = new ArrayList<>();
boolean 비어있음 = list.isEmpty(); // true를 반환

 

contains : 해당 단어가 존재하는지 true/false를 리턴하는 메서드

1. 리스트.contains(문자열)

ArrayList<String> list = new ArrayList<>();
list.add("사과");
list.add("바나나");
boolean 사과포함 = list.contains("사과"); // true를 반환
boolean 포도포함 = list.contains("포도"); // false를 반환

 

sort : 배열을 정렬한다

1. Arrays.sort(배열)

import java.util.Arrays;

class Solution {
    public boolean solution(String[] phone_book) {
        boolean answer = true;
        int n = phone_book.length; // python_book의 리스트 원소 개수
        Arrays.sort(phone_book);
        System.out.print(Arrays.toString(phone_book));

        return answer;
    }
}

 

 

toString

객체 정보를 문자열로 표현하는 메서드이다

java.Object 클래스에 정의되어 있음 → import 필요없음

 

선언 예시

String str = "ABCD";
System.out.print(str.toString());
// 출력 : ABCD

 

Arrays.toStirng()

int, char 형 배열을 String타입 문자열로 변환해주는 메서드

배열의 값을 확인하기 위해 사용한다

double[] values = {1.0, 1.1, 1.2};

System.out.println(values.toString()); // 이렇게 하면 [D@46a49e6 같은 객체 정보가 출력된다

System.out.println(Arrays.toString(values)); // 이렇게 하면 [1.0, 1.1, 1.2] 이 출력

 

Split

문자열을 특정 문자를 기준으로 나누는 메서드

 

선언 방식

문자열.split(특정 문자)

 

예시

String data = "John-Doe-30";
String[] info = data.split("-");

for (String element : info) {
    System.out.print(element + " ");
}
// 출력 : John Doe 30

 

 

split한 데이터를 arrayList에 넣고 싶다면?

 

ArrayList 선언 시 데이터를 추가하면 된다

split한 fruitsArray는 String타입 문자열이고, ArrayList와 다른 자료구조이므로 asList를 사용해야 한다

 

String data = "apple,banana,orange,grape";

String[] fruitsArray = data.split(",");

ArrayList<String> fruitsList = new ArrayList<>(Arrays.asList(fruitsArray));

 

String 핵심 메서드

 

valueOf : String타입이 아닌 문자, 문자열을 String 타입으로 변환하기위해 사용한다

 

valueOf가 필요한 이유 : 아래처럼 코드를 작성하면 에러가 발생한다

String res = "";
for(i=0;i<5;i++){
	res+=(char)i;
}

위와 같이 문자열을 추가하면 오류가 발생한다. 왜냐하면 char로 타입 변환 시 아스키 코드 값을 리턴하기 때문이다. 따라서 String.valueOf를 사용해야 한다

String res = "";
for(int i=0;i<5;i++){
	res+=String.valueOf(i);
}
System.out.print(res); // 01234 출력

 

reverse : 문자열을 뒤집으려면 reverse를 사용하면 된다. reverse는 StringBuilder 클래스 내에 존재한다

import java.lang.StringBuilder;

res = "230010203";
StringBuilder sb = new StringBuilder(res);
sb.reverse();
return sb.toString();

// 출력 302010032

 

charAt(index) : String 문자열의 경우 charAt으로 값을 확인해야한다

String tmp = "KAKAO";
char res = tmp.charAt(0);
// res에는 K가 저장됨

 

length() : String타입 배열은 길이를 확인하기 위해 length()를 사용한다

String msg = "KAKAO";
int num = msg.length();

 

parseInt : String타입 문자열을 int형으로 변환할 때 사용한다

String str = "123";
int num = Integer.parseInt(str);
System.out.println(num); // 출력 : 123

long형으로 변환하고 싶다 → parseLong

String numberString = "123456789";
long parsedNumber = Long.parseLong(numberString);
System.out.println("Parsed number: " + parsedNumber);

 

Map(해시테이블)

리스트나 배열처럼 순차적으로(sequential) 해당 요소 값을 구하지 않고 key를 통해 value를 얻는다

 key는 중복 허용 X

 value는 중복 허용 O

 

선언 방식

Hashmap <객체 타입, 객체 타입> 변수명 = new Hashmap<객체 타입, 객체 타입>();

예시

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

hashMap.put("Alice", 25);
hashMap.put("Bob", 30);
hashMap.put("John", 22);

 

LinkedHashMap

 

Map은 순서를 보장하지 않는 반면 LinkedHashMap은 순서를 보장한다

키를 기준으로 순서가 결정된다

LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();

 

주요 메서드

 

put : 데이터 추가

HashMap<String, String> map = new HashMap<String, String>();
map.put("people", "사람");
map.put("baseball", "야구");

 

get : 키를 통해 값 조회

System.out.println(map.get("people"));
// 출력 : 사람

 

 

remove : 데이터 삭제

System.out.println(map.remove("people"));

 

keySet() : Map에 있는 모든 키를 반환. 이 때 Set을 통해 반환한다

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

public class Main {
    public static void main(String[] args) {
        // HashMap 생성
        Map<String, Integer> hashMap = new HashMap<>();

        // 데이터 추가
        hashMap.put("Alice", 25);
        hashMap.put("Bob", 30);
        hashMap.put("John", 22);

        // keySet을 통해 Set에 키를 저장
        Set<String> keySet = hashMap.keySet();

        // 출력
        for (String key : keySet) {
            System.out.println("Key: " + key);
        }
    }
}

// 출력
Key: Alice
Key: Bob
Key: John

 

values() : Map에 있는 모든 value를 반환. 이 때 Collection으로 반환한다

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

public class Main {
    public static void main(String[] args) {
        // HashMap 생성
        Map<String, Integer> hashMap = new HashMap<>();

        // 데이터 추가
        hashMap.put("Alice", 25);
        hashMap.put("Bob", 30);
        hashMap.put("John", 22);

        // Collection에 value를 저장
        Collection<Integer> values = hashMap.values();

        // 출력
        for (Integer value : values) {
            System.out.println("Value: " + value);
        }
    }
}
// 출력
Value: 25
Value: 30
Value: 22

 

기타 메서드

containsKey(Object key): 지정된 키가 Map에 존재하는지 확인

containsValue(Object value): 지정된 값이 Map에 존재하는지 확인

isEmpty(): Map이 비어있는지 확인

size(): Map에 저장된 요소의 개수를 반환

 

Set(중복 불가 자료구조)

순서가 보장되지 않는 자료구조. 중복을 허용하지 않는다는 점을 활용할 수 있다

 

선언 방식

HashSet<객체 타입> hashSet = new HashSet<>();

 

주요 메서드

 

add(E e) : 주어진 원소를 HashSet에 추가한다. 이미 해당 원소가 HashSet에 존재하는 경우 추가되지 않고 false를 반환합니다. 추가에 성공하면 true를 반환합니다.

HashSet<String> hashSet = new HashSet<>();

 // HashSet에 원소 추가
 System.out.println("HashSet에 원소 추가...");
 System.out.println("추가 'Apple': " + hashSet.add("Apple")); // true
 System.out.println("추가 'Banana': " + hashSet.add("Banana")); // true
 System.out.println("추가 'Orange': " + hashSet.add("Orange")); // true
 System.out.println("중복 추가 'Apple' 다시 시도: " + hashSet.add("Apple")); // false (중복)

 

remove(Object o) : 주어진 원소를 HashSet에서 제거한다. 원소가 제거되면 true를 반환하고, 해당 원소가 HashSet에 없어서 제거에 실패하면 false를 반환

// HashSet에서 원소 제거
System.out.println("\nHashSet에서 원소 제거...");
System.out.println("제거 'Banana': " + hashSet.remove("Banana")); // true
System.out.println("제거 'Grape': " + hashSet.remove("Grape")); // false (존재하지 않음)

size(): HashSet에 저장된 원소의 개수를 반환

// HashSet 크기
System.out.println("\nHashSet 크기: " + hashSet.size()); // 3

 

contains(Object o): 주어진 원소가 HashSet에 존재하는지 확인한다. 원소가 존재하면true를 반환하고, 그렇지 않으면 false를 반환

// HashSet에 원소가 존재하는지 확인
System.out.println("\nHashSet에 원소 존재 여부 확인...");
System.out.println("포함 'Apple': " + hashSet.contains("Apple")); // true
System.out.println("포함 'Grape': " + hashSet.contains("Grape")); // false

isEmpty() : HashSet이 비어있는지 확인한다. 비어있으면 true를 반환하고, 원소가 하나 이상 있으면false를 반환

// HashSet가 비어있는지 확인
System.out.println("\nHashSet가 비어있는지 확인...");
System.out.println("HashSet이 비어있습니까? " + hashSet.isEmpty()); // false

clear() : HashSet의 모든 원소를 제거하여 비운다

// HashSet 비우기
System.out.println("\nHashSet 비우기...");
hashSet.clear();
System.out.println("비우기 후 HashSet이 비어있습니까? " + hashSet.isEmpty()); // true

Iterator<E> iterator() : HashSet의 원소들을 순회하는데 사용되는 반복자(Iterator)를 반환한다. 반복자를 사용하여HashSet의 원소들을 순회할 수 있다.

// Iterator를 사용하여 HashSet 순회
// 원소 다시 추가
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Orange");

System.out.println("\nIterator를 사용하여 HashSet 순회...");
Iterator<String> iterator = hashSet.iterator();
while (iterator.hasNext()) {
	System.out.println(iterator.next());
}

 

PriorityQueue(우선순위큐)

데이터가 일정한 우선순위를 갖고 출력되는 자료구조. 오름차순으로 구현된다

 

선언 방식

PriorityQueue<Integer> heap = new PriorityQueue<>();

 

기본적으로 우선순위는 오름차순으로 구현된다. 내림차순으로 하기 위해선 다음 Comparator 라이브러리를 사용하여 객체를 생성하면 된다

import java.util.PriorityQueue;
import java.util.Comparator;

PriorityQueue<Integer> heap = new PriorityQueue<>(Comparator.reverseOrder());
// 8 5 3 2 1 순서로 우선순위큐가 구현

 

주요 메서드

 

add : 우선순위큐에 값을 추가한다. 큐가 꽉차면 에러발생

PriorityQueue<Integer> heap = new PriorityQueue<>();
heap.add(5);

offer : add와 동일. 큐가 꽉차면 false 리턴

 

poll : 가장 우선순위가 높은 값을 삭제하고 값을 반환. 큐가 비어있을 경우 null 반환

int tmp = heap.poll();

 

peek : 가장 우선순위가 높은 값을 반환. 큐가 비어있을 경우 null 반환

int tmp = heap.peek(); // peek는 poll과 달리 heap의 데이터를 삭제하지 않는다

 

size : 우선순위큐의 요수 개수 반환

 

isEmpty : 큐가 비어있는지 확인

while (!heaq.isEmpty()) {
	System.out.println(heaq.poll());
}

 

 

Iterator

iterator는 반복자라는 의미를 가진다. iterator는

 

컬렉션 프레임워크의 출력을 위해 사용한다

컬렉션 프레임워크는 Set, Map, List, Queue 등을 의미한다

즉, iterator를 쓰는 이유는 위의 자료구조를 사용하며 결과를 확인하기 위해 사용한다

 

선언 방식

Ieterator <데이터타입> iterator명 = 컬렉션.iterator();

 

선언 예시

ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");

Iterator<String> iterList = list.iterator();

 

주요 메서드

 

iterator의 주요 메서드는 총 세가지

 

hasNext() : iterator 내부에 다음 값이 들어있는지 확인. 들었으면 true, 그렇지 않으면 false

next() : iterator 의 다음 값을 가져오기

import java.util.ArrayList;
import java.util.Iterator;

public class IteratorExample {
    public static void main(String[] args) {
        // ArrayList에 요소 추가
        ArrayList<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        fruits.add("Grapes");

        // Iterator를 사용하여 요소들 순회
        Iterator<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
        }
    }
}

 

remove : iterator 값을 제거. next를 수행한 이후 실행해야 에러가 없다

import java.util.ArrayList;
import java.util.Iterator;

public class RemoveExample {
    public static void main(String[] args) {
        // ArrayList에 요소 추가
        ArrayList<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        fruits.add("Grapes");

        // Iterator를 사용하여 요소들 순회
        Iterator<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            if (fruit.equals("Banana")) {
                iterator.remove(); // 현재 가리키고 있는 "Banana" 요소를 삭제
            }
        }

        // 삭제된 요소를 제외하고 남은 요소 출력
        System.out.println(fruits); // 출력: [Apple, Orange, Grapes]
    }
}