1. ๋ชฉ๋ก ์ค‘๊ฐ„(๋˜๋Š” ์‹œ์ž‘ ๋ถ€๋ถ„)์— ์š”์†Œ ์ถ”๊ฐ€

๋ชฉ๋ก ์ค‘๊ฐ„์— ์š”์†Œ๋ฅผ ์‚ฝ์ž…ํ•˜๋ ค๋Š” ๊ฒฝ์šฐ ๋ชฉ๋ก ๋‚ด๋ถ€์—์„œ ๋ฐœ์ƒํ•˜๋Š” ์ž‘์—…์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

11๊ฐœ์˜ ์š”์†Œ ๋ชฉ๋ก์ด ์žˆ๋‹ค๊ณ  ๊ฐ€์ •ํ•ฉ๋‹ˆ๋‹ค.

๋ชฉ๋ก ์ค‘๊ฐ„(๋˜๋Š” ์‹œ์ž‘ ๋ถ€๋ถ„)์— ์š”์†Œ ์ถ”๊ฐ€

์ธ๋ฑ์Šค 5์˜ ๋ชฉ๋ก์— ์ˆซ์ž 10,000์„ ์‚ฝ์ž…ํ•˜๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ์ด๋ ‡๊ฒŒ ํ•˜๋ ค๋ฉด ๋‹ค์Œ์„ ์‹คํ–‰ํ•˜๊ธฐ๋งŒ ํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.

list.add(5, 10000);

๋ณ€์ˆ˜๋Š” ์–ด๋””์— list์žˆ์Šต๋‹ˆ๊นŒ ArrayList? ์ด add(int index, type value)๋ฉ”์„œ๋“œ๋Š” ๋ชฉ๋ก์˜ ์œ„์น˜ 5์— ๊ฐ’ 10000์„ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค. ๋ฉ”์„œ๋“œ ์—์„œ ๋ฐœ์ƒํ•˜๋Š” ์ž‘์—…์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค add().

1๋‹จ๊ณ„: 5๋ฒˆ์งธ ์œ„์น˜๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜์—ฌ ๋ฐฐ์—ด์˜ ๋ชจ๋“  ์š”์†Œ๊ฐ€ ๋ฐฐ์—ด์˜ ๋์„ ํ–ฅํ•ด 1๊ฐœ ์š”์†Œ๋งŒํผ ์ด๋™(๋ณต์‚ฌ)๋ฉ๋‹ˆ๋‹ค.

๋ชฉ๋ก 1์˜ ์ค‘๊ฐ„(๋˜๋Š” ์‹œ์ž‘ ๋ถ€๋ถ„)์— ์š”์†Œ ์ถ”๊ฐ€

๋ฐฐ์—ด์˜ 5๋ฒˆ์งธ ๋ฐ 6๋ฒˆ์งธ ์…€์— ์žˆ๋Š” ์š”์†Œ๋Š” ์ด์ œ ๋™์ผํ•ฉ๋‹ˆ๋‹ค.

2๋‹จ๊ณ„: ๊ฐ’ 10,000์„ ๋‹ค์„ฏ ๋ฒˆ์งธ ์…€์— ์”๋‹ˆ๋‹ค.

๋ชฉ๋ก 2์˜ ์ค‘๊ฐ„(๋˜๋Š” ์‹œ์ž‘ ๋ถ€๋ถ„)์— ์š”์†Œ ์ถ”๊ฐ€

์ด์ œ ๋ชฉ๋ก์—๋Š” ๋ฐฐ์—ด์˜ ๋ชจ๋“  ์š”์†Œ๊ฐ€ ํฌํ•จ๋˜๊ณ  ๋‹ค์„ฏ ๋ฒˆ์งธ ์…€์—๋Š” ์ˆซ์ž 10,000์ด ํฌํ•จ๋ฉ๋‹ˆ๋‹ค. ์šฐ๋ฆฌ๊ฐ€ ์›ํ–ˆ๋˜ ๊ฒƒ.



2. ๋ชฉ๋ก์—์„œ ์š”์†Œ ์ œ๊ฑฐ

๋ชฉ๋ก์—์„œ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•˜๋Š” ๊ฒƒ์€ ์š”์†Œ๋ฅผ ์‚ฝ์ž…ํ•˜๋Š” ๊ฒƒ๊ณผ ๋น„์Šทํ•˜์ง€๋งŒ ํ”„๋กœ์„ธ์Šค๊ฐ€ ๋ฐ˜๋Œ€์ž…๋‹ˆ๋‹ค.

๋ชฉ๋ก์—์„œ ์„ธ ๋ฒˆ์งธ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ์ด๋ ‡๊ฒŒ ํ•˜๋ ค๋ฉด ๋‹ค์Œ์„ ์‹คํ–‰ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

list.remove(3);

