[Java] 코딩테스트 기초 문법

 

1. 라이브러리

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

 

 

2. Arrays 배열

// 1. 선언

// 초깃값을 넣어서 선언한다.
int arr[] = {1,2,3,4,5,6,7};

// 배열의 크기를 지정하여 선언한다.
int[] arr = new int [10];

// 2. 정렬

// 오름차순으로 정렬
Arrays.sort(arr);

// 내림차순으로 정렬
Arrays.sort(arr, Collections.reverseOrder());

// 일부만 정렬
Arrays.sort(arr, 시작 인덱스값, 마지막 인덱스값);

// 오름차순으로 정렬한 뒤 binary search로 특정 값 찾기
Arrays.binarySearch(arr, 찾을값);

// binary search에 옵션 주기
// Arrays.binarySearch(배열명, 시작 인덱스, 끝 인덱스, 찾을 값)
int[] arr = {1, 3, 5, 7, 9};
int index = Arrays.binarySearch(arr, 1, 4, 7);
System.out.println("인덱스: " + index); // 출력: 인덱스: 3


// 3. Arraylist로 변환하기
List<Integer> list = Arrays.asList(arr);

// 4. 배열의 특정 범위 자르기
int cut[] = Arrays.copyOfRange(arr, 시작 인덱스값, 마지막 인덱스값);

// 5. 배열 복사하기
int[] newArr = Arrays.copyOf(arr, 3);
System.out.println(Arrays.toString(newArr)); // 출력: [1, 2, 3]

// 6. 배열을 특정 값으로 채우기
int[] fillArr = Arrays.fill(arr, 0);

// 7. 배열끼리의 비교
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2);
System.out.println("두 배열이 같은가? " + isEqual); // 출력: 두 배열이 같은가? true

 

 

3. ArrayList 배열 리스트

-> 크기를 동적으로 조절할 수 있는 배열 기반의 리스트 구현체

// 선언
// ArrayList<타입> list[] = new ArrayList<>(초깃값);
ArrayList<Integer> list[] = new ArrayList<>();

// 1. 리스트에 요소를 추가한다.
list.add(값);

// 2. 지정한 인덱스의 값을 가져온다.
list.add(인덱스값);

// 3. 지정한 인덱스의 요소를 수정한다.
list.set(인덱스, 값);
list.add(1);
list.add(2);
list.add(3);
list.set(1, 10);
System.out.println(list); // 출력: [1, 10, 3]

// 4. 지정한 인덱스의 요소를 제거한다.
list.remove(1);
System.out.println(list); // 출력: [1, 3]

// 5. 리스트의 길이(요소의 개수) 를 반환한다.
list.size();

// 6. 리스트가 비어있는지 여부를 반환한다.
list.isEmpty(); // 출력: false

// 7. 리스트가 지정된 요소를 포함하고 있는지 여부를 반환한다.
boolean isContains = list.contains(1);
System.out.println(isContains); // 출력 : true

// 8. 리스트에서 지정된 요소의 인덱스를 반환한다. 여러개일 경우 첫 번째 인덱스만 반환한다.
// 만일 포함하고 있지 않다면, -1 을 리턴한다.
list.indexOf(1);

// 9. 지정된 컬렉션의 모든 요소를 리스트에 추가한다.
ArrayList<Integer> list2 = {6,7,8};
list.addAll(list2);

// 10. 리스트의 모든 요소를 제거한다.
list.clear();

// 11. 컬렉션의 요소를 순회하기 위한 iterator 메서드
// boolean hasNext() 는 다음 요소가 있는지의 여부를 확인하며, 정방향으로 순회할 때 사용한다.
// boolean hasPrevious() 는 이전 요소가 있는지의 여부를 확인하며, 리스트를 역방향으로 순회할 때 사용한다.
// next()는 다음 요소를 반환한다.
// previous() 는 이전 요소를 반환한다.

ArrayList<String> strList = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("orange");

Iterator<String> iterator = strList.iterator();
// 정방향 순회
while(iterator.hasNext()) {
	String fruit = iterator.next();;
    System.out.println(fruit);
}
// 역방향 순회
while(iterator.hasPrevious()) {
	String fruit = iterator.previous();;
    System.out.println(fruit);
}

 

 

 

4. Stream API

