CodeGym /Java Blog /๋ฌด์ž‘์œ„์˜ /Java์˜ LinkedHashSet
John Squirrels
๋ ˆ๋ฒจ 41
San Francisco

Java์˜ LinkedHashSet

๋ฌด์ž‘์œ„์˜ ๊ทธ๋ฃน์— ๊ฒŒ์‹œ๋˜์—ˆ์Šต๋‹ˆ๋‹ค
Java์˜ LinkedHashSet ํด๋ž˜์Šค ์— ๋Œ€ํ•ด ๋งํ•˜์ž๋ฉด Set ์ธํ„ฐํŽ˜์ด์Šค ๋ฅผ ๊ตฌํ˜„ํ•œ๋‹ค๋Š” ์ ์„ ์–ธ๊ธ‰ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค . LinkedHashSet์€ ํ•ด์‹œ ํ…Œ์ด๋ธ”์— ์š”์†Œ๋ฅผ ์ €์žฅํ•˜๋Š” ์ปฌ๋ ‰์…˜์„ ์ƒ์„ฑํ•˜์ง€๋งŒ ํ•ด๋‹น HashSet ๋Œ€์‘ ์š”์†Œ์™€ ๋‹ฌ๋ฆฌ ์š”์†Œ์˜ ์‚ฝ์ž… ์ˆœ์„œ๋ฅผ ์œ ์ง€ํ•ฉ๋‹ˆ๋‹ค.

Java์—์„œ ์„ค์ •๋˜๋Š” ๊ฒƒ

Set ์ธํ„ฐํŽ˜์ด์Šค๊ฐ€ ์ง‘ํ•ฉ(์ง‘ํ•ฉ)์„ ์ •์˜ํ•œ๋‹ค๋Š” ๊ฒƒ์„ ๊ฐ„๋‹จํžˆ ๊ธฐ์–ตํ•ด ๋ด…์‹œ๋‹ค . ์ปฌ๋ ‰์…˜์„ ํ™•์žฅ ํ•˜๊ณ  ์ค‘๋ณต ์š”์†Œ๋ฅผ ํ—ˆ์šฉํ•˜์ง€ ์•Š๋Š” ์ปฌ๋ ‰์…˜์˜ ๋™์ž‘์„ ์ •์˜ํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ add() ๋ฉ”์„œ๋“œ๋Š” ์ง‘ํ•ฉ์— ์ค‘๋ณต ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋ ค๊ณ  ํ•˜๋ฉด false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์ธํ„ฐํŽ˜์ด์Šค๋Š” ์ž์ฒด์ ์œผ๋กœ ์ถ”๊ฐ€ ๋ฉ”์„œ๋“œ๋ฅผ ์ •์˜ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. Set ์ธํ„ฐํŽ˜์ด์Šค๋Š” ์ €์žฅ๋œ ๊ฐ์ฒด์˜ ๊ณ ์œ ์„ฑ์„ ๊ด€๋ฆฌํ•˜๋ฉฐ ๊ณ ์œ ์„ฑ ์€ equals() ๋ฉ”์„œ๋“œ ์˜ ๊ตฌํ˜„์— ์˜ํ•ด ๊ฒฐ์ •๋ฉ๋‹ˆ๋‹ค . ๋”ฐ๋ผ์„œ ์ƒ์„ฑ๋œ ํด๋ž˜์Šค์˜ ๊ฐ์ฒด๋ฅผ Set ์— ์ถ”๊ฐ€ํ•  ๊ฒฝ์šฐ equals() ๋ฉ”์„œ๋“œ๋ฅผ ์˜ค๋ฒ„๋ผ์ด๋“œํ•˜๋Š” ๊ฒƒ์ด ๋ฐ”๋žŒ์งํ•˜๋‹ค .

LinkedHashSet ํด๋ž˜์Šค

