์ž๋ฐ”(Java)

[Java ๋ฌธ๋ฒ• ์ข…ํ•ฉ๋ฐ˜] ๊ธฐ์ดˆ์–ธ์–ด 2์ฃผ์ฐจ ~2-16

JAVABOZA 2023. 5. 25. 14:40

๐ŸŸก๐ŸŸข๋ฐฐ์—ด๐Ÿ”ด๐ŸŸ 

๋ฐฐ์—ด์˜ ๊ฐœ๋…

์—ฌ๋Ÿฌ๊ฐœ์˜ ๋ณ€์ˆ˜๋ฅผ ํ•œ๊ณณ์— ๋ชจ์•„์„œ ์ €์žฅ ํ•˜๊ณ  ์‹ถ์„ ๋•Œ "๋ฐฐ์—ด"์ด๋ผ๋Š” ๋ณ€์ˆ˜์— ์ €์žฅํ•œ๋‹ค๊ณ  ํ‘œํ˜„!

 

๋ฐฐ์—ด์˜ ์„ ์–ธ

int ์™€ ๊ฐ™์€ ๊ธฐ๋ณธํ˜• ๋ณ€์ˆ˜์—๋Š” 1๊ฐœ์˜ ๊ฐ’๋งŒ ์ €์žฅํ•  ์ˆ˜ ์žˆ๋‹ค๋ฉด int[]์™€ ๊ฐ™์€ ๋ฐฐ์—ดํ˜• ๋ณ€์ˆ˜๋Š” ์—ฌ๋Ÿฌ๊ฐœ๋ฅผ ์ €์žฅํ•  ์ˆ˜ ์žˆ์Œ

 

๋”๋ณด๊ธฐ

โ€ป ๋‹จ! ํ•˜๋‚˜์˜ ๋ฐฐ์—ดํ˜• ๋ณ€์ˆ˜์—๋Š” ๊ฐ™์€ ํƒ€์ž… ๋ณ€์ˆ˜๋งŒ ๋‹ด์„ ์ˆ˜ ์žˆ์Œ!

 

๋ฐฐ์—ด์€ Array๋ผ ๋ถ€๋ฅด๋ฉฐ

ํƒ€์ž… []  ๋ณ€์ˆ˜;

 ex) int[] intArray;

 

ํƒ€์ž… ๋ณ€์ˆ˜ [] ;

 ex) int intArray[];

      

//๋ฐฐ์—ด ์„ ์–ธ ์˜ˆ์‹œ

int[] intArray;   //์ •์ˆ˜๋ฐฐ์—ด
long[] longArray;
double[] doubleArray;    //์‹ค์ˆ˜๋ฐฐ์—ด
char[] charArray;    //๋ฌธ์ž๋ฐฐ์—ด
String[] stringArray; //๋ฌธ์ž์—ด ๋ฐฐ์—ด


// ์•„๋ž˜๋„ ๊ฐ™์€ ํ‘œํ˜„์ด๋‹ค

int intArray[]; //์ •์ˆ˜๋ฐฐ์—ด
long longArray[]; 
double doubleArray[];   //์‹ค์ˆ˜๋ฐฐ์—ด
char charArray[];   // ๋ฌธ์ž๋ฐฐ์—ด
String stringArray[]; //๋ฌธ์ž์—ด๋ฐฐ์—ด

โ˜…โ˜…๋ฐฐ์—ด์€ ์ฐธ์กฐํ˜•๋ณ€์ˆ˜๋“ค์ฒ˜๋Ÿผ new ๋ช…๋ น์„ ํ†ตํ•ด์„œ ์ƒ์„ฑํ•ด์„œ ๋Œ€๊ด„ํ˜ธ [] ์•ˆ์— ํฌ๊ธฐ๋ฅผ ์ •ํ•œ๋‹ค!!โ˜…โ˜…

Int array[] = new int[8];

 

+

๋ฐฐ์—ด์€ ์ƒ์„ฑ๋  ๋•Œ ๊ฐ ํƒ€์ž…๋ณ„๋กœ ์ดˆ๊ธฐ๊ฐ’์œผ๋กœ ์ดˆ๊ธฐํ™” ๋œ๋‹ค