1. filter(Predicate<? super T> predicate): 주어진 조건을 만족하는 요소들로 구성된 새로운 Stream을 반환합니다.
2. map(Function<? super T, ? extends R> mapper): 각 요소에 지정된 함수를 적용하여 새로운 값을 생성하는 Stream을 반환합니다.
3. flatMap(Function<? super T, ? extends Stream<? extends R>> mapper): 각 요소에 대해 스트림을 매핑하고, 각 스트림의 요소를 하나의 스트림으로 연결하여 새로운 Stream을 반환합니다.
4. sorted(): 요소를 자연 순서로 정렬한 새로운 Stream을 반환합니다.
5. distinct(): 중복을 제거한 새로운 Stream을 반환합니다.
6. forEach(Consumer<? super T> action): 각 요소에 대해 지정된 작업을 수행합니다.
7. collect(Collector<? super T, A, R> collector): Stream의 요소를 수집하여 지정된 컬렉터에 따라 결과를 생성합니다.
8. count() : 스트림에 있는 요소의 개수를 반환하며, 중개 오퍼레이션을 통해 가공된 값의 개수를 반환할 수 있습니다.

// 최종형을 Set으로 변환하고 싶다면 Collectors.toSet()
// List로 변환하고 싶다면 Collectors.toList()
// Arrays는 toArray()
// Stream 요소를 1개의 String 객체로 변환해주고 싶다면 Collectors.joining() 을 사용한다.

// 1. filter(Predicate<? super T> predicate)
// 주어진 조건을 만족하는 요소들로 구성된 새로운 Stream을 반환한다.
// 예를 들어, 아래 예시는 짝수만 반환한다.
List<Integer> numbers = Arrays.asList(1,2,3,4,5);
List<Integer> evenNumbers = numbers.stream()
								   .filter(n -> n%2 == 0)
                                   .collect(Collectors.toList());
System.out.println(evenNumbers); // 출력: [2, 4]

// 2. map(Function<? super T, ? extends R> mapper)
// 각 요소에 지정된 함수를 적용하여 새로운 값을 생성하는 Stream을 반환한다.
List<String> names = Arrays.asList("apple", "banana", "orange");
List<Integer> nameLengths = names.stream()
								 .map(s -> s.length())
                                 .collect(Collectors.toList());
                                 System.out.println(nameLengths); // 출력: [5, 6, 6]
                                 
// 3. flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
// 각 요소에 대해 스트림을 매핑하고, 각 스트림의 요소를 하나의 스트림으로 연결하여 새로운 Stream을 반환한다.
List<List<Integer>> numbers = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4), Arrays.asList(5, 6));
List<Integer> flattenedList = numbers.stream()
                                    .flatMap(List::stream)
                                    .collect(Collectors.toList());
System.out.println(flattenedList); // 출력: [1, 2, 3, 4, 5, 6]

// 4. sorted()
// 요소를 자연 순서로 정렬한 새로운 Stream을 반환한다.
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6);
List<Integer> sortedNumbers = numbers.stream()
                                     .sorted() // 역순은 Comparator.reverseOeder()를 추가한다.
                                     .collect(Collectors.toList());
System.out.println(sortedNumbers); // 출력: [1, 1, 2, 3, 4, 5, 6, 9]

// 5. distinct()
// 중복을 제거한 새로운 Stream을 반환한다.
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4);
List<Integer> result = numbers.stream()
							  .distinct();
                              .collect(Collectors.toList());
System.out.println(distinctNumbers); // 출력: [1, 2, 3, 4]

// 6. forEach(Consumer<? super T> action)
// 각 요소에 대해 지정된 작업을 수행한다.
List<String> names = Arrays.asList("apple", "banana", "orange");
names.stream().forEach(System.out::println);
// 출력:
// apple
// banana
// orange

// 7. collect(Collector<? super T, A, R> collector)
// Stream의 요소를 수집하여 지정된 컬렉터에 따라 결과를 생성한다.
// 예를 들어, names 리스트의 각 문자열을 결합하여 하나의 문자열로 만들고, 각 문자열 사이에 구분자(", ")를 추가하고, 문자열의 앞뒤에 접두사("[")와 접미사("]")를 추가하여 최종 문자열을 생성한다.
List<String> names = Arrays.asList("apple", "banana", "orange");
String result = names.stream()
                    .collect(Collectors.joining(", ", "[", "]"));
System.out.println(result); // 출력: [apple, banana, orange]

// 8. count()
// 스트림에 있는 요소의 개수를 반환한다.
// 중개 오퍼레이션을 통해 가공된 값의 개수를 반환할 수 있다.
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4);
int result = numbers.stream()
					.filter(s->s.equals(4))
                    .count(); 
