1. ๋ฌธ์ ์ ๋ํ์ฌ ๐ฆ
- ๋ฌธ์ ๋งํฌ: https://www.acmicpc.net/problem/22861
(1) ์กฐ๊ฑด ๋ถ์ ๐
- ํด๋ ๊ตฌ์กฐ ํ์ฑ ๋ช
๋ น์ด
- ๋งจ ๋ง์ง๋ง์ 1์ด ์ค๋ฉด ํด๋ ๊ฐ์ ๋ถ๋ชจ-์์ ๊ด๊ณ๋ฅผ ๋ํ๋
- ๋งจ ๋ง์ง๋ง์ 0์ด ์ค๋ฉด ํน์ ํด๋์ ํ์ผ ์ฝ์ ๋ช ๋ น์ด
- ํด๋ ์ด๋ ๋ช
๋ น์ด
- ํด๋ A, ํด๋ B ๊ตฌ์กฐ๋ก ์๋ ค์ฃผ๋ฉด ํด๋ A๋ฅผ B๋ก ์ฎ๊ธด๋ค.
- ํด๋ ํ์ ํ์ผ ์ + ํ์ผ ์ ํ ์ถ๋ ฅ ๋ช ๋ น์ด
2. ์ฝ๋๊ฐ ๋์ค๊ธฐ๊น์ง ๐ ๏ธ
KEY WORD: ์๋ฎฌ๋ ์ด์
, ์๋ฃ๊ตฌ์กฐ
๋จผ์ ๊ฐ๋ ์ ๋๋๊ณ ์ ํ๋ค.
- ์ง์ ํ์ผ: ํด๋น ํด๋์ ์กด์ฌํ๋ ํ์ผ์ด๋ค.
- ํ์ ํ์ผ: ํด๋น ํด๋์ ํ์ ํด๋ ์ค ์ด๋๊ฐ์ ์กด์ฌํ๋ ํ์ผ์ด๋ค.
(0) ํด๋์ ์ข ๋ฅ๋ฅผ ๊ตฌ๋ถํ๋ ์ด์
ํด๋ ์ ๋ฆฌ (small)๋ฅผ ํ๋ฉด์ ์ง์ํ์ผ๊ณผ ํ์ํ์ผ์ ๊ตฌ๋ถ์์ด ๋์ ํ์ฌ ํ์๋ ํ์ด์๋ค์ ํด๋น ํ์ด๋ฅผ ๊ณ ์ํ ๊ฒฝ์ฐ ๋ฌธ์ ํ์ด๊ฐ ์ด๋ ค์์ง๋ค. ์๋ํ๋ฉด ํด๋ ์ด๋์ ๋ฐ๋ผ ๋์ ํ์ผ์ ๊ฐ์์ ํ์์ ์ค๋ณต ์๋ ํ์ผ ์ ํ์ ๋๊ธฐํ๊ฐ ๊นจ์ง ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฌธ์ ์์ ์ฃผ์ด์ง ์์๋ฅผ ๋ณด๋ฉด ์ด๊ธฐ ์ํ๋ ๋ค์๊ณผ ๊ฐ์ ๊ฒ์ด๋ค.
์ดํ folderB์ ๋ด์ฉ๋ฌผ์ folderA๋ก ์ฎ๊ธฐ๋ฉด ๋ค์๊ณผ ๊ฐ์ด FIle 1์ด ๋ฎ์ด์จ์ง๋ฏ๋ก, ํ์ผ ์ ํ์ ๊ทธ๋๋ก์ง๋ง ํ์ผ ๊ฐ์๋ ์ค์ฌ์ผํ๋ค.
ํ๋ฐ ์ง์ ํ์ผ๊ณผ ํ์ ํ์ผ์ ํผํฉํด์ ๊ด๋ฆฌํ๊ณ ์์๋ค๋ฉด, ์ด๋ฌํ ํ์ผ ์ด๋์ ๊ตฌํํ๊ธฐ๊ฐ ๋งค์ฐ ์ด๋ ค์์ง๋ค.
์์ผ๋ก ํฉ๋ณํ๊ณ ์ญ์ ๋ ํด๋๋ฅผ from ํด๋, ํฉ๋ณํด์ ์ปค์ง ํด๋๋ฅผ to ํด๋๋ผ๊ณ ํด๋ณด์. ํฉ์น ๋ ์ค๋ณต๋ ํ์ผ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค๊ณ , to ํด๋์ ๋ถ๋ชจ ํด๋๋ค์์ ์ค๋ณต๋ ํ์ผ ์ ํ์ ๊ดํด์๋ ๋์ ํ์ผ ๊ฐ์๋ฅผ ์ฌ๋ฆฌ์ง ์๋ ๋ฐฉ์์ ํ์ด๋ฅผ ์๊ฐํ ์ ์์ง๋ง
to,from๊ณตํต ๋ถ๋ชจ์ผ ๊ฒฝ์ฐ ์ฒ๋ฆฌ, ๊ณตํต ๋ถ๋ชจ๊ฐ ์๋ ๊ฒฝ์ฐ ์ฒ๋ฆฌ ๊ตฌํ ๋ฐ๋ก ์ง์ผํ๋ค๋ ์ - ๋งค๋ฒ ๋ถ๋ชจ ํด๋์ ๋ชจ๋ ํด๋ ์ ํ์ ๊ฒ์ํด์ผ ํ๋ค๋ ์
์์ ๋ณต์ก๋๊ฐ ์ค๋ฅด๊ณ ์ฑ๋ฅ์ด ๋ฎ์์ง๋ค. (ํ์๊ฐ ์ด๋ ๊ฒ ํ์์ผ๋ ์๊ฐ์ด๊ณผ๊ฐ ๋ซ๋ค.)
๋ฐ๋ผ์ ๋์ ํฉ์ผ๋ก ๊ด๋ฆฌํ์ง๋ง๊ณ , ํด๋๋ง๋ค ์ง์ ํ์ผ, ํ์ ํ์ผ๋ค์ ๊ตฌ๋ถํ์ฌ ๊ด๋ฆฌํ๋ฉด ๋ฌธ์ ๋ฅผ ์ฝ๊ฒ ํ ์ ์๋ค.
(1) ํด๋ ๊ด๋ฆฌ์ ํ์ผ ์ด๋
static class Folder {
HashSet<String> subFolders;
HashSet<String> subFiles; // ์ง์ ํ์ผ๋ง ์ ์ฅ
public Folder (){
subFolders = new HashSet<>();
subFiles = new HashSet<>();
}
}
subFolder๋ ํ์ ํด๋๋ค์ ์ด๋ฆ, subFiles๋ ์์ ์ ์ง์ ํ์ผ๋ค์ ์ด๋ฆ์ ์ ์ฅํ๋ค.
์ดํ ํด๋๊ฐ์ ํฉ๋ณ์ด ์์ ๊ฒฝ์ฐ from ํด๋์ ์๋ ๋ชจ๋ ํ์ ํด๋์ ์ง์ ํ์ผ๋ค์ to ํด๋๋ก ์์๋ฒ๋ฆฌ๋ฉด ๋๋ค. HashSet์ด๊ธฐ ๋๋ฌธ์ ์ค๋ณต ์ ๊ฑฐ๋ ์๋์ ์ผ๋ก ๋๊ณ , ๋ฐ๋ก ๋ถ๋ชจ์ ์์ ํด๋๋ฅผ ์๋ ๊ณผ์ ๋ ๋ถํ์ํด์ง๋ค.
ํ์ง๋ง ์ฃผ์ํด์ผํ ์ ์ด ์๋๋ฐ, ๋ค์๊ณผ ๊ฐ๋ค.
(2) From ํด๋์ ๋ถ๋ชจ ์์ ๊ด๊ณ ๋๊ธฐ
์์ ์์์์ folderB์ ๋ด์ฉ๋ฌผ์ folderA๋ก ์์๋ฃ์ ๋ค, folderB๊ฐ ์์ด์ง ๊ฒ์ ๋ณผ ์ ์๋ค. ์ด๊ฒ์ ๊ตฌํํด์ผํ๋ ์ด์ ๋ ์ดํ ํ์ผ ์ด๋ ๊ณ์ฐ์ ํ๋ ค๋๋ฐ folderB๊ฐ ์์ง๋ ์ด์ ๋ถ๋ชจ ํด๋์ ๋ถ์ด์๋ค๋ฉด ์ดํ ๊ณ์ฐ์ด ์ด๊ทธ๋ฌ์ง ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
์ง์ฐ๋ ค๋ฉด folderB์ ๋ถ๋ชจ ํด๋๋ฅผ ์์์ผ ํ๋๋ฐ, ๋ฌธ์ ์์ ํ์ผ ์ด๋ ๋ช
๋ น์ด๋ฅผ ์ค ๋ ๊ฒฝ๋ก ์์ฒด๋ฅผ ์ฃผ๋ฏ๋ก ๊ฑฐ๊ธฐ์ ๊บผ๋ด ์ฐ๋ฉด๋๋ค.
(3) ํน์ ํด๋๊ฐ ๊ฐ์ง ์ ์ฒด ํด๋ ๊ฐ์ ๋ฐ ํ์ผ ์ ํ ์ถ๋ ฅ
์ ์ฒด ํ์ผ ์ ํ ์ถ๋ ฅ
:์ฌ๊ท๋ฅผ ๋๋ฉฐ ๊ทธ๊ฒ์ ํ์ ํด๋๋ค์ ํ์ผ์ ๋ชจ๋ ํ๋์ SET์ ์ ์ฅํ๋ค. -> ์ค๋ณต ์ ๊ฑฐ์ ์ฒด ํด๋ ๊ฐ์
: ์ฌ๊ท๋ฅผ ๋๋ฉฐ ํ์ผ์ ๋ง๋ ๋๋ง๋ค ์ ์ฒด ํด๋ ๊ฐ์ +1 ํ๋ฉด ๋๋ค.
(4) ์๊ฐ๋ณต์ก๋ ๋ถ์ โณ
๋งค ํด๋ ์ด๋ ๋ช ๋ น์ด์์ ํ์ผ์ ์ต๋์น์ธ 1,000๊ฐ๋ฅผ ๋ค ์ฎ๊ธด๋ค๊ณ ํด๋ ์ต๋ $1,000 \times 1,000 = 1,000,000$ ๊ฐ์ฌ์ ํด๋น ํ์ด๋ก๋ ์๊ฐ์ด๊ณผ๊ฐ ๋์ง ์๋๋ค.
3. ์ฝ๋ ๐
import java.io.*;
import java.util.*;
/*
* ํด๋ ์ ๋ฆฌ (Large)* 1. ํด๋์ ํ์ผ ์
๋ ฅ์ผ๋ก unionfind ๋ง๋ค๊ธฐ -> ๊ฒฝ๋ก ์์ถํ์ง ๋ง๊ธฐ
* 2. ํ์ผ ์
๋ ฅ ์ ๋ถ๋ชจ ๋
ธ๋ ํ๊ณ ๊ฐ๋ฉฐ + 1์ฉ ๋ค ํด์ฃผ๊ธฐ
*/
public class Main {
static class Folder {
HashSet<String> subFolders;
HashSet<String> subFiles; // ์ง์ ํ์ผ๋ง ์ ์ฅ
public Folder (){
subFolders = new HashSet<>();
subFiles = new HashSet<>();
}
} static int N,M,K,Q; // ํด๋ ์, ํ์ผ ์, ์ด๋ ๋ช
๋ น์ด ์, ํ๋ฆฐํธ ๋ช
๋ น์ด
static String [][] relation_order;
static String [][][] move_order;
static String [] print_order;
static HashMap<String, Folder> tree = new HashMap<>();
public static void main(String[] args) throws IOException {
input();
for (String [] order : relation_order){
if(order[2].equals("1")) makeDir(order[0], order[1]);
else addFile(order[0], order[1]);
}
for (String [][] order : move_order){
moveFolder(order[0], order[1]);
}
StringBuilder answer = new StringBuilder();
HashSet<String> all_types = new HashSet<>();
int [] sum = new int[1];
for(String order : print_order){
all_types.clear();
sum[0] = 0;
calculate(order, sum, all_types);
answer.append(all_types.size()).append(" ").append(sum[0]).append("\n");
}
System.out.println(answer);
}
public static void makeDir(String parent, String child){
tree.compute(parent, (k,ov)-> ov == null? new Folder() : ov);
tree.compute(child, (k,ov) -> ov == null? new Folder() : ov);
tree.get(parent).subFolders.add(child);
}
public static void addFile(String folder, String file){
tree.get(folder).subFiles.add(file);
}
public static void moveFolder(String [] fromPaths, String [] toPaths){
Folder from = tree.get(fromPaths[fromPaths.length-1]);
Folder to = tree.get(toPaths[toPaths.length-1]);
// from ํด๋ ์์ฒด๋ฅผ ์๋ ๊ฒฝ๋ก์์ ์ง์ฐ๊ธฐ
tree.get(fromPaths[fromPaths.length-2]).subFolders.remove(fromPaths[fromPaths.length-1]);
// from ํด๋์ ํด๋๋ค๊ณผ ํ์ผ๋ค์ to ํด๋์ ์๊ธฐ
to.subFolders.addAll(from.subFolders);
to.subFiles.addAll(from.subFiles);
// from ํด๋ ๋น์ฐ๊ธฐ
from.subFolders.clear();
from.subFiles.clear();
}
public static void calculate(String folder, int [] sum, HashSet<String> set){
Folder now = tree.get(folder);
sum[0] += now.subFiles.size();
set.addAll(now.subFiles);
for (String sub : now.subFolders){
calculate(sub, sum, set);
}
}
public static void input() throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
N = Integer.parseInt(st.nextToken());
M = Integer.parseInt(st.nextToken());
relation_order = new String[N+M][3];
for(int i = 0; i < N+M; i++){
relation_order[i] = br.readLine().split(" ");
}
Arrays.sort(relation_order, (row1, row2) -> Integer.parseInt(row2[2]) - Integer.parseInt(row1[2]));
K = Integer.parseInt(br.readLine());
move_order = new String[K][2][N+1];
for (int i = 0; i < K; i++) {
st = new StringTokenizer(br.readLine());
String [] to = st.nextToken().split("/");
String [] from = st.nextToken().split("/");
move_order[i][0] = to;
move_order[i][1] = from;
}
Q = Integer.parseInt(br.readLine());
print_order = new String[Q];
for (int i = 0; i < Q; i++) {
String [] path = br.readLine().split("/");
print_order[i] = path[path.length-1];
}
}}
4. ํธ๋ฌ๋ธ ์ํ or ๋ฐฐ์ด ์ ๐
(1) ํ์ด ๋ฐฉ์ ์คํ
ํ์๋ ์ถ๋ ฅ ๋ช ๋ น ๋ถ๋ถ์์ ํด๋น ํด๋์ ๋ชจ๋ ํ์ ํด๋๋ฅผ ์ํํ๋ฉฐ ํ์ผ์ ์ผ์ผํ ์ธ๋ ๊ณผ์ ์ด ์๊ฐ ์ด๊ณผ๊ฐ ๋ ๊ฒ์ด๋ผ ํ๋จํ๋ค. ๊ทธ๋์ ๋งค๋ฒ ํด๋ ์ด๋ ์, ๋ฎ์ด์ฐ๊ธฐ ๋ ํ์ผ์ ๋ฐ๋ก ๊ด๋ฆฌํ๋ฉฐ ๋ถ๋ชจ ํด๋์์ ํด๋น ํ์ผ์ ๋ฐ๋ก ๋์ ํ์ผ ๊ฐ์์ ์ํฅ์ด ๊ฐ์ง ์๋๋ก ํ์๋ค.
ํ์ง๋ง ์ด ์ค๋ณต ๋ฆฌ์คํธ ๊ด๋ฆฌ ํ์ด๊ฐ ์คํ๋ ค ์๊ฐ์ด๊ณผ๊ฐ ๋ฌ๋ค. ํ์๊ฐ ๋ถ์ํ ์ด์ ๋ ๋ชจ๋ ๋ถ๋ชจ ํธ๋ฆฌ๋ง๋ค ์ค๋ณต๋ฆฌ์คํธ ์ ์ฒด์ ๋ถ๋ชจ ํด๋์ ๋์ ํด๋ ๊ฐ์ ์ ์ฒด๋ฅผ ๋น๊ตํด์ผํด์ ์๋ค. ์ด๋ ๊ฒ ๋๋ฉด ์ต์ ์ ๊ฒฝ์ฐ, ํด๋ ์ด๋ ํ ๋ฒ๋น ๋ชจ๋ ํด๋์ ๋ชจ๋ ๋์ ํ์ผ์ ๋ชจ๋ ์ํํด์ผ ํ๋ฏ๋ก $1,000 \times 1,000 \times 1,000 = 10^9$ ๊ฐ ๋์ด ์๊ฐ ์ด๊ณผ๊ฐ ๋ ๊ฒ์ด๋ค.
(2) Integer๋ ๋ถ๋ณ ๊ฐ์ฒด
StringBuilder answer = new StringBuilder();
HashSet<String> all_types = new HashSet<>();
int [] sum = new int[1];
for(String order : print_order){
all_types.clear();
sum[0] = 0;
calculate(order, sum, all_types);
answer.append(all_types.size()).append(" ").append(sum[0]).append("\n");
}
System.out.println(answer);
ํด๋น ๋ถ๋ถ์ ํ์ฌ ์ถ๋ ฅ๋ช
๋ น์ด์ ํด๋นํ๋ ํด๋์ ๋ชจ๋ ํ์ ํ์ผ ๊ฐ์์ ์ ํ์ ์ธ๋ ์ฝ๋ ๋ถ๋ถ์ธ๋ฐ, ํ์ผ ๊ฐ์๋ฅผ ๋์ ํ๋ sum์ int [] ๋ฐฐ์ด๋ก ๋๊ธฐ๋ ๊ฒ์ ๋ณผ ์ ์๋ค. ์ด๋ ๋ฐฐ์ด์ ์ฃผ์๊ฐ์ด ๊ณ์ฐ ํจ์์ ์ธ์๋ก ๋๊ฒจ์ง๋ ๊ฒ์ ํ์ฉํด ํจ์๊ฐ ๋๋๊ณ ๋ ๊ฐ์ ์ ์งํ๋๋ก ํ๊ธฐ ์ํจ์ด์๋ค.
์ฒ์์๋ ํด๋น int [] sum ์ Integer sum์ผ๋ก ํ์์ง๋ง sum์ ์ํ๊ฐ ์ ์ง๋์ง ์์๋ค. ์ด์ ๋ Integer๋ ๋ถ๋ณ ๊ฐ์ฒด์ด๊ธฐ ๋๋ฌธ์ด๋ค. ๋ถ๋ณ ๊ฐ์ฒด๋ ํ ๋ฒ ๊ฐ์ด ์ ํด์ง๋ฉด ๋ฐ๋์ง ์๋ ๊ฐ์ฒด๋ฅผ ๋ปํ๋ค. ๋ฐ๋ผ์ calculate(Integer sum)์ ๋๊ธฐ๋ฉด sum์ ์ฃผ์๊ฐ์ด ์ ๋ฌ๋๋ ๊ฒ์ด ์๋๋ผ ์๋ก์ด Integer ๊ฐ์ฒด๊ฐ ์ธ์๋ก ์ ๋ฌ๋๋ค๊ณ ํ๋ค.
(3) ConcurrentModificationException
HashSet์ ์ํํ๋ฉด์ ์์ ๋ด์ฉ์ ์ญ์ ํ๋ ค๋ค๊ฐ ์์ ๊ฐ์ ์ค๋ฅ๊ฐ ๋ฌ๋ค. Collections ํด๋์ค๋ฅผ ์์๋ฐ์ ์๋ฃ๊ตฌ์กฐ๋ค (ex - HashMap, HashSet, ArrayList ๋ฑ)์ ์ดํฐ๋ ์ดํฐ๋ก ์ํํ๋ฉด์ ๊ทธ ์์ ๊ฐ์ ํด๋น ํด๋์ค ์ ์ฉ remove() ๋ก ์ญ์ ํ๋ ค๊ณ ํ๋ฉด ์์ ๊ฐ์ ์ค๋ฅ๊ฐ ๋๋ค.
๊ทธ ์ด์ ๋ Iterator๋ก ์ํ๋ฅผ ํ ๋, iterator.next()๋ฅผ ์ฌ์ฉํ๋๋ฐ, ์ด ํจ์๋ ํญ์ modCount๋ผ๋ int ๊ฐ์ด ์ด๊ธฐ๊ฐ๊ณผ ๋ฌ๋ผ์ก๋์ง ๊ฒ์ฌํ๋ค. ๋ง์ฝ ์ด๊ธฐ๊ฐ๊ณผ ๋์ผํ์ง ์๋ค๋ฉด, ์ํ ์ค์ ์์ ์ด ๋ฐ์ํ ๊ฒ์ด๊ณ , ์ด๋ ์ผ๊ด์ฑ์ ์ ์งํ ์ ์๊ธฐ์ ์ค๋ฅ๋ฅผ ๋ธ๋ค.
(collections ํด๋์ค์ ์์ ์๋ modCount๋ collections์์ ์ฝ์
, ์์ ์ญ์ ๊ฐ ์๊ธธ ๋๋ง๋ค ์ฆ๊ฐํ๋ ๊ฐ์ด๋ค.)
ArrayList๋ ๋ด๋ถ๊ฐ ๋ฐฐ์ด๋ก ์ด๋ฃจ์ด์ ธ ์๊ธฐ ๋๋ฌธ์ for(int i = 0; โฆ)์ผ๋ก ์์ํ๋ ๋จ์ for๋ฌธ์ผ๋ก ๋๋ฉด์ ์์ ๊ฐ๋ค์ ์์ ํ ์ ์์ผ๋, ๋ฌด์กฐ๊ฑด Iterator๋ฅผ ํ์ฉํด์ ์ํํด์ผ ํ๋ set, map ์ ํ๋ค์ ์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
[!info] ๊ฐํ for ๋ฌธ
for (Itneger now : hashSet) {}ํํ๋ก ๋ ๊ฐํ for ๋ฌธ๋ ๋ด๋ถ์ ์ผ๋ก iterator๋ฅผ ์ฌ์ฉํ๋คใ .
A. ํด๋น ์ค๋ฅ๋ฅผ ํผํ๋ฉด์ ์ํ ์ค remove๋ฅผ ํ๋ ๋ฐฉ๋ฒ
๊ฐ ์๋ฃ๊ตฌ์กฐ ๋ด๋ถ remove ๋ง๊ณ , Iterator ์ remove ๋งค์๋๊ฐ ๋ฐ๋ก ์กด์ฌํ๋๋ฐ ์ด๊ฑธ ์ฌ์ฉํด์ผ ํ๋ค.
ํด๋น ์ญ์ ํจ์๋ ๋ด๋ถ์ ์ผ๋ก expectedModeCount ๋ผ๋ ๊ฐ์ด ์กด์ฌํ๋๋ฐ, ์ด๋ฅผ ํ์ฉํด ์ปฌ๋์
์๋ฃ๊ตฌ์กฐ์ modCount๋ฅผ ์ญ์ ๊ฐ ๋๋ด๊ณ ๋งค ๋ฒ ๋๊ธฐํํ๋ค. ๋ฐ๋ผ์ ConcurrentModificationException์ด ๋ฐ๋ก ์๊ธฐ์ง ์๋๋ค.
Iterator๊ฐ ์ธํฐํ์ด์ค๋ผ ๊ทธ๊ฒ์ ๊ตฌํํ ๋ฐฉ๋ฒ์ ์๋ฃ๊ตฌ์กฐ๋ง๋ค ๋ค๋ฅด์ง๋ง, ArrayList๋ฅผ ์๋ก ๋ค์ด๋ณด๋ฉด Iterator๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํํ๊ณ ์๋คใ .
private class Itr implements Iterator<E> {
int cursor; // ๋ค์ ๋ฐํํ ์์์ ์ธ๋ฑ์ค
int lastRet = -1; // ๋ง์ง๋ง ๋ฐํํ ์์์ ์ธ๋ฑ์ค
int expectedModCount = modCount; // โโ ์ฌ๊ธฐ ์๋ค!
public boolean hasNext() {
return cursor != size;
}
public E next() {
checkForComodification(); // expectedModCount ๋น๊ต
// ... ๋๋จธ์ง ๊ตฌํ
}
}
๋ง์ฝ iterator.remove()๋ฅผ ํตํด ํ์ฌ ์ธ๋ฑ์ค์ ๊ฐ์ ์ญ์ ํ์ผ๋ฉด, ๊ตฌํ์ฒด ๋ด๋ถ์ ์ผ๋ก ๋ง์ง๋ง ์ฌ์ฉ ์ธ๋ฑ์ค (lastRet)์ ํตํด ๋ค์ next() ํธ์ถ ์ ๋ฐฉ๋ฌธํด์ผํ ์ธ๋ฑ์ค๋ฅผ ๊ณ์ฐํ์ฌ cursor๋ฅผ ์ฎ๊ธด๋ค. ๋ฐ๋ผ์ ์ผ๊ด์ฑ ๋ฌธ์ ์์ด ์ญ์ ๋ฅผ ์งํํ ์ ์๋ค.
5. ๋ถ๋ก
A. ๋ชจ๋ฅด๋ ๋จ์ด ์ ๋ฆฌ
play along with ~~
: (์๋๋ฐฉ์ด ์ํ๋ ๋๋ก) ๋ง์ถฐ ์ฃผ๋ค. ๋์กฐํด์ฃผ๋ค. ํ์กฐํ๋ค.
(Fail-fast iterators in Java don't play along when the underlying collection gets modified.)
(์๋ฐ์ ๋น ๋ฅธ ์คํจ ์ดํฐ๋ ์ดํฐ๋ ๊ทธ๊ฒ์ด ๋์๊ฐ๊ณ ์๋ ์ปฌ๋ ์ ์ด ์์ ๋์์ ๋ ์์ํ ํ์กฐํด์ฃผ์ง ์๋๋ค.)abort
: ์ค๋จํ๋ค.
(Fail-Fast systems abort operation as-fast-as-possible exposing failures immediately and stopping the whole operation.)
๋น ๋ฅธ ์คํจ ์์คํ ์ ์คํจ์ ๋ ธ์ถ๋๋ ์ฆ์ ์๋์ ์ค๋จํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ชจ๋ ์๋์ ์ค๋จํ๋ค.basis
: ๊ธฐ์ค, ๋ฐฉ์, ๋ฐฉ๋ฒ
(These iterators throw ConcurrentModificationException on a best effort basis.)
(์ดํฐ๋ ์ดํฐ๋ ์ต์ ์ ๋คํด ๋ ธ๋ ฅํด์ ๋์์์ ์ค๋ฅ๋ฅผ ์ผ์ผํจ๋ค.)favor A over B
: A๋ฅผ B๋ณด๋ค ์ ํธํ๋ค.
(Faile-Safe Iterator favor lack of failure over the inconvenience of exception handling)
(์คํจ-์์ ์ดํฐ๋ ์ดํฐ๋ ์์ธ ํธ๋ค๋ง์ ๋ถํธ๋ณด๋ค ์คํจ๊ฐ ์๋ ๊ฒ์ ๋ ์ ํธํ๋ค.)