ex int๋Š” 0 / boolean์€ false / String์€ null

 

 

โญ์ฐธ์กฐํ˜•๋ณ€์ˆ˜์ด๊ธฐ ๋•Œ๋ฌธ์— ์‹ค์ œ๊ฐ’์„ ๋‹ด์ง€ ์•Š๊ณ  ์‹ค์ œ๊ฐ’์˜ ์ฃผ์†Œ๊ฐ’์„ ์ €์žฅ

 

๋ฐฐ์—ด์˜ ์กฐํšŒ (= ํ•ด๋‹น ๋ฐฐ์—ด๋ณ€์ˆ˜ ๋’ค์— ์ˆœ๋ฒˆ์„ ๋Œ€๊ด„ํ˜ธ[] ๋กœ ๊ฐ์‹ธ์„œ ๋ช…์‹œ)

 

int[] intArray = new int[3];  // ๋ฐฐ์—ด์˜ ๋‹จ๊ฑด์กฐํšŒ
System.out.println(intArray[1]);

 

int[] intArray = new int[3];

for(int i=0; i<intArray.length; i++){
 System.out.println(intArray[i]);
}

๊ธธ์ด๊ฐ€ 8์ธ ์ •์ˆ˜๋ฐฐ์—ด์€ ์„ ์–ธํ•˜๊ณ  ์ดˆ๊ธฐํ™”๋œ ๊ฐ’ ์ถœ๋ ฅ

 

 

๋ฐฐ์—ด์˜ ์ดˆ๊ธฐํ™”

import java.utill.Arrays;

public class main{
	public static void main(String[] args){
    
    // ๋ฐฐ์—ด์— ํŠน์ •๊ฐ’ ๋Œ€์ž…ํ•˜์—ฌ์„œ ์„ ์–ธ
    int[] Array = {1,2,3,4,5};
    String[] stringArray = {"a", "b", "c", "d"};
    }
    
    // for๋ฌธ์„ ํ†ตํ•œ ๊ฐ’์„ ๋Œ€์ž…
    for(int=0; i<intArray.length; i++){
    intArray[i] = i;
    }
    
   // ํ–ฅ์ƒ๋œ for๋ฌธ์„ ํ†ตํ•œ ๋ฐฐ์—ด ์ถœ๋ ฅ
   for(int i : intArray){
    System.out.print(1);
    System.out.println
    Arrays.fill(intArray, 1);   // ๋ฐฐ์—ด์˜ ๋ชจ๋“ ๊ฐ’์„ 1๋กœ ์ดˆ๊ธฐํ™”
    
    for(int i : intArray){
    	System.out.pring(i);
	    }
   }
}

 


 

 

 

 

 


๐ŸŸก๐ŸŸข์ปฌ๋ ‰์…˜๐Ÿ”ด๐ŸŸ 

* ๋ฐฐ์—ด์„ ๋” ๊ณ ๋„ํ™” ์‹œํ‚จ๋‹ค(๋ฐฐ์—ด๋ณด๋‹ค ๋‹ค์ˆ˜์˜ ์ฐธ์กฐํ˜• ๋ฐ์ดํ„ฐ๋ฅผ ๋” ์ˆ˜๋น„๊ณ  ํšจ๊ณผ์ ์œผ๋กœ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์Œ).

* ์ž๋ฃŒ๊ตฌ์กฐ

* ์ปฌ๋ ‰์…˜์€ ์ฐธ์กฐํ˜• ๋ณ€์ˆ˜๋งŒ ์ €์žฅํ•จ

*  ์ข…๋ฅ˜ : List, Set, Queue, Map

List : ์ˆœ์„œ๊ฐ€ ์žˆ๋Š” ๋ฐ์ดํ„ฐ์˜ ์ง‘ํ•ฉ (โ˜…๋ฐ์ดํ„ฐ ์ค‘๋ณต ํ—ˆ์šฉ) - ๋ฐฐ์—ด๊ณผ ๋น„์Šทํ•˜๋‹ค๊ณ  ๋ณผ์ˆ˜์žˆ์Œ