LinkedHashSet ํด๋ž˜์Šค ์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•˜๊ธฐ ์ „์— ๊ฐ€๊นŒ์šด ์นœ์ฒ™์ธ HashSet ํด๋ž˜์Šค ๋ฅผ ์–ธ๊ธ‰ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค . HashSet์€ Set ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๊ตฌํ˜„ํ•ฉ๋‹ˆ๋‹ค . ํ•ด์‹œ ํ…Œ์ด๋ธ”์— ์š”์†Œ๋ฅผ ์ €์žฅํ•˜๋Š” ์ปฌ๋ ‰์…˜์„ ๋งŒ๋“ญ๋‹ˆ๋‹ค. ํ•ด์‹œ ํ…Œ์ด๋ธ”์˜ ์š”์†Œ๋Š” ํ‚ค-๊ฐ’ ์Œ์œผ๋กœ ์ €์žฅ๋ฉ๋‹ˆ๋‹ค. ํ‚ค๋Š” ๊ฐ’์„ ์ €์žฅํ•  ์…€(๋˜๋Š” ์„ธ๊ทธ๋จผํŠธ)์„ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค. ํ‚ค์˜ ๋‚ด์šฉ์€ ํ•ด์‹œ ์ฝ”๋“œ๋ผ๋Š” ๊ณ ์œ ํ•œ ๊ฐ’์„ ๊ฒฐ์ •ํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ํ•ด์‹œ ์ฝ”๋“œ๊ฐ€ ๊ณ ์œ ํ•  ํ•„์š”๋Š” ์—†์ง€๋งŒ ๊ฐœ์ฒด ์‹๋ณ„์ž๋กœ ์ƒ๊ฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ํ•ด์‹œ ์ฝ”๋“œ๋Š” ํ‚ค์™€ ๊ด€๋ จ๋œ ๋ฐ์ดํ„ฐ๊ฐ€ ์ €์žฅ๋˜๋Š” ์ธ๋ฑ์Šค ์—ญํ• ๋„ ํ•ฉ๋‹ˆ๋‹ค. LinkedHashSet Java ํด๋ž˜์Šค๋Š” ์ƒˆ ๋ฉ”์„œ๋“œ๋ฅผ ์ถ”๊ฐ€ํ•˜์ง€ ์•Š๊ณ  HashSet์„ ํ™•์žฅํ•ฉ๋‹ˆ๋‹ค.LinkedHashSet์„ ์‚ฌ์šฉํ•˜๋ฉด HashSet ๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ํ•ญ๋ชฉ์˜ ์กด์žฌ๋ฅผ ๋น ๋ฅด๊ฒŒ ํ™•์ธํ•  ์ˆ˜ ์žˆ์ง€๋งŒ ๋‚ด๋ถ€์— ์ •๋ ฌ๋œ ๋ชฉ๋ก์ด ํฌํ•จ๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค. ์ฆ‰, ์š”์†Œ์˜ ์‚ฝ์ž… ์ˆœ์„œ๋ฅผ ์ €์žฅํ•ฉ๋‹ˆ๋‹ค. ์ฆ‰, LinkedHashSet์€ ์‚ฝ์ž…๋œ ์ˆœ์„œ๋Œ€๋กœ ์ง‘ํ•ฉ ์š”์†Œ์˜ ์—ฐ๊ฒฐ๋œ ๋ชฉ๋ก์„ ์œ ์ง€ํ•ฉ๋‹ˆ๋‹ค. ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ์„ธํŠธ์— ์ˆœ์„œ๋Œ€๋กœ ์‚ฝ์ž…ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ์ด๋กœ ์ธํ•ด LinkedHashSet ํด๋ž˜์Šค๊ฐ€ HashSet ํด๋ž˜์Šค ๋ณด๋‹ค ๋” ๊ธด ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค .

LinkedHashSet์˜ ์ค‘์š”ํ•œ ๊ธฐ๋Šฅ

  • LinkedHashSet ์—๋งŒ ๊ณ ์œ ํ•œ ์š”์†Œ๋ฅผ ์ €์žฅํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

  • LinketHashSet์„ ์‚ฌ์šฉํ•˜๋ฉด ์‚ฝ์ž…ํ•œ ์ˆœ์„œ๋Œ€๋กœ ์š”์†Œ๋ฅผ ์ถ”์ถœํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

  • LinkedHashSet์ด ๋™๊ธฐํ™”๋˜์ง€ ์•Š์Œ

  • LinkedHashSet์€ null ์š”์†Œ๋ฅผ ์ €์žฅํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

  • LinkedHashSet์€ ํ•ด์‹ฑ ๊ธฐ์ˆ ์„ ์‚ฌ์šฉํ•˜์—ฌ ํ•ด์‹œ ์ฝ”๋“œ๋ฅผ ๊ธฐ๋ฐ˜์œผ๋กœ ์ง€์ •๋œ ์ธ๋ฑ์Šค์— ์š”์†Œ๋ฅผ ์ €์žฅํ•ฉ๋‹ˆ๋‹ค.