๋‹ค์Œ์€ remove() ๋ฉ”์„œ๋“œ์—์„œ ์ผ์–ด๋‚˜๋Š” ์ผ์ž…๋‹ˆ๋‹ค.

1๋‹จ๊ณ„: ๋ฐฐ์—ด์˜ ์š”์†Œ๋Š” 4๋ฒˆ์งธ ์œ„์น˜์—์„œ ์‹œ์ž‘ํ•˜์—ฌ ๋ฐฐ์—ด์˜ ์‹œ์ž‘ ๋ฐฉํ–ฅ์œผ๋กœ 1๊ฐœ ์š”์†Œ๋งŒํผ ์ด๋™(๋ณต์‚ฌ)๋ฉ๋‹ˆ๋‹ค.

๋ชฉ๋ก์—์„œ ์š”์†Œ ์ œ๊ฑฐ

2๋‹จ๊ณ„: ๋ณ€์ˆ˜ ๊ฐ’์ด size1์”ฉ ๊ฐ์†Œํ•ฉ๋‹ˆ๋‹ค.

๋ชฉ๋ก 2์—์„œ ์š”์†Œ ์ œ๊ฑฐ

๋ฐฐ์—ด ๋์— ํšŒ์ƒ‰์œผ๋กœ ํ‘œ์‹œ๋œ ์ผ๋ถ€ ๊ฐ’์ด ์žˆ๋‹ค๋Š” ์ ์— ์œ ์˜ํ•˜์‹ญ์‹œ์˜ค. ๊ธฐ์ˆ ์ ์œผ๋กœ ์ด๊ฒƒ์€ ์“ฐ๋ ˆ๊ธฐ์ž…๋‹ˆ๋‹ค. ๊ฐ€๋น„์ง€ ์ˆ˜์ง‘์„ ๋ฐฉํ•ดํ•˜์ง€ ์•Š์œผ๋ ค๋ฉด ์ œ๊ฑฐํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค .

3๋‹จ๊ณ„: ์“ฐ๋ ˆ๊ธฐ ์น˜์šฐ๊ธฐ

๋ชฉ๋ก์—์„œ ์š”์†Œ ์ œ๊ฑฐ 3



3. Java์—์„œ ๋ชฉ๋ก ์ž‘์—…์˜ ์‹ค์ œ ์˜ˆ

๋ชฉ๋ก ์ž‘์—…์˜ ๋ช‡ ๊ฐ€์ง€ ์˜ˆ๋ฅผ ์ž‘์„ฑํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

1์—์„œ 20๊นŒ์ง€์˜ ๋ฒ”์œ„์— ์žˆ๋Š” ๋ชจ๋“  ์ง์ˆ˜๋ฅผ ๋‚˜์—ดํ•ฉ๋‹ˆ๋‹ค.

์•”ํ˜ธ ๋…ธํŠธ
ArrayList<Integer> list = new ArrayList<Integer>();

for (int i = 1; i <= 20; i++)
   if (i%2 == 0)
      list.add(i);


๋ชจ๋“  ์ธ๋ฑ์Šค์— ๋Œ€ํ•ด 1๋ชฉ๋ก ๊ฐ์ฒด๋ฅผ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค 20
. ์ธ๋ฑ์Šค๊ฐ€ 2๋‚˜๋จธ์ง€ ์—†์ด ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ
๋ชฉ๋ก์— ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.

์ด์ œ ๋ชฉ๋ก์˜ ๋ชจ๋“  ์š”์†Œ๋ฅผ โ€‹โ€‹ํ™”๋ฉด์— ํ‘œ์‹œํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

์•”ํ˜ธ ๋…ธํŠธ
ArrayList<Integer> list = new ArrayList<Integer>();

for (int i = 1; i <= 20; i++)
   if (i%2 == 0)
      list.add(i);

for (int i = 0; i < list.size(); i++)
   System.out.println(list.get(i));
๋ชฉ๋ก ๊ฐ์ฒด ๋งŒ๋“ค๊ธฐ
๋ชจ๋“  ์ธ๋ฑ์Šค์— ๋Œ€ํ•ด ๋ฐ˜๋ณตํ•ฉ๋‹ˆ๋‹ค. 1์ˆซ์ž 20

๊ฐ€ 2๋‚˜๋จธ์ง€ ์—†์ด ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ
๋ชฉ๋ก์— ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค .

0๋ถ€ํ„ฐ ๋ชฉ๋ก ํฌ๊ธฐ๊นŒ์ง€ ๋ฐ˜๋ณตํ•ฉ๋‹ˆ๋‹ค
. ๊ฐ ์š”์†Œ๋ฅผ ํ™”๋ฉด์— ํ‘œ์‹œํ•ฉ๋‹ˆ๋‹ค.

์š”์†Œ ์ œ๊ฑฐ:

