์ ๋ถํฐ ํฌ์คํ ํด์ผ ๊ฒ ๋ค๊ณ ์๊ฐํ๋๋ฐ ๋ฏธ๋ฃจ๋ค๊ฐ ํ๋ ํฌ์คํ
์๋ฃ์กฐ์ฌ ํ๋ ค๋ฉด ๋๋ฌด ์ค๋๊ฑธ๋ ค์ ๋ค์์ ํ๋ ค๋ค๊ฐ
์ง๊ธ ์งฌ๋ด์ ํ๋ฑ ํด ๋ฒ๋ฆฌ์
1. Map๊ณผ Set
Map๊ณผ Set์ ์๋ฐ์์ ์ปฌ๋ ์ ํ๋ ์์ํฌ(Collection Framework)์ ์ํ๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ๋ ๋ค java.utilํจํค์ง์ ํฌํจ๋์ด ์๋ค. ๊ธฐ๋ณธ ์๋ฃํ์ ์๋๊ณ ๊ฐ์ฒด๋ก ๋ค๋ฃจ์ด์ง๋ ์๋ฃ๊ตฌ์กฐ์ธ๋ฐ, Map์ key-value ํํ๋ก ๋น ๋ฅธ ๊ฒ์์ด ํ์ํ ๋๋์ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ๋ ์ ์ฉํ๊ณ , Set์ ์ค๋ณต ์๋ ๋ฐ์ดํฐ ์งํฉ์ด ํ์ํ ๋ ์ฌ์ฉ๋๋ค.
2. Map ์ด๋?
์ฌ๋์ ‘์ด๋ฆ = ์ต๋ค์ธ’, 'ํค = 165' ๋ฑ์ผ๋ก ๊ตฌ๋ถํ ์ ์๋ฏ์ด ๋งต(Map) ์ ๋์ ๊ด๊ณ๋ฅผ ์ฝ๊ฒ ํํํ ์ ์๊ฒ ํด์ฃผ๋ ์๋ฃํ์ด๋ค. ๋งต์ ๊ตฌํ์ฒด ์ค์ ๊ฐ์ฅ ์ ๋ช ํ ๊ฑด ํด์๋งต์ด๋ผ Map์ ๊ทธ๋ฅ Hash๋ผ๊ณ ๋ถ๋ฅด๋ ์ฌ๋๋ ์๋ค.
Python(ํ์ด์ฌ)์๋ Dictionary๋ผ๋ ์๋ฃ๊ตฌ์กฐ๊ฐ ์๋ฏ์ด, ๋งต๋ ์ฌ์ (dictionary)๊ณผ ๋น์ทํ๋ค. ์๋ฅผ ๋ค์ด people์ด๋ ๋จ์ด์๋ ์ฌ๋, baseball์ด๋ผ๋ ๋จ์ด์๋ ์ผ๊ตฌ๋ผ๋ ๋ป์ด ๋ถํฉ๋๋ฏ์ด ๋งต์ ํค(key)์ ๊ฐ(value)์ ํ ์์ผ๋ก ๊ฐ๋ ์๋ฃํ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
๊ทธ๋ผ Map์ ์ด๋์ ์ฐ์ด๋ฉฐ, Map์ด ๊ฐ์ง ์ฅ์ ์ด ๋ญ๊น?
๋งต์ ๋ฆฌ์คํธ๋ ๋ฐฐ์ด์ฒ๋ผ ์์ฐจ์ ์ผ๋ก(sequential) ํ ์นธ์ฉ ์ํํ๋ฉด์ ๊ฐ์ ๊ตฌํ์ง ์๋๋ค. ๊ทธ ๋์ ํค(key)๋ฅผ ์ด์ฉํด ๊ฐ(value)์ ์ป๋๋ค. ์ฐ๋ฆฌ๊ฐ pizza ์ด๋ ๋จ์ด์ ๋ป์ ์ฐพ์ ๋ ์ฌ์ ์ 1์ชฝ๋ถํฐ ๋ชจ๋ ์ฝ์ง ์๊ณ pizza์ด๋ผ๋ ๋จ์ด๊ฐ ์๋ ๊ณณ์ ์ฐพ์ ๋ฐ๋ก ํ์ธํ๋ ๊ฒ๊ณผ ๊ฐ๋ค.
3. HashMap ์ ์๋ ์๋ฆฌ
๋งต์ ์๋ฃํ(๋ณดํต ๊ตฌํ์ฒด ๋ผ๊ณ ํจ)์๋ HashMap, LinkedHashMap, TreeMap ๋ฑ์ด ์์ผ๋, ์ผ๋ฐ์ ์ผ๋ก ๊ฐ์ฅ ๋ง์ด ์ฐ์ด๋ HashMap (ํด์๋งต)๋ง ๊ฐ๋จํ ์ดํด ๋ณด์.
๊ตฌ๊ธ์ ๋ ๋๋ hashmap ๊ทธ๋ฆผ ์ค์ ๊ฐ์ฅ ์์ฃผ ๋ณด์ด๋ ๊ฒ์ ๊ฐ์ ธ์๋ค. Map์ ๊ตฌํํ ํด๋์ค๋ค์ด ๋ด๋ถ์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ด๋ป๊ฒ ์ ์ฅํ๊ณ ๊ด๋ฆฌํ๋์ง ์ดํดํ๋ ค๋ฉด, ํค(key), ๋ฒํท(bucket), ๊ทธ๋ฆฌ๊ณ ์ํธ๋ฆฌ(entry) ๊ฐ๋ ์ ์์์ผ ํ๋ค.
ํค(key)
Key๋ Map์์ ๋ฐ์ดํฐ๋ฅผ ์ฐพ์ ๋ ์ฌ์ฉํ๋ ๊ณ ์ ํ ์๋ณ์์ด๋ค, ๋ฐ๋ผ์ key๋ ์ค๋ณต๋ ์ ์์ผ๋ฉฐ, ๊ฐ ํค๋ ํ๋์ value์ ์ฐ๊ฒฐ๋๋ค. ๊ทธ๋์ key๋ ๋ฐ์ดํฐ ์กฐํ, ์ถ๊ฐ, ์ญ์ ์ ๊ธฐ์ค์ด ๋๋ฉฐ, Map์์ ํน์ ๊ฐ์ ๊ฐ์ ธ์ค๋ ค๋ฉด key๋ฅผ ์ฌ์ฉํ๋ค.
๋ฒํท(Bucket)
HashMap์ ํด์ ํ ์ด๋ธ์ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋๋ฐ, key๋ ํด์ ํจ์์ ์ํด ํน์ ๋ฒํท ๋ฒํธ๋ก ๋งคํ๋๋ค. ์ฆ, ๋ด๋ถ์ ์ผ๋ก Map์key๋ฅผ ํด์ ๊ฐ์ผ๋ก ๋ณํํ ํ, ์ด๋ฅผ ์ฌ๋ฌ ๊ฐ์ "๋ฒํท(Bucket)"์ผ๋ก ๋๋์ด ์ ์ฅํ๋ค. ๋ฒํท์ Map์ด ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ๊ฒ์ํ๊ณ ๊ด๋ฆฌํ ์ ์๋๋ก ๋์์ฃผ๋ ๋ฐฐ์ด ๋๋ ๋ฆฌ์คํธ ํํ์ ๊ณต๊ฐ์ฏค์ด๋ผ๊ณ ์๊ณ ์์ผ๋ฉด ๋๋ค.
์ํธ๋ฆฌ(Entry)
Entry๋ key์ value๋ฅผ ํ๋์ ์ํธ๋ฆฌ๋ก ๋ฌถ์ ๊ฒ์ด๋ค. Map.Entry๋ ์๋ฐ์์ Map ์ธํฐํ์ด์ค ๋ด๋ถ์ ์ ์๋ ์ธํฐํ์ด์ค๋ก, ์ด ๊ฐ์ฒด๋ key์ value๋ฅผ ๊ฐ๊ฐ getKey()์ getValue() ๋ฉ์๋๋ก ๋ฐํํด ์ค๋ค. ํ ๋ง๋๋ก ์ํธ๋ฆฌ๋ HashMap ์์ ์๋ ๊ฐ๋ค์ ์กฐํํด์ ๊ฐ์ง๊ณ ์ค๋ ์ญํ ์ ํ๋ค. ์๋ฅผ ๋ค์ด, entrySet() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด Set<Map.Entry<K, V>> ํํ๋ก ๊ฐ์ ธ์จ๋ค.
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
4. HashMap ์ฃผ์ ๋ฉ์๋
4-1. put
Map์ key์ value๋ฅผ ์ถ๊ฐํ๋ ๋ฉ์๋
map.put("key", "value");
map.put("people", "์ฌ๋");
import java.util.HashMap;
public class Sample {
public static void main(String[] args) {
// 1. HashMap์ ArrayList์ฒ๋ผ ์ ๋ค๋ฆญ์ค<>๋ฅผ ์ด์ฉํด ์ ์ธํ๋ค
HashMap<String, String> map = new HashMap<>();
map.put("people", "์ฌ๋");
map.put("pizza", "ํผ์");
}
}
4-2. get
get ๋ฉ์๋๋ key์ ํด๋นํ๋ value๋ฅผ ์ป์ ๋ ์ฌ์ฉํ๋ค.
map.get("Key")
map.get("people")
import java.util.HashMap;
public class Sample {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("people", "์ฌ๋");
map.put("piza", "ํผ์");
System.out.println(map.get("people"));
// key์ธ people์ ๋์ํ๋ value์ธ "์ฌ๋" ์ถ๋ ฅ
}
}
4-3. getOrDefault
map.getOrDefault("key", "๊ธฐ๋ณธ๊ฐ")
๋งต์ key์ ํด๋นํ๋ value๊ฐ ์์ ๋ get ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด null๊ฐ์ด ๋ฆฌํด๋๋ค. ์ด๋ฅผ ๋ฐฉ์งํ๊ณ ์ ํ ๋ ๊ธฐ๋ณธ๊ฐ์ ์ค์ ํด์ฃผ๋ ์ฉ๋๋ก ์ฌ์ฉํ๋ ๋ฉ์๋๊ฐ getOrDefault์ด๋ค. map์ ์ฑ๋ณ๊ฐ์ ๋งคํํด ์ฃผ์ง ์์ ๊ฒฝ์ฐ, ์ฑ๋ณ์ ์กฐํํ๋ฉด null๊ฐ์ด ๋ฆฌํด๋๋ค.
System.out.println(map.get("gender")); // null ์ถ๋ ฅ
null ๋์ ๊ธฐ๋ณธ๊ฐ(default)์ ์ป๊ณ ์ถ๋ค๋ฉด getOrDefault ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ์ฃผ๋ฉด ๋๋ค. ์ฑ๋ณ์ ์ง์ ํ์ง ์์ ๊ฒฝ์ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ๋จ์ฑ์ผ๋ก ์ถ๋ ฅ ํด ์ฃผ๊ณ ์ถ๋ค๋ฉด ์๋์ ๊ฐ์ด ์ ๋ ฅํด ์ฃผ๋ฉด ๋๋ค.
System.out.println(map.getOrDefault("gender", "๋จ์ฑ")); // "๋จ์ฑ" ์ถ๋ ฅ
4-4. containsKey
containsKey ๋ฉ์๋๋ ๋งต์ ํด๋น key๊ฐ ์๋์ง ์ฌ๋ถ๋ฅผ boolean : ์ฐธ(true) ๋๋ ๊ฑฐ์ง(false)์ผ๋ก ๋ฆฌํดํ๋ค.
import java.util.HashMap;
public class Sample {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("people", "์ฌ๋");
map.put("piza", "ํผ์");
System.out.println(map.containsKey("people"));
// people ์ด๋ผ๋ key๊ฐ ์กด์ฌํ๋ฏ๋ก true ์ถ๋ ฅ
}
}
4-5. remove
remove ๋ฉ์๋๋ ๋งต์ ํญ๋ชฉ์ ์ญ์ ํ๋ ๋ฉ์๋๋ก, ํด๋น key์ ํญ๋ชฉ์ ์ญ์ ํ ํ value ๊ฐ์ ๋ฆฌํดํ๋ค.
import java.util.HashMap;
public class Sample {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("people", "์ฌ๋");
map.put("piza", "ํผ์");
System.out.println(map.remove("people"));
// people์ ํด๋น๋๋ key์ value๊ฐ ๋ชจ๋ ์ญ์ ๋ ํ "์ฌ๋" ์ถ๋ ฅ
}
}
4-6. size
size ๋ฉ์๋๋ ๋งต ์์์ ๊ฐ์๋ฅผ ๋ฆฌํดํ๋ค. (ArrayList ์ฌ์ด์ฆ ๋ฆฌํดํ๋ ๊ฒ๊ณผ ๋น์ท)
import java.util.HashMap;
public class Sample {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("people", "์ฌ๋");
map.put("piza", "ํผ์");
System.out .println(map.remove(“people”)); // ์ฌ๋ ์ถ๋ ฅ ํ ํด๋น ํค๊ฐ ์ญ์
System.out.println(map.size()); // 1 ์ถ๋ ฅ
}
}
people, pizza ๋ ๊ฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ค๊ฐ people์ด ์ญ์ ๋์ด 1์ ์ถ๋ ฅํ๋ค.
4-7. keySet
keySet() ๋ฉ์๋๋ ๋งต์ ๋ชจ๋ key๋ฅผ ๋ชจ์์ ์งํฉ ์๋ฃํ(set)์ผ๋ก ๋ฆฌํดํ๋ค.
import java.util.HashMap;
public class Sample {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("people", "์ฌ๋");
map.put("pizza", "ํผ์");
System.out.println(map.keySet()); // [people, pizza] ์ถ๋ ฅ
}
}
HashMap์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ์ง ์๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค. HashMap์ ์ ์ฅ๋ key-value ์๋ค์ ์ ๋ ฅ ์์๋๋ก ๋ฐํ๋์ง ์์ผ๋ฉฐ, keySet() ๋ฉ์๋๋ฅผ ํธ์ถํ ๋๋ ํน์ ์์๊ฐ ๋ณด์ฅ๋์ง๋ ์๋๋ค.
๊ทธ๋์ System.out.println(map.keySet());์ด ์ถ๋ ฅํ ๊ฐ์ ["people", "pizza"]์ ๊ฐ์ ์งํฉ์ด๊ธฐ๋ ํ์ง๋ง, people๊ณผ pizza ์ค์์ ์ด๋ ๊ฒ์ด ๋จผ์ ์ถ๋ ฅ๋ ์ง๋ ์์ธกํ ์ ์๋ค. ๊ทธ ์ด์ ๋ HashMap ๋ด๋ถ์์ key๋ค์ด ์ด๋ป๊ฒ ํด์ ํ ์ด๋ธ์ ์ ์ฅ๋์๋์ง์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๊ธฐ ๋๋ฌธ์ด๋ค.
keySet()์ผ๋ก ์ป์ ๊ฒฐ๊ณผ๊ฐ์ ArrayList๋ก ๋ณํํด์ ์ฌ์ฉํ ์ ์๋ค.
ArrayList<String> keyList = new ArrayList<>(map.keySet());
5. Set ์ด๋?
- Map: ํค์ ๊ฐ์ด ์ฐ๊ด๋์ด ์ ์ฅ๋๋ฉฐ, ํน์ ํค๋ฅผ ํตํด ๊ฐ์ ๋น ๋ฅด๊ฒ ์กฐํํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ
- Set: ์ค๋ณต์ ํ์ฉํ์ง ์๋ ๋ฐ์ดํฐ ์งํฉ์ ๊ด๋ฆฌํ๋ ๋ฐ ์ฌ์ฉ๋๋ฉฐ, ์ค๋ณต ์ ๊ฑฐ๋ฅผ ์ํ ํํฐ ์ญํ ์ ํ๊ฑฐ๋ ๊ฐ์ ์กด์ฌ ์ฌ๋ถ๋ฅผ ํ์ธํ ๋ ์ ์ฉํ๋ค.
์๋ฐ์์ set์ ๋ค๋ฅธ ๋ง๋ก ์งํฉ์ด๋ผ๊ณ ํ๋ค. ์์์ ๋ณธ map๊ณผ ๋ฐ๋๋ก set์๋ ๋ ๊ฐ์ง ํน์ง์ด ์๋๋ฐ,
- ์ค๋ณต์ ํ์ฉํ์ง ์๋๋ค.
- ์์๊ฐ ์๋ค(unordered).
6. Map๊ณผ Set ๋น๊ต
๊ทธ๋ ๋ค๋ฉด set ์๋ฃํ ์ค ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ HashSet์ ๋ํด ๊ฐ๋จํ ์์๋ณด์.
7. Set์ผ๋ก ๊ต์งํฉ, ์ฐจ์งํฉ, ํฉ์งํฉ ๊ตฌํ๊ธฐ
์๋ ๋ด์ฉ์ ์ ํ ํฌ ์๋ฐ์์ ๊ทธ๋๋ก ๋ฐ์ทํ ์ฝ๋์ ์์ ์ ๋๋ค.
๋จผ์ ์๋์ฒ๋ผ s1, s2 ๋ผ๋ ์งํฉ ์๋ฃํ์ ๋ ๊ฐ ์ ์ธ ํด ์ฃผ์๋ค
s1์ ๋ฒ์๋ ๋ถํฐ 6๊น์ง, s2๋ 4๋ถํฐ 9๊น์ง์ด๋ค.
set์ด ๊ฐ์ง ๋ฉ์๋๋ฅผ ํตํด ๋ ์งํฉ์ ๊ต์งํฉ, ์ฐจ์งํฉ, ํฉ์งํฉ์ ๊ตฌํด๋ณด์.
import java.util.Arrays;
import java.util.HashSet;
public class Sample {
public static void main(String[] args) {
// ๋จผ์ set ์๋ฃํ ๋ ๊ฐ๋ฅผ ์ ์ธํด์ฃผ์
HashSet<Integer> s1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5, 6));
HashSet<Integer> s2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8, 9));
}
}
7-1. ๊ต์งํฉ (retainAll ๋ฉ์๋)
retainAll ๋ฉ์๋๋ก ๊ต์งํฉ์ ์ํ
import java.util.Arrays;
import java.util.HashSet;
public class Sample {
public static void main(String[] args) {
HashSet<Integer> s1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5, 6));
HashSet<Integer> s2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8, 9));
HashSet<Integer> intersection = new HashSet<>(s1); // s1์ผ๋ก intersection ์์ฑ
intersection.retainAll(s2); // ๊ต์งํฉ ์ํ
System.out.println(intersection); // [4, 5, 6] ์ถ๋ ฅ
}
}
retainAll ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ฉด ๊ต์งํฉ์ ์ฝ๊ฒ ๊ตฌํ ์ ์๋ค.
ํ์ง๋ง
retainAll ๋ฉ์๋๋ ํธ์ถํ ์ปฌ๋ ์ ์์ ์ฃผ์ด์ง ์ปฌ๋ ์ ์ ๊ต์งํฉ์ ํด๋นํ๋ ์์๋ค๋ง ๋จ๊ธฐ๊ณ ๋๋จธ์ง๋ ๋ชจ๋ ์ญ์ ํ๋ ๋ฉ์๋์ด๋ค. s1์ ์ง์ retainAll(s2)๋ฅผ ํธ์ถํ๋ฉด s1์ ๋ด์ฉ์ด ๊ต์งํฉ์ ํด๋นํ๋ ๊ฐ๋ค๋ง ๋จ๋๋ค. ์ฆ retainAll์ ์๋ณธ ์ปฌ๋ ์ ์ธ s1๋ฅผ ์์ ํ๊ธฐ ๋๋ฌธ์, s1์ ๊ทธ๋๋ก ์ ์งํ๊ธฐ ์ฐํด intersection์ด๋ผ๋ ํด์์ ์ ๋ณ๋๋ก ์ ์ธํด์ ๊ต์งํฉ์ ์ํํด ์ฃผ์๋ค.
7-2. ํฉ์งํฉ (addAll ๋ฉ์๋)
ํฉ์งํฉ์ addAll ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
์ ๊ทธ๋ฆผ์์ 4, 5, 6์ฒ๋ผ ์ค๋ณตํด์ ํฌํจ๋ ๊ฐ์ ํ ๊ฐ์ฉ๋ง ํํ๋๋ค.
import java.util.Arrays;
import java.util.HashSet;
public class Sample {
public static void main(String[] args) {
HashSet<Integer> s1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5, 6));
HashSet<Integer> s2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8, 9));
HashSet<Integer> union = new HashSet<>(s1); // s1์ผ๋ก union ์์ฑ
union.addAll(s2); // ํฉ์งํฉ ์ํ
System.out.println(union); // [1, 2, 3, 4, 5, 6, 7, 8, 9] ์ถ๋ ฅ
}
}
์ฌ๊ธฐ์ addAll ๋ฉ์๋์ ๋ ๋ค๋ฅธ ์ฐ์ **
๊ฐ์ ํ๊บผ๋ฒ์ ์ฌ๋ฌ ๊ฐ ์ถ๊ฐํ ๋๋ addAll ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
๊ฐ์ ์ญ์ ํ ๋๋ set.remove ๋ฉ์๋๋ฅผ ์จ ์ค๋ค.
import java.util.Arrays;
import java.util.HashSet;
public class Sample {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("Hello");
set.addAll(Arrays.asList("World", "!"));
System.out.println(set); // [Hello, World, !] ์ถ๋ ฅ
set.remove("!");
System.out.println(set); // [Hello, World] ์ถ๋ ฅ
}
}
7-3. ์ฐจ์งํฉ (removeAll ๋ฉ์๋)
์ฐจ์งํฉ์ removeAll ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
import java.util.Arrays;
import java.util.HashSet;
public class Sample {
public static void main(String[] args) {
HashSet<Integer> s1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5, 6));
HashSet<Integer> s2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8, 9));
HashSet<Integer> substract = new HashSet<>(s1); // s1์ผ๋ก substract ์์ฑ
substract.removeAll(s2); // ์ฐจ์งํฉ ์ํ
System.out.println(substract); // [1, 2, 3] ์ถ๋ ฅ
}
}
8. TreeSet๊ณผ LinkedHashSet
์งํฉ ์๋ฃํ์ ํน์ง์ ์์๊ฐ ์๋ค๋ ๊ฒ์ด๋ค. ๊ทธ๋ฐ๋ฐ ์งํฉ์ ์ ๋ ฅํ ์์๋๋ก ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๊ฑฐ๋ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๊ณ ์ถ์ ์ ์๋ค. ์ด๋ด ๋ ์ฌ์ฉํ๋ ๊ฒ์ด TreeSet๊ณผ LinkedHashSet์ด๋ค.
- TreeSet : ๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด ์ ์ฅํ๋ค.
- LinkedHashSet : ๊ฐ์ ์ ๋ ฅํ ์์๋๋ก ์ ๋ ฌํ๋ค.
ํฌ์คํ ์ ์ฐธ์กฐํ ์๋ฃ
- chatGPT์ ๊ตฌ๊ธ ๊ฒ์ (์ด๋ฏธ์ง๋ ์ฝ๋ ์ถ์ฒ ๊ฐ๊ฐ ํ๊ธฐํ์์)
- ๋ฐ์์ฉ JUMP TO JAVA
- ๋ด ๋จธ๋ฆฟ์ ใ ใ ใ
๋ถํ๊ธ์ง ํฌ์คํ ํ๋๋ฐ 2์๊ฐ ๊ฑธ๋ฆผ
'Coding > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ๋ฐฐ์ด ์ฌ์ฉ์์ ์ ์ ๋ ฌํ๋ ๋ฒ(๋ด๋ฆผ์ฐจ์, ๋๋ค์) (4) | 2024.11.12 |
---|---|
[Java] JDBC ์ค๋ผํด์ด๋ ์๋ฐ ์ฐ๋ (31) | 2024.11.04 |
[Java] ์๋ฐ์์ map์ ์ค์ ๊ฐ๋ฐ์์ ์ด๋์ ์ฐ์ผ๊น? (18) | 2024.11.03 |
[Java] ์๋ฐ ์ฝ๋๊ฐ ์คํ๋๋ ๊ณผ์ & JVM & ๋ฉ๋ชจ๋ฆฌ (13) | 2024.11.03 |
[Java] ArrayList, ์ ๋ค๋ฆญ์ค(Generics), ์ ๋ ฌ, Join, String.join ์ ๋ฆฌ (8) | 2024.11.03 |