LinkedHashSet ๋ฉ”์„œ๋“œ

๋ถ€๋ชจ ํด๋ž˜์Šค์—์„œ ์ƒ์†๋œ ๋ฉ”์„œ๋“œ ์™ธ์—๋„ HashSet์€ ๋‹ค์Œ ๋ฉ”์„œ๋“œ๋ฅผ ์ •์˜ํ•ฉ๋‹ˆ๋‹ค.
  • boolean add(Object o)๋Š” ์ง€์ •๋œ ์š”์†Œ๊ฐ€ ์•„์ง ์กด์žฌํ•˜์ง€ ์•Š๋Š” ๊ฒฝ์šฐ ์ด ์„ธํŠธ์— ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.

  • void clear()๋Š” ์ด ์„ธํŠธ์—์„œ ๋ชจ๋“  ์š”์†Œ๋ฅผ โ€‹โ€‹์ œ๊ฑฐํ•ฉ๋‹ˆ๋‹ค.

  • Object clone()์€ ์ด LinkedHashSet ์ธ์Šคํ„ด์Šค ์˜ ์–•์€ ๋ณต์‚ฌ๋ณธ์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค . ์š”์†Œ ์ž์ฒด๋Š” ๋ณต์ œ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

  • boolean contains(Object o)๋Š” ์ด ์ง‘ํ•ฉ์— ์ง€์ •๋œ ์š”์†Œ๊ฐ€ ํฌํ•จ๋˜์–ด ์žˆ์œผ๋ฉด true๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

  • ๋ถ€์šธ isEmpty()๋Š” ์ด ์ง‘ํ•ฉ์— ์š”์†Œ๊ฐ€ ์—†์œผ๋ฉด true๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค .

  • Iterator iterator()๋Š” ์ด ์ง‘ํ•ฉ์˜ ์š”์†Œ์— ๋Œ€ํ•œ ๋ฐ˜๋ณต์ž๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

  • boolean remove(Object o)๋Š” ์ด ์„ธํŠธ์—์„œ ์ง€์ •๋œ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•ฉ๋‹ˆ๋‹ค(์กด์žฌํ•˜๋Š” ๊ฒฝ์šฐ).

  • int size()๋Š” ์ด ์ง‘ํ•ฉ์˜ ์š”์†Œ ์ˆ˜(์š”์†Œ ์ˆ˜)๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

์‰ฌ์šด LinkedHashSet ์˜ˆ์ œ ์•„๋ž˜ ์˜ˆ์ œ์—์„œ๋Š” LinkedHashSet ๊ฐœ์ฒด์˜ ์ดˆ๊ธฐํ™”์™€ add() ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ง‘ํ•ฉ์„ ์ฑ„์šฐ๋Š” ๋ฐฉ๋ฒ•์„ ๋ณด์—ฌ์ค๋‹ˆ๋‹ค.

import java.util.LinkedHashSet;
import java.util.Set;

   public class LinkedHashSetEx1 {
       public static void main(String[] args) {
//LinkedHashSet() Init            
Set<String> set = new LinkedHashSet<>();
//adding elements to LinkedHashSet 
           set.add("Re"); //first added element 
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");//last added element  


           System.out.println(set);
       }
   }
์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
[๋ ˆ, ๋„, ํŒŒ, ์†”, ๋ผ, ํ‹ฐ, ๋ฏธ]
๋ณด์‹œ๋‹ค์‹œํ”ผ ์„ธํŠธ์˜ ์š”์†Œ๋Š” ๋ฐฐ์น˜ํ•œ ๊ฒƒ๊ณผ ๋™์ผํ•œ ์ˆœ์„œ๋กœ ๋‚˜ํƒ€๋‚ฉ๋‹ˆ๋‹ค. Java์˜ LinkedHashSet - 1