Queue : ๋นจ๋Œ€๋กœ ๋น„์œ  ํ•œ์ชฝ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ๋„ฃ๊ณ  ๋ฐ˜๋Œ€์ชฝ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ๋บ„ ์ˆ˜ ์žˆ๋Š” ์ง‘ํ•ฉ

      ๐Ÿ‘‰ First In First Out :: ๋จผ์ € ๋“ค์–ด๊ฐ„ ์ˆœ์„œ๋Œ€๋กœ ๊ฐ’์„ ์กฐํšŒํ•  ์ˆ˜ ์žˆ๋‹ค.

Set : ์ˆœ์„œ๊ฐ€ ์—†๋Š” ๋ฐ์ดํ„ฐ์˜ ์ง‘ํ•ฉ (๋ฐ์ดํ„ฐ ์ค‘๋ณต ํ—ˆ์šฉ x ) - ์ˆœ์„œ๊ฐ€ ์—†์œผ๋ฉฐ ์ค‘๋ณต์—†๋Š” ๋ฐฐ์—ด

Map : ์ˆœ์„œ๊ฐ€ ์—†๋Š” (key, value) ์Œ์œผ๋กœ ์ด๋ค„์ง„ ๋ฐ์ดํ„ฐ์˜ ์ง‘ํ•ฉ (โ˜… key๊ฐ’ ์ค‘๋ณต ํ—ˆ์šฉ ์•ˆํ•จ)

 

๋”๋ณด๊ธฐ

์ž์ฃผ์“ฐ๋Š” ์ฐธ์กฐํ˜• ๋ณ€์ˆ˜

int ์˜ ์ฐธ์กฐํ˜• ๋ณ€์ˆ˜ = Integer

long ์˜ ์ฐธ์กฐํ˜• ๋ณ€์ˆ˜ = Long

double ์˜ ์ฐธ์กฐํ˜• ๋ณ€์ˆ˜ = Double

String --> ์ž์ฒด๊ฐ€ ์ฐธ์กฐํ˜• ๋ณ€์ˆ˜

 

 

 

List (= ๋™์ ๋ฐฐ์—ด : ํฌ๊ธฐ๊ฐ€ ๊ฐ€๋ณ€์ ์œผ๋กœ ๋Š˜์–ด๋‚จ)

์ˆœ์„œ๊ฐ€ ์žˆ๋Š” ๋ฐ์ดํ„ฐ์˜์ง‘ํ•ฉ (๋ฐ์ดํ„ฐ์˜ ์ค‘๋ณต์„ ํ—ˆ์šฉ O) (=๋ฐฐ์—ด๊ณผ ๋น„์Šท)

 

ArrayList 

 : ๋ฐฐ์—ด์ฒ˜๋Ÿผ ์ผ๋ ฌ๋กœ ๋ฐ์ดํ„ฐ๋ฅผ ์ €์žฅ, ์กฐํšŒ, ์ธ๋ฑ์Šค๊ฐ’์„ ํ•˜๋‚˜์”ฉ ์กฐํšŒ ๊ฐ€๋Šฅ

 

Array ์™€  ArrayList์˜ ์ฐจ์ด์ 

๋”๋ณด๊ธฐ

Array๋Š” ๋ฉ”๋ชจ๋ฆฌ์— ์—ฐ์†๋œ ๊ณต๊ฐ„์„ ์š”์ฒญํ•ด์„œ ์‚ฌ์ด์ฆˆ๋งŒํผ ๋ฐ›์•„ '์‹ค์ œ๊ฐ’'์„ ์ €์žฅํ•˜๋Š” ๊ธฐ๋ณธํ˜• ๋ณ€์ˆ˜๋กœ ์ €์žฅ

 

๋”๋ณด๊ธฐ