System.out.println(result); // 출력 : 4

 

 

5. String

1. length(): 문자열의 길이를 반환합니다.
2. charAt(int index): 지정된 인덱스에 있는 문자를 반환합니다.
3. substring(int beginIndex): 지정된 시작 인덱스부터 끝까지의 부분 문자열을 반환합니다.
4. substring(int beginIndex, int endIndex): 지정된 시작 인덱스부터 끝 인덱스 전까지의 부분 문자열을 반환합니다.
5. equals(Object anObject): 문자열이 주어진 객체나 문자열과 동일한지 여부를 반환합니다.
6. equalsIgnoreCase(String anotherString): 대소문자를 무시하고 두 문자열이 동일한지 여부를 반환합니다.
7. indexOf(int ch): 지정된 문자 또는 문자의 인덱스를 반환합니다.
8. indexOf(int ch, int fromIndex): 지정된 문자 또는 문자의 인덱스를 반환합니다. 시작 위치를 정할 수 있습니다.
9. indexOf(String str): 지정된 문자열이나 문자열의 인덱스를 반환합니다.
10. indexOf(String str, int fromIndex): 지정된 문자열이나 문자열의 인덱스를 반환합니다. 시작 위치를 정할 수 있습니다.
11. startsWith(String prefix): 지정된 접두사로 시작하는지 여부를 반환합니다.
12. endsWith(String suffix): 지정된 접미사로 끝나는지 여부를 반환합니다.
13. toUpperCase(): 문자열의 모든 문자를 대문자로 변환한 새로운 문자열을 반환합니다.
14. toLowerCase(): 문자열의 모든 문자를 소문자로 변환한 새로운 문자열을 반환합니다.
15. trim(): 문자열의 앞뒤 공백을 제거한 새로운 문자열을 반환합니다.
16. splite(String regex): 지정된 구분자를 기준으로 문자열을 분할하여 배열로 반환합니다.
17. substring(int beginIndex, int endIndex): 문자열의 일부분을 추출하여 새로운 문자열을 생성합니다.

// 1. length(): 문자열의 길이를 반환한다.
String str = "Hello, world!";
int length = str.length(); // length에는 13이 저장된다.

// 2. charAt(int index): 지정된 인덱스에 있는 문자를 반환한다.
String str = "Hello, world!";
char ch = str.charAt(7); // ch에는 'w'가 저장된다.

// 3. substring(int beginIndex): 지정된 시작 인덱스부터 끝까지의 부분 문자열을 반환한다.
String str = "Hello, world!";
String substring = str.substring(7); // substring에는 "world!"가 저장된다.

// 4.substring(int beginIndex, int endIndex): 지정된 시작 인덱스부터 끝 인덱스 전까지의 부분 문자열을 반환한다.
String str = "Hello, world!";
String substring = str.substring(7, 12); // substring에는 "world"가 저장된다.

// 5. equals(Object anObject): 문자열이 주어진 객체나 문자열과 동일한지 여부를 반환한다.
String str1 = "hello";
String str2 = "hello";
boolean isEqual = str1.equals(str2); // isEqual에는 true가 저장된다.

// 6. equalsIgnoreCase(String anotherString): 대소문자를 무시하고 두 문자열이 동일한지 여부를 반환한다.
String str1 = "hello";
String str2 = "HELLO";
boolean isEqual = str1.equalsIgnoreCase(str2); // isEqual에는 true가 저장된다.

// 7. indexOf(int ch): 지정된 문자 또는 문자의 인덱스를 반환한다. 없을 경우 -1을 반환한다.
String str = "Hello, world!";
int index = str.indexOf('o'); // index에는 4가 저장된다.

// 8. indexOf(int ch, int fromIndex): 지정된 문자 또는 문자의 인덱스를 반환한다. 시작 위치를 정할 수 있다.
String str = "Hello, world!";
int index = str.indexOf('o', 5); // index에는 8이 저장된다.

// 9. indexOf(String str): 지정된 문자열이나 문자열의 인덱스를 반환한다.
String str = "Hello, world!";
int index = str.indexOf("world"); // index에는 7이 저장된다.

// 10. indexOf(String str, int fromIndex): 지정된 문자열이나 문자열의 인덱스를 반환한다. 시작 위치를 정할 수 있다.
String str = "Hello, world!";
int index = str.indexOf("world", 5); // index에는 7이 저장된다.