์˜ˆ 2. LinkedHashSet์— ๋ณต์ œ ํ•ญ๋ชฉ ์ถ”๊ฐ€

์•…๋ณด ์ด๋ฆ„์ด ์žˆ๋Š” LinkedHashSet 7 ์š”์†Œ๋ฅผ ๋‹ค์‹œ ๋„ฃ๊ณ  ์ด์ „์— ๋ฐฐ์น˜ํ•œ ์š”์†Œ ์ค‘ ํ•˜๋‚˜์™€ ๋™์ผํ•œ ์ƒˆ ์š”์†Œ๋ฅผ ํ•˜๋‚˜ ๋„ฃ์Šต๋‹ˆ๋‹ค.

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetEx2 {
   public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("Re");
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");
           set.add("Sol");
           System.out.println(set);
       }
   }
ํ”„๋กœ๊ทธ๋žจ์˜ ์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
[๋ ˆ, ๋„, ํŒŒ, ์†”, ๋ผ, ํ‹ฐ, ๋ฏธ]
์˜ˆ์ œ 2์˜ ์ถœ๋ ฅ์€ ์ฒซ ๋ฒˆ์งธ ์˜ˆ์ œ์™€ ์™„์ „ํžˆ ๋™์ผํ•ฉ๋‹ˆ๋‹ค. LinkedHashSet ์ปฌ๋ ‰์…˜ ์—๋Š” ๋‘ ๊ฐœ์˜ ์œ ์‚ฌํ•œ ์š”์†Œ๊ฐ€ ์žˆ์„ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค . ๋‘ ๋ฒˆ์งธ ๊ฒƒ์„ ๋„ฃ์œผ๋ ค๊ณ  ํ•˜๋ฉด ๊ทธ๋ƒฅ ๋ฌด์‹œ๋ฉ๋‹ˆ๋‹ค.

์˜ˆ 3. LinkedHashSet์—์„œ ์š”์†Œ ์ œ๊ฑฐ


import java.util.LinkedHashSet;
import java.util.Set;
   public class LinkedHashSet3 {
       public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("Re");
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");
           System.out.println(set);
           set.remove("Fa");// removing an element from our set
           set.remove("Score");//trying to remove element that isn't in set
           System.out.println(set.remove("Score"));
           System.out.println("Print our set without elements removed: ");
           System.out.println(set);
           set.clear();
           System.out.println("Print out our set after clear command: ");
           System.out.println(set);
       }
   }
ํ”„๋กœ๊ทธ๋žจ์˜ ์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
[Re, Do, Fa, Sol, La, Ti, Mi] false ์ œ๊ฑฐ๋œ ์š”์†Œ ์—†์ด ์„ธํŠธ ์ธ์‡„: [Re, Do, Sol, La, Ti, Mi] ์ง€์šฐ๊ธฐ ๋ช…๋ น ํ›„ ์„ธํŠธ ์ธ์‡„: []
๋ณด๋‹ค ์‹œํ”ผ ์กด์žฌํ•˜์ง€ ์•Š๋Š” ์š”์†Œ์— ์ ์šฉ๋œ remove() ๋ฉ”์„œ๋“œ๋Š” ํ”„๋กœ๊ทธ๋žจ ์˜ค๋ฅ˜๋ฅผ ์ผ์œผํ‚ค์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์š”์†Œ๊ฐ€ ์ œ๊ฑฐ๋˜์ง€ ์•Š์€ ๊ฒฝ์šฐ ๋‹จ์ˆœํžˆ false๋ฅผ ๋ฐ˜ํ™˜ํ•˜๊ณ  ์š”์†Œ๊ฐ€ LinkedHashSet ์— ์žˆ๋‹ค๊ฐ€ ์ œ๊ฑฐ๋œ ๊ฒฝ์šฐ true๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค .

LinkedHashSet ๋Œ€ HashSet