ArrayList๋Š” ์ƒ์„ฑ์‹œ์ ์— ์—ฐ์†๋œ ๊ณต๊ฐ„์„ ์š”์ฒญ. ์ฐธ์กฐํ˜• ๋ณ€์ˆ˜๋“ค์„ ๋‹ด์•„๋‘๊ณ  ๊ฐ’์ด ์ถ”๊ฐ€๋  ๋•Œ ๋” ํฐ ๊ณต๊ฐ„์ด ํ•„์š”ํ•˜๋ฉด

                   ๋” ํฐ ๊ณต๊ฐ„์„ ๋ฐ›์•„์„œ ์ €์žฅ

 

 

 

List ๊ธฐ๋Šฅ

ArrayList 

ArrayList<Integer> intList = new ArrayList<Integer>();

์œ„์˜ ์ฝ”๋“œ๋Š” ArrayList ์„ ์–ธ๊ณผ ์ƒ์„ฑ์„ ๋™์‹œ์— ์ง„ํ–‰ํ•œ ๊ฒƒ!

 

โ— ๊ฐ’์„ ์ถ”๊ฐ€ํ•  ๋•Œ

   intList.add(์ถ”๊ฐ€ํ•  ๊ฐ’)

 

โ— ๊ฐ’์„ ์ˆ˜์ •ํ•  ๋•Œ

   intList.set(์ˆ˜์ •ํ•  ์ˆœ๋ฒˆ , ์ˆ˜์ •ํ•  ๊ฐ’)

 

โ— ๊ฐ’์„ ์‚ญ์ œํ•  ๋•Œ 

   intList.remove(์‚ญ์ œํ•  ์ˆœ๋ฒˆ)

 

โ— ์ „์ฒด์ถœ๋ ฅ

   intList.toString()

 

โ— ์ „์ฒด์ œ๊ฑฐ

   intList.clear()

LinkedList 

 : ๋ฉ”๋ชจ๋ฆฌ์— ๋‚จ๋Š” ๊ณต๊ฐ„์„ ์š”์ฒญํ•ด์„œ ์—ฌ๊ธฐ์ €๊ธฐ ๋‚˜๋ˆ ์„œ ์‹ค์ œ๊ฐ’์„ ๋‹ด๊ณ , ์‹ค์ œ๊ฐ’์ด ์žˆ๋Š” ์ฃผ์†Œ๊ฐ’์œผ๋กœ ๋ชฉ๋ก์„ ๊ตฌ์„ฑํ•˜๊ณ  ์ €์žฅ

 

์ผ๋ฐ˜์ ์œผ๋กœ ArrayList์™€ ๋™์ผํ•˜์ง€๋งŒ LinkedListt๋Š” ๊ฐ’์„ ๋‚˜๋ˆ ์„œ ๋‹ด๊ธฐ ๋•Œ๋ฌธ์— ์กฐํšŒ์†๋„๊ฐ€ ๋Š๋ฆผ

โ€ป๋‹จ ๊ฐ’์„ ์ค‘๊ฐ„์— ์ถ”๊ฐ€ํ•˜๊ฑฐ๋‚˜ ์‚ญ์ œํ•  ๋•Œ๋Š” ๋น ๋ฆ„

 

๋”๋ณด๊ธฐ

LinkedList<Integer> LinkedList = new LinkedList<Integer>();

์œ„์˜ ์ฝ”๋“œ๋Š” LinkedList ์„ ์–ธ๊ณผ ์ƒ์„ฑ์„ ๋™์‹œ์— ์ง„ํ–‰ํ•œ ๊ฒƒ!

 

โ— ๊ฐ’์„ ์ถ”๊ฐ€ํ•  ๋•Œ

   LinkedList.add(์ถ”๊ฐ€ํ•  ๊ฐ’)

 

โ— ๊ฐ’์„ ์ˆ˜์ •ํ•  ๋•Œ

   LinkedList.set(์ˆ˜์ •ํ•  ์ˆœ๋ฒˆ , ์ˆ˜์ •ํ•  ๊ฐ’)

 

โ— ๊ฐ’์„ ์‚ญ์ œํ•  ๋•Œ 

   LinkedList.remove(์‚ญ์ œํ•  ์ˆœ๋ฒˆ)

 