์ด์ œ 4๋กœ ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ๋Š” ๋ชจ๋“  ์š”์†Œ๋ฅผ โ€‹โ€‹์ œ๊ฑฐํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ๋ชฉ๋ก์—์„œ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•˜๋ฉด ๋‚˜๋จธ์ง€ ์š”์†Œ์˜ ์œ„์น˜๊ฐ€ ์ฆ‰์‹œ ๋ณ€๊ฒฝ๋ฉ๋‹ˆ๋‹ค.

์•”ํ˜ธ ๋…ธํŠธ
ArrayList<Integer> list = new ArrayList<Integer>();

for (int i = 1; i <= 20; i++)
   if (i%2 == 0)
      list.add(i);

for (int i = 0; i < list.size(); i++)
   if (list.get(i)%4 == 0)
   {
      list.remove(i);
      i--;
   }
๋ฆฌ์ŠคํŠธ ๊ฐ์ฒด๋ฅผ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.

๋ชจ๋“  ์ธ๋ฑ์Šค์— ๋Œ€ํ•ด ๋ฐ˜๋ณตํ•ฉ๋‹ˆ๋‹ค 1. 20
์ธ๋ฑ์Šค๊ฐ€ 2๋‚˜๋จธ์ง€ ์—†์ด ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ
๋ชฉ๋ก์— ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค

. 0๋ถ€ํ„ฐ ๋ชฉ๋ก ํฌ๊ธฐ๊นŒ์ง€ ๋ฐ˜๋ณต ํ•ฉ๋‹ˆ๋‹ค
. ๋ชฉ๋ก์˜ ์š”์†Œ๊ฐ€ 4๋‚˜๋จธ์ง€ ์—†์ด ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ:

a) ์ œ๊ฑฐ ์š”์†Œ
b) i๋ฃจํ”„์˜ ๋‹ค์Œ ๋ฐ˜๋ณต์—์„œ ๋™์ผํ•œ ์ธ๋ฑ์Šค๋ฅผ ์–ป๋„๋ก ์นด์šดํ„ฐ๋ฅผ ์ค„์ž…๋‹ˆ๋‹ค.

๋ชฉ๋ก์—์„œ ๋งˆ์ง€๋ง‰ 3๊ฐœ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•ด์•ผ ํ•œ๋‹ค๊ณ  ๊ฐ€์ •ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

์ž˜๋ชปํ•˜๋Š” ๋ฐฉ๋ฒ•์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

์•”ํ˜ธ ๋…ธํŠธ
ArrayList<Integer> list = new ArrayList<Integer>();

for (int i = 1; i <= 20; i++)
   if (i%2 == 0)
      list.add(i);

int n = list.size();
list.remove(n - 3);
list.remove(n - 2);
list.remove(n - 1);
๋ชฉ๋ก ๊ฐœ์ฒด ๋งŒ๋“ค๊ธฐ

๋ชฉ๋ก์—๋Š” 10๊ฐœ์˜ ์š”์†Œ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. 2, 4, 6, ... 20



n = 10
n - 3 = 7(๋ชฉ๋ก์— 9๊ฐœ์˜ ์š”์†Œ๊ฐ€ ๋‚จ์•„ ์žˆ์Œ)
n - 2 = 8(๋ชฉ๋ก์— 8๊ฐœ์˜ ์š”์†Œ๊ฐ€ ๋‚จ์•„ ์žˆ์Œ)
n - 1 = 9(๋ชฉ๋ก์— 7๊ฐœ์˜ ์š”์†Œ๊ฐ€ ๋‚จ์•„ ์žˆ์Œ)

7๋ฒˆ์งธ์™€ 8๋ฒˆ์งธ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•œ ํ›„์—๋Š” 8๊ฐœ์˜ ์š”์†Œ๋งŒ ๋ชฉ๋ก์— ๋‚จ์Šต๋‹ˆ๋‹ค. ์ฆ‰, 9๋ฒˆ์งธ ์š”์†Œ๋ฅผ ์‚ญ์ œํ•  ์ˆ˜ ์—†์œผ๋ฉฐ ํ”„๋กœ๊ทธ๋žจ์—์„œ ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•˜๋Š” ์˜ฌ๋ฐ”๋ฅธ ๋ฐฉ๋ฒ•์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

์˜ต์…˜ 1 ์˜ต์…˜ 2
int n = list.size();
list.remove(n - 3);
list.remove(n - 3);
list.remove(n - 3);
int n = list.size();
list.remove(n - 1);
list.remove(n - 2);
list.remove(n - 3);

๊ฐ ์ œ๊ฑฐ ์ž‘์—… ํ›„ ์š”์†Œ๊ฐ€ ํ•˜๋‚˜์”ฉ ์ด๋™ํ•˜๋ฏ€๋กœ ๋์ด๋‚˜ ๋‹ค๋ฅธ ์ผ๊ด€๋œ ์œ„์น˜์—์„œ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.