์ด ๋‘ ํด๋ž˜์Šค๋Š” ๊ฐ€๊นŒ์šด ์นœ์ฒ™์ž…๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ HashSet ๋‚ด๋ถ€์—์„œ๋Š” HashMap์„ ์‚ฌ์šฉํ•˜์—ฌ ๊ฐœ์ฒด๋ฅผ ์ €์žฅํ•˜๊ณ  LinkedHashSet์€ LinkedHashMap์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค . ์‚ฝ์ž… ์ˆœ์„œ๋ฅผ ์œ ์ง€ํ•  ํ•„์š”๊ฐ€ ์—†์ง€๋งŒ ๊ณ ์œ ํ•œ ๊ฐœ์ฒด๋ฅผ ์ €์žฅํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ HashSet์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ๋” ์ ํ•ฉํ•ฉ๋‹ˆ๋‹ค . ์š”์†Œ์˜ ์‚ฝ์ž… ์ˆœ์„œ๋ฅผ ์œ ์ง€ํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ LinkedHashSet์„ ์„ ํƒํ•ฉ๋‹ˆ๋‹ค. LinkedHashSet์€ ๋‚ด๋ถ€ LinkedList๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์š”์†Œ์˜ ์‚ฝ์ž… ์ˆœ์„œ๋ฅผ ์œ ์ง€ํ•˜๊ธฐ ๋•Œ๋ฌธ์— LinkedHashSet ์˜ ์„ฑ๋Šฅ์€ HashSet ๋ณด๋‹ค ์•ฝ๊ฐ„ ๋Š๋ฆฝ๋‹ˆ๋‹ค . ์˜ˆ๋ฅผ ๋“ค์–ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

import java.util.*;

public class LinkedHashSetExample1 {

   public static void main(String[] args) {
       // while regular hash set orders its elements according to its hashcode stamps

       Set<Integer> regularHashSet = new HashSet<>();
       regularHashSet.add(7);
       regularHashSet.add(3);
       regularHashSet.add(5);
       regularHashSet.add(65536);
       regularHashSet.add(9);
       // few duplicates
       regularHashSet.add(5);
       regularHashSet.add(7);

       // next will print:
       // > regularHashSet = [65536, 3, 5, 7, 9]
       System.out.println("regularHashSet = " + regularHashSet);

       // linked hash set keeps order of adding unchanged

       Set<Integer> linkedHashSet = new LinkedHashSet<>();
       linkedHashSet.add(7);
       linkedHashSet.add(3);
       linkedHashSet.add(5);
       linkedHashSet.add(65536);
       linkedHashSet.add(9);
       // few duplicates
       linkedHashSet.add(5);
       linkedHashSet.add(7);

       // next will print:
       // > linkedHashSet = [7, 3, 5, 65536, 9]
       System.out.println("linkedHashSet = " + linkedHashSet);
   }
}
ํ”„๋กœ๊ทธ๋žจ์˜ ์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
regularHashSet = [65536, 3, 5, 7, 9] linkedHashSet = [7, 3, 5, 65536, 9]

์‹ค์ œ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์—์„œ Java LinkedHashSet ์‚ฌ์šฉ