โ— ๊ฐ’์„ ์ค‘๊ฐ„์— ํ•  ๋•Œ 

   LinkedList.add(์ถ”๊ฐ€ํ•  ์ˆœ๋ฒˆ, ์ถ”๊ฐ€ํ•  ๊ฐ’)

 

โ— ์ „์ฒด์ถœ๋ ฅ

   LinkedList.toString()

 

โ— ์ „์ฒด์ œ๊ฑฐ

 LinkedList.clear()

Stack (= '์ƒ์ž'๋กœ ๋ฌ˜์‚ฌ)

 : ๊ฐ’์„ ์ˆ˜์ง์œผ๋กœ ์Œ“์•„๋†“๊ณ  ๋„ฃ์—ˆ๋‹ค๊ฐ€ ๋นผ์„œ ์กฐํšŒ ํ•˜๋Š” ํ˜•์‹์œผ๋กœ ๋ฐ์ดํ„ฐ ๊ด€๋ฆฌ

   ์ตœ๊ทผ ์ €์žฅ๋œ ๋ฐ์ดํ„ฐ๋ฅผ ๋‚˜์—ดํ•˜๊ณ  ์‹ถ๊ฑฐ๋‚˜, ๋ฐ์ดํ„ฐ์˜ ์ค‘๋ณต ์ฒ˜๋ฆฌ๋ฅผ ๋ง‰์„ ๋•Œ ์‚ฌ์šฉ

    (Last-In-First-Out) ==> "๋‚˜์ค‘์— ๋“ค์–ด๊ฐ„ ๊ฒƒ์ด ๊ฐ€์žฅ ๋จผ์ € ๋‚˜์˜จ๋‹ค"

 

โ—๊ธฐ๋Šฅ ์ •๋ฆฌ

push ()  = add()์™€ ์œ ์‚ฌ // ์ถ”๊ฐ€ ๊ธฐ๋Šฅ

peek () = get() ๊ธฐ๋Šฅ๊ณผ ์œ ์‚ฌ // ์กฐํšŒ ๊ธฐ๋Šฅ 

pop () = ๊บผ๋‚ด๋Š” ๊ธฐ๋Šฅ

 

๋”๋ณด๊ธฐ

Stack<Integer> intStack = new Stack<Integer>();

์œ„์˜ ์ฝ”๋“œ๋Š” Stack ์„ ์–ธ๊ณผ ์ƒ์„ฑ์„ ๋™์‹œ์— ์ง„ํ–‰ํ•œ ๊ฒƒ!

 

โ— ๊ฐ’์„ ์ถ”๊ฐ€ํ•  ๋•Œ

intStack.push(์ถ”๊ฐ€ํ•  ๊ฐ’)

 

โ— ๊ฐ’์„ ์กฐํšŒํ•  ๋•Œ

(๋งจ์œ„ ๊ฐ’์„ ์กฐํšŒํ•จ)

intStack.peek()

 

โ— ๊ฐ’์„ ๊บผ๋‚ผ ๋•Œ

(๋งจ์œ„ ๊ฐ’์„ ๊บผ๋‚ด๊ณ  ํ›„์— ์‚ญ์ œ)

  intStack.pop()

โ— ๊ฐ’์„ ํฌ๊ธฐ ํ™•์ธํ•  ๋•Œ

intStack.size()


Queue : FIFO (= First In First Out)

: ๋นจ๋Œ€์ฒ˜๋Ÿผ ํ•œ์ชฝ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ๋„ฃ๊ณ  ๋ฐ˜๋Œ€์ชฝ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ๋บ„ ์ˆ˜ ์žˆ๋Š” ์ง‘ํ•ฉ

: ๋จผ์ € ๋“ค์–ด๊ฐ„ ์ˆœ์„œ๋Œ€๋กœ ๊ฐ’์„ ์กฐํšŒ

: Queue๋Š” ์ƒ์„ฑ์ž๊ฐ€ ์—†๋Š” ์ธํ„ฐํŽ˜์ด์Šค ๊ทธ๋ž˜์„œ ๋ฐ”๋กœ ์ƒ์„ฑ ๋ถˆ๊ฐ€