// 11. startsWith(String prefix): 지정된 접두사로 시작하는지 여부를 반환한다.
String str = "Hello, world!";
boolean startsWith = str.startsWith("Hello"); // startsWith에는 true가 저장된다.

// 12. endsWith(String suffix): 지정된 접미사로 끝나는지 여부를 반환한다.
String str = "Hello, world!";
boolean endsWith = str.endsWith("world!"); // endsWith에는 true가 저장된다.

// 13. toUpperCase(): 문자열의 모든 문자를 대문자로 변환한 새로운 문자열을 반환한다.
String str = "Hello, world!";
String upperCaseStr = str.toUpperCase(); // upperCaseStr에는 "HELLO, WORLD!"가 저장된다.

// 14. toLowerCase(): 문자열의 모든 문자를 소문자로 변환한 새로운 문자열을 반환한다.
String str = "Hello, world!";
String lowerCaseStr = str.toLowerCase(); // lowerCaseStr에는 "hello, world!"가 저장된다.

// 15. trim(): 문자열의 앞뒤 공백을 제거한 새로운 문자열을 반환한다.
String str = "   Hello, world!   ";
String trimmedStr = str.trim(); // trimmedStr에는 "Hello, world!"가 저장된다.

// 16. split(String regex): 지정된 구분자를 기준으로 문자열을 분할하여 배열로 반환한다.
String str = "apple,banana,orange";
String[] fruits = str.split(",");
// fruits 배열에는 ["apple", "banana", "orange"]가 저장된다.


// 17. substring(int beginIndex, int endIndex): 문자열의 일부분을 추출하여 새로운 문자열을 생성한다.
String str = "Hello, world!";
String substr = str.substring(7, 12); // substr에는 "world"가 저장된다.

 

6. HashMap

// 1. 선언
HashMap<String, Intger> hash =  new HashMap<>();

// 2. put(K key, V value): 지정된 키와 값을 맵에 추가한다.
HashMap<String, Integer> map = new HashMap<>();
map.put("apple", 3);
map.put("banana", 5);

// 3. get(Object key): 지정된 키에 매핑된 값을 반환한다.
int value = map.get("apple"); // value에는 3이 저장된다.

// 4. containsKey(Object key): 맵에 지정된 키가 포함되어 있는지 여부를 반환한다.
boolean containsKey = map.containsKey("apple"); // containsKey에는 true가 저장된다.

// 5. containsValue(Object value): 맵에 지정된 값이 포함되어 있는지 여부를 반환한다.
boolean containsValue = map.containsValue(5); // containsValue에는 true가 저장된다.

// 6. remove(Object key): 맵에서 지정된 키와 해당 값에 매핑된 항목을 제거한다.
map.remove("apple"); // "apple" 키에 해당하는 항목을 제거한다.

// 7. isEmpty(): 맵이 비어 있는지 여부를 반환한다.
boolean isEmpty = map.isEmpty(); // isEmpty에는 false가 저장된다.

// 8. size(): 맵의 크기(항목 수)를 반환한다.
int size = map.size(); // size에는 2가 저장된다.

// 9. keySet(): 맵의 모든 키를 포함하는 Set 뷰를 반환한다.
Set<String> keys = map.keySet(); // keys에는 ["apple", "banana"]가 저장된다.

// 10. values(): 맵의 모든 값들을 포함하는 Collection 뷰를 반환한다.
Collection<Integer> values = map.values(); // values에는 [3, 5]가 저장된다.

// 11. entrySet(): 맵의 모든 키-값 쌍을 포함하는 Set 뷰를 반환한다.
Set<Map.Entry<String, Integer>> entrySet = map.entrySet(); // entrySet에는 ["apple=3", "banana=5"]가 저장된다.

// 12. clear(): 맵의 모든 항목을 제거하여 맵을 비운다.
map.clear(); 

// 13. getOrDefault(Object key, V defaultValue) HashMap에서 지정된 키에 해당하는 값이 존재할 경우 해당 값을 반환하고, 그렇지 않은 경우에는 기본값(default value)을 반환한다
HashMap<String, Integer> map = new HashMap<>();
map.put("apple", 3);
map.put("banana", 5);

int value1 = map.getOrDefault("apple", 0); // 키 "apple"에 대한 값인 3을 반환한다.
int value2 = map.getOrDefault("grape", 0); // 키 "grape"는 존재하지 않으므로 기본값 0을 반환한다.

System.out.println(value1); // 출력: 3
System.out.println(value2); // 출력: 0