String list -> integer Array
Java에서 문자열 목록을 정수 목록으로 변환
1. Java 8 사용하기
list에서 list로 변환하는데 단계가 있다.
list-->stream사용
Stream에서 Stream사용
Accumulate stream 안으로 List사용 Collec->tors.tolist()
/* stream 이 뭘까?
Java 8에서 도입된 Stream API는 컬렉션의 데이터 처리와 조작을 더 쉽고 직관적으로 할 수 있는 강력한 도구입니다. Stream은 데이터 소스(컬렉션, 배열, I/O 채널 등)에 대해 연속적인 데이터를 처리할 수 있는 API를 제공합니다
List result = fruits.stream() // 스트림 생성
.filter(fruit -> fruit.startsWith("B")) // 필터링
.map(String::toUpperCase) // 변환
.sorted() // 정렬
.collect(Collectors.toList()); // 결과 수집
Stream API는 데이터 컬렉션을 처리할 때 유용한 기능을 제공합니다.
중간 연산은 스트림을 변형하고, 종단 연산은 결과를 생성합니다.
병렬 처리를 통해 성능을 개선할 수 있습니다.
Stream API를 사용하면 데이터 처리 코드를 더 간결하고 직관적으로 작성할 수 있습니다.*/
https://www.techiedelight.com/convert-list-string-list-integer-java/
https://velog.io/@deannn/Java-int%ED%98%95-ArrayList-%EB%B0%B0%EC%97%B4-%EB%B3%80%ED%99%98
=======================
Java 8에서 도입된 Stream API는 컬렉션의 데이터 처리와 조작을 더 쉽고 직관적으로 할 수 있는 강력한 도구입니다. Stream은 데이터 소스(컬렉션, 배열, I/O 채널 등)에 대해 연속적인 데이터를 처리할 수 있는 API를 제공합니다. 주요 장점은 코드가 더 간결하고, 병렬 처리가 용이하며, 함수형 프로그래밍 스타일을 사용할 수 있다는 점입니다.
기본 개념
- Stream: 컬렉션 데이터의 흐름을 나타내며, 다양한 연산을 순차적으로 적용할 수 있습니다.
Stream은 데이터를 처리하기 위한 파이프라인을 구성합니다. - 파이프라인:
Stream의 연산은 연속적으로 연결된 단계로 구성됩니다. 일반적으로 중간 연산과 종단 연산으로 나뉩니다.
Stream의 주요 연산
-
중간 연산 (Intermediate Operations):
- 데이터를 변형하거나 필터링하는 연산입니다. 중간 연산은 지연 연산(lazy evaluation)으로, 실제로는 데이터가 처리되지 않고 다음 연산을 정의하기만 합니다.
- 예:
filter(),map(),distinct(),sorted(),limit(),skip()
-
종단 연산 (Terminal Operations):
- 스트림의 최종 결과를 생성하거나 스트림을 소모합니다. 종단 연산이 호출되면 스트림의 모든 중간 연산이 실행됩니다.
- 예:
collect(),forEach(),reduce(),count(),min(),max(),anyMatch(),allMatch(),noneMatch()
기본 사용법
아래 예제는 Stream API의 기본적인 사용법을 보여줍니다.
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExample {
public static void main(String[] args) {
// 데이터 소스: List
List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry", "Blueberry", "Avocado");
// 스트림 생성 및 중간 연산, 종단 연산 사용
List<String> result = fruits.stream() // 스트림 생성
.filter(fruit -> fruit.startsWith("B")) // 필터링
.map(String::toUpperCase) // 변환
.sorted() // 정렬
.collect(Collectors.toList()); // 결과 수집
// 결과 출력
System.out.println(result);
}
}출력
[BLUEBERRY, BANANA]코드 설명
fruits.stream():List에서Stream을 생성합니다.filter(fruit -> fruit.startsWith("B")):startsWith("B")로 시작하는 요소만 통과시킵니다.map(String::toUpperCase): 모든 문자열을 대문자로 변환합니다.sorted(): 문자열을 알파벳 순으로 정렬합니다.collect(Collectors.toList()): 스트림의 결과를 리스트로 수집합니다.
Stream의 주요 메서드
-
중간 연산:
filter(Predicate<? super T> predicate): 주어진 조건을 만족하는 요소만 필터링합니다.map(Function<? super T, ? extends R> mapper): 각 요소를 다른 형태로 변환합니다.distinct(): 중복된 요소를 제거합니다.sorted(): 요소를 정렬합니다. (기본 정렬과 비교를 위한Comparator를 사용할 수도 있습니다.)limit(long maxSize): 스트림의 요소를 지정된 개수만큼 제한합니다.skip(long n): 스트림의 첫n개 요소를 건너뜁니다.
-
종단 연산:
collect(Collector<? super T, A, R> collector): 스트림의 요소를 컬렉션이나 다른 형태로 수집합니다.forEach(Consumer<? super T> action): 각 요소에 대해 지정된 작업을 수행합니다.reduce(T identity, BinaryOperator<T> accumulator): 스트림의 요소를 단일 결과로 축소합니다.count(): 스트림의 요소 개수를 반환합니다.min(Comparator<? super T> comparator): 최소 요소를 반환합니다.max(Comparator<? super T> comparator): 최대 요소를 반환합니다.anyMatch(Predicate<? super T> predicate): 조건을 만족하는 요소가 하나라도 있는지 확인합니다.allMatch(Predicate<? super T> predicate): 모든 요소가 조건을 만족하는지 확인합니다.noneMatch(Predicate<? super T> predicate): 모든 요소가 조건을 만족하지 않는지 확인합니다.findFirst(): 스트림의 첫 번째 요소를 반환합니다.findAny(): 스트림에서 임의의 요소를 반환합니다.
병렬 처리
Stream API는 데이터 처리의 병렬화를 지원합니다. parallelStream() 메서드를 사용하면 컬렉션의 데이터 처리를 병렬로 실행할 수 있습니다.
import java.util.Arrays;
import java.util.List;
public class ParallelStreamExample {
public static void main(String[] args) {
List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry", "Blueberry", "Avocado");
// 병렬 스트림 생성 및 처리
fruits.parallelStream()
.filter(fruit -> fruit.startsWith("B"))
.map(String::toUpperCase)
.sorted()
.forEach(System.out::println);
}
}결론
StreamAPI는 데이터 컬렉션을 처리할 때 유용한 기능을 제공합니다.- 중간 연산은 스트림을 변형하고, 종단 연산은 결과를 생성합니다.
- 병렬 처리를 통해 성능을 개선할 수 있습니다.
Stream API를 사용하면 데이터 처리 코드를 더 간결하고 직관적으로 작성할 수 있습니다.
ArrayList는 자바에서 리스트를 구현하는 클래스이며, 내부적으로 배열을 사용하여 데이터를 저장합니다. 따라서 ArrayList는 리스트이지만, 그 내부 구현에는 배열을 사용하고 있습니다.
ArrayList 개요
-
리스트:
ArrayList는java.util.List인터페이스를 구현한 클래스입니다.List는 순서가 있는 요소 집합을 표현하며, 인덱스를 사용하여 요소에 접근할 수 있습니다. -
배열 기반:
ArrayList는 내부적으로 동적으로 크기를 조절할 수 있는 배열을 사용하여 요소를 저장합니다. 초기 배열 크기가 정해져 있지만, 요소가 추가되면 배열의 크기가 자동으로 확장됩니다.
ArrayList 특징
-
동적 크기 조절:
ArrayList는 배열의 크기를 자동으로 조절할 수 있습니다. 배열의 크기가 부족하면 새로운 배열을 생성하고 기존 배열의 요소를 새로운 배열로 복사합니다. -
빠른 인덱스 접근: 배열 기반의 구현 덕분에 인덱스를 사용하여 빠르게 요소에 접근할 수 있습니다. 인덱스를 통한 접근은 상수 시간(
O(1)) 복잡도를 가집니다. -
중간 삽입 및 삭제: 요소를 삽입하거나 삭제할 때는 배열의 크기 조절이 필요하며, 이 과정에서 요소의 이동이 발생합니다. 따라서 중간에서의 삽입과 삭제는 상대적으로 시간이 더 걸릴 수 있습니다 (
O(n)복잡도). -
중복 허용:
ArrayList는 중복된 요소를 허용합니다. 즉, 동일한 값이 여러 번 존재할 수 있습니다.
예제: ArrayList 사용
다음은 ArrayList를 사용하는 기본적인 예제입니다.
import java.util.ArrayList;
public class ArrayListExample {
public static void main(String[] args) {
// ArrayList 생성
ArrayList<String> list = new ArrayList<>();
// 요소 추가
list.add("Apple");
list.add("Banana");
list.add("Cherry");
// 요소 출력
System.out.println("List: " + list);
// 특정 인덱스의 요소 가져오기
String fruit = list.get(1);
System.out.println("Element at index 1: " + fruit);
// 요소 변경
list.set(1, "Blueberry");
System.out.println("List after update: " + list);
// 요소 삭제
list.remove("Apple");
System.out.println("List after removal: " + list);
// 리스트 크기 확인
System.out.println("Size of the list: " + list.size());
// 리스트 순회
System.out.println("Elements in the list:");
for (String element : list) {
System.out.println(element);
}
}
}출력
List: [Apple, Banana, Cherry]
Element at index 1: Banana
List after update: [Apple, Blueberry, Cherry]
List after removal: [Blueberry, Cherry]
Size of the list: 2
Elements in the list:
Blueberry
Cherry요약
ArrayList는 자바의List인터페이스를 구현한 클래스로, 내부적으로 배열을 사용하여 데이터를 저장합니다.- 리스트로서의 특성: 순서가 있으며 인덱스를 통한 접근이 가능.
- 배열 기반: 요소를 저장하기 위해 배열을 사용하며, 배열의 크기는 동적으로 조절됩니다.
따라서 ArrayList는 리스트이지만, 그 내부 구현은 배열을 기반으로 하고 있습니다.
자바에서 Map은 키-값 쌍을 저장하는 데이터 구조로, java.util 패키지에 포함되어 있습니다. Map 인터페이스를 구현하는 클래스들은 키를 통해 값을 빠르게 검색, 추가, 삭제할 수 있도록 설계되어 있습니다.
Map의 주요 인터페이스 및 구현 클래스
-
Map인터페이스:Map인터페이스는 키와 값의 쌍으로 데이터를 저장하는 구조를 정의합니다. 주요 메서드로는put(),get(),remove(),containsKey(),keySet(),values(),entrySet()등이 있습니다.
-
주요 구현 클래스:
HashMap:- 해시 테이블을 기반으로 구현됩니다.
- 키의 순서가 보장되지 않습니다.
- 빠른 검색, 추가, 삭제 성능을 제공합니다.
LinkedHashMap:HashMap과 비슷하지만, 삽입 순서를 유지합니다.- 키의 순서가 유지되기 때문에 순서가 중요한 경우에 유용합니다.
TreeMap:NavigableMap인터페이스를 구현하며, 정렬된 순서를 유지합니다.- 키를 자연 순서 또는 제공된
Comparator에 따라 정렬합니다.
기본적인 Map 사용 예제
예제 1: HashMap 사용하기
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
// HashMap 생성
Map<String, Integer> map = new HashMap<>();
// 데이터 추가
map.put("Apple", 3);
map.put("Banana", 2);
map.put("Cherry", 5);
// 데이터 조회
System.out.println("Apple: " + map.get("Apple")); // 출력: Apple: 3
// 데이터 삭제
map.remove("Banana");
// 키 존재 여부 확인
System.out.println("Contains Cherry: " + map.containsKey("Cherry")); // 출력: Contains Cherry: true
// Map 전체 출력
System.out.println("Map contents: " + map);
// 키와 값 쌍 순회
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + " -> " + entry.getValue());
}
}
}예제 2: LinkedHashMap 사용하기
import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapExample {
public static void main(String[] args) {
// LinkedHashMap 생성
Map<String, Integer> map = new LinkedHashMap<>();
// 데이터 추가
map.put("Apple", 3);
map.put("Banana", 2);
map.put("Cherry", 5);
// Map 전체 출력
System.out.println("Map contents: " + map);
}
}예제 3: TreeMap 사용하기
import java.util.Map;
import java.util.TreeMap;
public class TreeMapExample {
public static void main(String[] args) {
// TreeMap 생성
Map<String, Integer> map = new TreeMap<>();
// 데이터 추가
map.put("Apple", 3);
map.put("Banana", 2);
map.put("Cherry", 5);
// Map 전체 출력
System.out.println("Map contents: " + map);
// 특정 범위의 키 조회
System.out.println("SubMap: " + map.subMap("Apple", "Cherry"));
}
}Map의 주요 메서드
put(K key, V value): 맵에 키와 값을 추가합니다. 이미 키가 존재하면 값을 업데이트합니다.get(Object key): 주어진 키에 대한 값을 반환합니다.remove(Object key): 주어진 키를 가진 항목을 제거합니다.containsKey(Object key): 주어진 키가 맵에 존재하는지 확인합니다.containsValue(Object value): 주어진 값이 맵에 존재하는지 확인합니다.keySet(): 맵에 있는 모든 키를 반환하는Set을 반환합니다.values(): 맵에 있는 모든 값을 반환하는Collection을 반환합니다.entrySet(): 맵에 있는 모든 키-값 쌍을 반환하는Set<Map.Entry<K, V>>을 반환합니다.
요약
Map인터페이스는 키와 값의 쌍으로 데이터를 저장하고 관리하는 기능을 제공합니다.HashMap: 빠른 성능을 제공하지만 순서가 보장되지 않습니다.LinkedHashMap: 삽입 순서를 유지하며HashMap과 유사합니다.TreeMap: 키의 자연 순서 또는 제공된Comparator에 따라 정렬된 순서를 유지합니다.
이러한 Map 구현 클래스는 데이터의 저장과 검색, 순회 방식에 따라 다양한 사용 사례에 맞게 선택할 수 있습니다.
Java에서 List를 출력하는 방법은 여러 가지가 있습니다. 가장 일반적인 방법은 for 루프를 사용하거나, List의 toString() 메서드를 사용하는 것입니다. 또한 Java 8 이상의 버전을 사용하는 경우 forEach 메서드나 Stream API를 사용하여 출력할 수도 있습니다.
아래에 다양한 방법을 통해 List를 출력하는 예제를 제공합니다.
예제: 기본적인 List 출력
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
// List 생성 및 초기화
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");
// 방법 1: toString() 메서드를 사용한 출력
System.out.println("방법 1: " + fruits);
// 방법 2: for-each 루프를 사용한 출력
System.out.print("방법 2: ");
for (String fruit : fruits) {
System.out.print(fruit + " ");
}
System.out.println();
// 방법 3: for 루프와 get() 메서드를 사용한 출력
System.out.print("방법 3: ");
for (int i = 0; i < fruits.size(); i++) {
System.out.print(fruits.get(i) + " ");
}
System.out.println();
// 방법 4: Java 8의 forEach 메서드를 사용한 출력
System.out.print("방법 4: ");
fruits.forEach(fruit -> System.out.print(fruit + " "));
System.out.println();
// 방법 5: Java 8의 Stream API를 사용한 출력
System.out.print("방법 5: ");
fruits.stream().forEach(fruit -> System.out.print(fruit + " "));
System.out.println();
}
}출력 결과
방법 1: [Apple, Banana, Cherry]
방법 2: Apple Banana Cherry
방법 3: Apple Banana Cherry
방법 4: Apple Banana Cherry
방법 5: Apple Banana Cherry 코드 설명
-
방법 1:
toString()메서드 사용List객체 자체를System.out.println()에 전달하면List의toString()메서드가 호출되어 리스트의 모든 요소가 출력됩니다. 이 방법은 리스트의 모든 요소를[ ]로 묶어서 쉼표로 구분하여 출력합니다.
-
방법 2:
for-each루프 사용for-each루프를 사용하여List의 각 요소를 순회하면서 개별적으로 출력합니다. 이 방법은 요소들을 하나씩 읽어와 출력하는 방법입니다.
-
방법 3:
for루프와get()메서드 사용for루프와List의get(int index)메서드를 사용하여 리스트의 요소를 인덱스 기반으로 접근하여 출력합니다.List의 크기(size())를 사용하여 반복 횟수를 지정합니다.
-
방법 4: Java 8의
forEach메서드 사용- Java 8부터 추가된
forEach메서드를 사용하여List의 각 요소를 출력합니다. 람다 표현식을 사용하여 코드를 간결하게 작성할 수 있습니다.
- Java 8부터 추가된
-
방법 5: Java 8의
StreamAPI 사용- Java 8의
StreamAPI를 사용하여List를 스트림으로 변환하고, 스트림의forEach메서드를 사용하여 요소를 출력합니다. 이 방법은 람다 표현식을 사용할 수 있어 코드가 간결해집니다.
- Java 8의
결론
List의 출력은 다양한 방법으로 수행될 수 있으며, 상황에 따라 적절한 방법을 선택하여 사용하면 됩니다.- Java 8 이상에서는 람다 표현식과
StreamAPI를 활용하여 더욱 간결하고 직관적인 코드를 작성할 수 있습니다.
The error message integer cannot be resolved to a type indicates that Java cannot recognize integer as a valid data type. This is likely because integer is incorrectly spelled or capitalized.
Correct Usage in Java
Java is a case-sensitive language, which means that it distinguishes between uppercase and lowercase letters. The correct type names in Java are:
int: A primitive data type representing a 32-bit signed integer.Integer: A wrapper class in thejava.langpackage that wraps a value of the primitive typeintin an object. This class provides methods to convert betweenintandStringobjects, as well as other constants and methods.
Solution
To fix the error, ensure that you are using the correct capitalization:
- Use
intfor primitive integer variables. - Use
Integer(with an uppercase "I") when you need an object that can hold an integer value, or when working with generics (likeArrayList<Integer>).
Example Correct Usage
Here are some correct examples of using int and Integer in Java:
public class Main {
public static void main(String[] args) {
// Using primitive data type 'int'
int primitiveInt = 5;
System.out.println("Primitive int: " + primitiveInt);
// Using wrapper class 'Integer'
Integer wrapperInteger = 10;
System.out.println("Wrapper Integer: " + wrapperInteger);
// Example of using Integer with ArrayList
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println("ArrayList of Integer: " + numbers);
}
}Key Points to Remember
- Case Sensitivity: Java is case-sensitive, so make sure you use
int(lowercase) for primitive types andInteger(uppercase) for the wrapper class. - Primitive vs. Wrapper Class:
int: A primitive data type. It is faster and consumes less memory than its wrapper class counterpart.Integer: A wrapper class. It is useful when you need objects instead of primitives, such as when working with generics or collections.
Common Scenarios Where This Error Occurs
- Misspelling: Accidentally typing
integerinstead ofintorInteger. - Imports: Forgetting to import necessary classes (not relevant for
Integersince it’s injava.lang, which is imported by default).
Conclusion
To resolve the error integer cannot be resolved to a type, make sure you are using int or Integer with the correct capitalization and context in your Java program.
네, Enhanced for 문 안에서 조건에 맞는 요소를 새로운 배열이나 컬렉션에 저장할 수 있습니다. 이를 통해 원하는 요소들만 선택적으로 저장하는 작업이 가능합니다. 예를 들어, 특정 조건을 만족하는 요소들만 새로운 ArrayList에 저장하는 예제를 보겠습니다.
예제: 짝수만 새로운 리스트에 저장하기
정수 배열에서 짝수만 추출하여 새로운 ArrayList에 저장하는 예제입니다.
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// 짝수만 저장할 ArrayList 생성
ArrayList<Integer> evenNumbers = new ArrayList<>();
// Enhanced for 문을 사용하여 배열을 순회
for (int number : numbers) {
// 짝수인지 검사하는 if 문
if (number % 2 == 0) {
// 짝수일 경우 evenNumbers 리스트에 저장
evenNumbers.add(number);
}
}
// 저장된 짝수 출력
System.out.println("짝수 리스트: " + evenNumbers);
}
}출력
짝수 리스트: [2, 4, 6, 8, 10]코드 설명
int[] numbers: 정수를 저장하는 배열입니다.ArrayList<Integer> evenNumbers: 짝수만 저장할 새로운 리스트입니다.Enhanced for문:numbers배열을 순회하면서 각 요소를number변수에 저장합니다.if (number % 2 == 0): 현재 요소가 짝수인지 검사합니다.evenNumbers.add(number): 짝수일 경우evenNumbers리스트에 추가합니다.- 결과 출력:
evenNumbers리스트에 저장된 짝수들을 출력합니다.
예제: 특정 길이의 문자열만 저장하기
ArrayList 컬렉션에서 길이가 5 이상인 문자열만 새로운 리스트에 저장하는 예제입니다.
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<String> words = new ArrayList<>();
words.add("apple");
words.add("banana");
words.add("cat");
words.add("dog");
words.add("elephant");
// 길이가 5 이상인 문자열을 저장할 리스트 생성
ArrayList<String> longWords = new ArrayList<>();
// Enhanced for 문을 사용하여 컬렉션을 순회
for (String word : words) {
// 문자열 길이가 5 이상인지 검사하는 if 문
if (word.length() >= 5) {
// 조건을 만족하는 문자열을 longWords 리스트에 저장
longWords.add(word);
}
}
// 저장된 문자열 출력
System.out.println("길이가 5 이상인 단어 리스트: " + longWords);
}
}출력
길이가 5 이상인 단어 리스트: [apple, banana, elephant]요약
Enhanced for문과if문을 함께 사용하여 배열이나 컬렉션에서 특정 조건을 만족하는 요소들을 선택적으로 저장할 수 있습니다.- 새로운 리스트 또는 배열을 생성하여 조건에 맞는 요소만 저장함으로써, 필터링된 데이터를 후속 처리에 활용할 수 있습니다.
Enhanced for문(또는 향상된 for 문)은 자바에서 배열이나 컬렉션을 순회(iterate)하기 위해 사용되는 편리한 반복문입니다. 일반적인for문과 비교했을 때, 코드가 더 간결하고 읽기 쉽다는 장점이 있습니다.
사용법
Enhanced for 문은 다음과 같은 형식으로 사용됩니다:
for (데이터 타입 변수 : 배열 또는 컬렉션) {
// 반복할 코드
}- 데이터 타입 변수: 배열이나 컬렉션의 각 요소가 저장될 변수를 선언합니다.
- 배열 또는 컬렉션: 순회할 대상이 되는 배열이나
Iterable인터페이스를 구현한 컬렉션입니다.
예제 1: 배열을 순회할 때의 사용
배열의 모든 요소를 출력하는 예제입니다.
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
// Enhanced for 문을 사용하여 배열을 순회
for (int number : numbers) {
System.out.println(number);
}
}
}위 코드에서는 numbers 배열의 각 요소를 number 변수에 대입하여 for 문 안의 코드를 반복 실행합니다. 출력은 다음과 같습니다:
1
2
3
4
5예제 2: 컬렉션을 순회할 때의 사용
ArrayList와 같은 컬렉션을 순회할 때도 Enhanced for 문을 사용할 수 있습니다.
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");
// Enhanced for 문을 사용하여 컬렉션을 순회
for (String fruit : fruits) {
System.out.println(fruit);
}
}
}위 코드에서는 ArrayList에 저장된 문자열들을 fruit 변수에 대입하여 출력합니다. 출력은 다음과 같습니다:
Apple
Banana
Cherry특징 및 주의사항
-
읽기 전용:
Enhanced for문에서 사용되는 변수는 읽기 전용입니다. 배열이나 컬렉션의 요소를 변경하려면 별도의 인덱스나 참조를 사용해야 합니다. -
모든 요소를 순회:
Enhanced for문은 항상 컬렉션이나 배열의 모든 요소를 순회합니다. 만약 중간에 반복을 멈추려면break문을 사용해야 합니다. -
Iterable인터페이스를 구현해야 함:Enhanced for문은Iterable인터페이스를 구현한 컬렉션에서만 사용할 수 있습니다. 예를 들어, 배열,ArrayList,HashSet등은 사용할 수 있지만,Map은 직접 사용할 수 없습니다. 대신,Map의keySet(),entrySet()또는values()를 사용하여 키, 값, 또는 엔트리를 순회할 수 있습니다.
예제 3: Map 컬렉션을 순회하는 경우
Map 컬렉션을 순회할 때는 entrySet() 메서드를 사용하여 Map.Entry 객체를 순회합니다.
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 30);
ages.put("Bob", 25);
ages.put("Charlie", 35);
// Map 컬렉션의 각 엔트리 순회
for (Map.Entry<String, Integer> entry : ages.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}위 코드는 HashMap의 각 키-값 쌍을 순회하여 출력합니다. 출력은 다음과 같습니다:
Alice: 30
Bob: 25
Charlie: 35결론
Enhanced for 문은 배열이나 컬렉션을 순회하는 작업을 간결하고 직관적으로 만들어주는 유용한 반복문입니다. 컬렉션의 요소를 읽어 처리하는 경우에 적합하며, 코드의 가독성을 높이는 데 도움이 됩니다.