: ์ƒ์„ฑ์ž๊ฐ€ ์กด์žฌํ•˜๋Š” ํด๋ž˜์Šค์ธ LinkedList๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ Queue๋ฅผ ์ƒ์„ฑํ•ด์„œ ๋ฐ›๋Š”๋‹ค

๋”๋ณด๊ธฐ

Queue<Integer> = new Linked<Integer>();

์œ„์˜ ์ฝ”๋“œ๋Š” Queue ์„ ์–ธ๊ณผ ์ƒ์„ฑ์„ ๋™์‹œ์— ์ง„ํ–‰ํ•œ ๊ฒƒ!

โ— ๊ฐ’์„ ์ถ”๊ฐ€ํ•  ๋•Œ

(๊ฐ’์„ ๋งจ์œ„์— ์ถ”๊ฐ€)

intQueue.add(์ถ”๊ฐ€ํ•  ๊ฐ’)

 

โ— ๊ฐ’์„ ์กฐํšŒํ•  ๋•Œ

(๋งจ ์•„๋ž˜ ๊ฐ’์„ ์กฐํšŒํ•จ)

intQueue.peek()

 

โ— ๊ฐ’์„ ๊บผ๋‚ผ ๋•Œ

(๋งจ์•„๋ž˜๊ฐ’์„ ๊บผ๋‚ด๊ณ  ์‚ญ์ œ๋จ)

intQueue.poll()


Set

: ์ˆœ์„œ๊ฐ€ ์—†๋Š” ๋ฐ์ดํ„ฐ์˜ ์ง‘ํ•ฉ (๋ฐ์ดํ„ฐ ์ค‘๋ณต ํ—ˆ์šฉ x) -- ์ˆœ์„œ์—†๊ณ  ์ค‘๋ณต์—†๋Š” ๋ฐฐ์—ด์ด๋ผ ์ƒ๊ฐํ•˜์ž

: Set ๊ทธ๋ƒฅ ์‚ฌ์šฉ ๊ฐ€๋Šฅ. HashSet, TreeSet ๋“ฑ์œผ๋กœ ์‘์šฉ ์‚ฌ์šฉ๊ฐ€๋Šฅ

: Set๋„ Queue ์ฒ˜๋Ÿผ ์ƒ์„ฑ์ž๊ฐ€ ์—†๋Š” ์ธํ„ฐํŽ˜์ด์Šค๋ผ ๋ฐ”๋กœ ์ƒ์„ฑ ๋ถˆ๊ฐ€๋Šฅ

: ์ƒ์„ฑ์ž๊ฐ€ ์กด์žฌํ•˜๋Š” ํด๋ž˜์Šค์ธ HashSet์„ ์‚ฌ์šฉํ•ด์„œ Set๋ฅผ ์ƒ์„ฑ๋ฐ›์„ ์ˆ˜ ์žˆ๋‹ค.

 

HashSet : ๊ฐ€์žฅ ๋น ๋ฅด๋‹ค. ์ˆœ์„œ๋ฅผ ์ „ํ˜€ ์˜ˆ์ธกํ•  ์ˆ˜ ์—†์Œ

TreeSet : ์ •๋ ฌ๋œ ์ˆœ์„œ๋Œ€๋กœ ๋ณด๊ด€. ์ •๋ ฌ๋ฐฉ๋ฒ•์„ ์ง€์ •ํ•  ์ˆ˜ ์—†์Œ

LinkedHashSet : ์ถ”๊ฐ€๋œ ์ˆœ์„œ, ํ˜น์€ ๊ฐ€์žฅ ์ตœ๊ทผ์— ์ ‘๊ทผํ•œ ์ˆœ์„œ๋Œ€๋กœ ์ ‘๊ทผ ๊ฐ€๋Šฅ

 

๋”๋ณด๊ธฐ

๐Ÿ“ŒTip

๋ณดํ†ต HashSet ์‚ฌ์šฉํ•จ

์ˆœ์„œ๋ณด์žฅ์ด ํ•„์š”ํ•˜๋‹ค ์‹ถ์Œ LinkedHashSet์„ ์‚ฌ์šฉ

 

๋”๋ณด๊ธฐ

Set<Integer> intSet = new HashSet<Integer>();

์œ„์˜ ์ฝ”๋“œ๋Š” Set ์„ ์–ธ๊ณผ ์ƒ์„ฑ์„ ๋™์‹œ์— ์ง„ํ–‰ํ•œ ๊ฒƒ!

 

โ— ๊ฐ’์„ ์ถ”๊ฐ€ํ•  ๋•Œ

(๊ฐ’์„ ๋งจ์œ„์— ์ถ”๊ฐ€)

intSet.add(์ถ”๊ฐ€ํ•  ๊ฐ’)

 

โ— ๊ฐ’์„ ์กฐํšŒํ•  ๋•Œ

(์ˆœ๋ฒˆ์— ์žˆ๋Š” ๊ฐ’ ์กฐํšŒ)

intSet.get(์กฐํšŒํ•  ์ˆœ๋ฒˆ)

 

โ— ๊ฐ’์„ ์‚ญ์ œํ•  ๋•Œ

(์‚ญ์ œํ•  ๊ฐ’ ์ง€์ •)

intSet.remove(์‚ญ์ œํ•  ๊ฐ’)

 

โ— ๊ฐ’ ํฌํ•จํ™•์ธํ•  ๋•Œ

(ํ•ด๋‹น๊ฐ’์ด ํฌํ•จ๋˜์–ด์žˆ๋Š” ์ง€๋Š” boolean๊ฐ’์œผ๋กœ ์‘๋‹ต)

intSet.contains(ํฌํ•จํ™•์ธ ํ•  ๊ฐ’)

 


Map

 : key - value ๊ตฌ์กฐ๋กœ ๊ตฌ์„ฑ๋œ ๋ฐ์ดํ„ฐ๋ฅผ ์ €์žฅ (key๊ฐ’์„ ๊ธฐ์ค€์œผ๋กœ value ์กฐํšŒ ๊ฐ€๋Šฅ)

 : key๊ฐ’ ๋‹จ์œ„๋กœ ์ค‘๋ณต์„ ํ—ˆ์šฉํ•˜์ง€ ์•Š๋Š” ๊ธฐ๋Šฅ์ด ์žˆ๋‹ค. (key ๊ฐ’์€ ์ค‘๋ณต๋˜๋ฉด ์•ˆ๋จ)

 : Map๋„ ๊ทธ๋ƒฅ ์‚ฌ์šฉ ๊ฐ€๋Šฅ / HashMap, TreeMap ๋“ฑ์œผ๋กœ ์‚ฌ์šฉ ๊ฐ€๋Šฅ

 

๋”๋ณด๊ธฐ

Map<String, Integer> intMap = new HashMap<>();

์œ„์˜ ์ฝ”๋“œ๋Š” Map์„ ์–ธ๊ณผ ์ƒ์„ฑ์„ ๋™์‹œ์— ์ง„ํ–‰ํ•œ ๊ฒƒ!

 

โ— ๊ฐ’์„ ์ถ”๊ฐ€ํ•  ๋•Œ

(๊ฐ’์„ ๋งจ์œ„์— ์ถ”๊ฐ€)

intMap.put(์ถ”๊ฐ€ํ•  key๊ฐ’, ์ถ”๊ฐ€ํ•  value๊ฐ’)

 

โ— ๊ฐ’์„ ์กฐํšŒํ•  ๋•Œ

(key์— ์žˆ๋Š” value ๊ฐ’ ์กฐํšŒ)

intMap.get(์กฐํšŒํ•  key๊ฐ’)

 

โ— ์ „์ฒด key ์กฐํšŒ

intMap.keySet()

 

โ— ์ „์ฒด value ์กฐํšŒ

intMap.values()

 

โ— ๊ฐ’ ์‚ญ์ œ

(key์— ์žˆ๋Š” value ๊ฐ’ ์‚ญ์ œ)

intMap.remove(์‚ญ์ œํ•  key๊ฐ’)