LinkedHashSet์„ ์‚ฌ์šฉํ•˜๋ฉด ํ•ญ๋ชฉ์˜ ์กด์žฌ๋ฅผ ๋น ๋ฅด๊ฒŒ ํ™•์ธํ•˜๊ณ  ์ฃผ๋ฌธ๋„ ์ €์žฅํ•  ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ ์ด ์ปฌ๋ ‰์…˜์€ ๋ชฉ๋ก์—์„œ ์ค‘๋ณต ํ•ญ๋ชฉ์„ ์ œ๊ฑฐํ•˜๋Š” ๋ฐ ๋งค์šฐ ํŽธ๋ฆฌํ•ด ๋ณด์ž…๋‹ˆ๋‹ค. ๋˜๋Š” ์˜ˆ๋ฅผ ๋“ค์–ด ๋‚ด ๊ฐ€๋ฐฉ์—์„œ ๊ฐ€์žฅ ์ตœ๊ทผ์— ๋ณธ ํ•ญ๋ชฉ๊ณผ ๊ฐ™์€ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•ฉ๋‹ˆ๋‹ค. ์•„๋‹ˆ๋ฉด ๊ทธ๋Ÿฐ ๊ฒŒ์ž„, Pokemon Go๋ฅผ ๊ธฐ์–ตํ•˜์‹ญ๋‹ˆ๊นŒ? LinkedHashSet์€ ๋‹น์‹ ์ด ๋งŒ๋‚œ ํฌ์ผ“๋ชฌ ๋ชฉ๋ก๊ณผ ๊ทธ๋“ค์ด ๋‹น์‹ ์˜ ๊ฒฝ๋กœ์—์„œ ๋งŒ๋‚œ ์ˆœ์„œ๋ฅผ ์ €์žฅํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ๊ฒฝ์šฐ "๋ฐ˜๋ณต" ํฌ์ผ“๋ชฌ์€ ๋” ์ด์ƒ ๋ชฉ๋ก์— ์ถ”๊ฐ€๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ๋˜๋Š” ์˜ˆ๋ฅผ ๋“ค์–ด ๋ ˆ๋ฒจ์ด ์žˆ๋Š” ๋ชจ๋“  ๊ฒŒ์ž„์—์„œ ์ด๋ฏธ ๋งŒ๋‚œ ๋ ˆ๋ฒจ๋ณ„ ๋ณด์Šค ๋ชฉ๋ก์ž…๋‹ˆ๋‹ค. ๋˜๋Š” ์ฒœ์ฒด ๋ฐœ๊ฒฌ์˜ ์—ญ์‚ฌ. LinkedHashSet๊ณต๊ฐ„ ๋ณธ์ฒด๊ฐ€ ์ด๋ฏธ ๋ชฉ๋ก์— ์žˆ๋Š”์ง€ ์—ฌ๋ถ€๋ฅผ ๋น ๋ฅด๊ฒŒ ํ™•์ธํ•˜๊ณ  ๋ชฉ๋ก์— ์—†๋Š” ๊ฒฝ์šฐ ๋ชฉ๋ก์— ์ถ”๊ฐ€ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ค‘๋ณต ์ œ๊ฑฐ์˜ ์˜ˆ๋ฅผ ๋“ค์–ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

import java.util.*;

class LinkedHashSetExample2 {
   public static void main(String[] args) {
       List<String> listWithDuplicates = List.of("some","elements","with", "few", "duplicates", "were", "here", "duplicates", "duplicates");

       Set<String> linkedHashSet = new LinkedHashSet<>(listWithDuplicates);
       List<String> listWithoutDuplicates = new ArrayList<>(linkedHashSet);

       // next will print:
       // > listWithDuplicates = [some, elements, with, few, duplicates, here, duplicates, duplicates]
       System.out.println("listWithDuplicates = " + listWithDuplicates);
       // next will print:
       // > listWithoutDuplicates = [some, elements, with, few, duplicates, here]
       System.out.println("listWithoutDuplicates = " + listWithoutDuplicates);

       // -------------------------------------------------------------------------

       // while using regular Hash Set will generally produces some unexpected order
       Set<String> regularHashSet = new HashSet<>(listWithDuplicates);

       // next will print:
       // > linkedHashSet = [some, elements, with, few, duplicates, were, here]
       System.out.println("linkedHashSet = " + linkedHashSet);
       // next will print:
       // > regularHashSet = [here, some, with, duplicates, were, elements, few]
       System.out.println("regularHashSet = " + regularHashSet);
   }
}
ํ”„๋กœ๊ทธ๋žจ์˜ ์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
listWithDuplicates = [some, elements, with, few, duplicates, were, here, duplicates, duplicates] listWithoutDuplicates = [some, elements, with, few, duplicates, were, here] linkedHashSet = [some, elements, with, few, duplicates , ์žˆ์—ˆ๋‹ค, ์—ฌ๊ธฐ] regularHashSet = [์—ฌ๊ธฐ, ์ผ๋ถ€, ์™€, ์ค‘๋ณต, ์žˆ์—ˆ๋‹ค, ์š”์†Œ, ์†Œ์ˆ˜]
์ฝ”๋ฉ˜ํŠธ
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION