CodeGym /Java Blog /๋ฌด์ž‘์œ„์˜ /Java์—์„œ ๋ฐฐ์—ด์— ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ๋ฐฉ๋ฒ•
John Squirrels
๋ ˆ๋ฒจ 41
San Francisco

Java์—์„œ ๋ฐฐ์—ด์— ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ๋ฐฉ๋ฒ•

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

์ž๋ฐ”์—์„œ ๋ฐฐ์—ด์ด๋ž€?

๋ฐฐ์—ด์ด ๋ฌด์—‡์ด๋ฉฐ Java์—์„œ ๋ฐฐ์—ด์„ ์ƒ์„ฑํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ๊ธฐ์–ตํ•ด ๋ด…์‹œ๋‹ค. ์ด ์ ์„ ๊ธฐ์–ตํ•œ๋‹ค๋ฉด ๋‹ค์Œ ๋ถ€์ œ์ธ "Java ๋ฐฐ์—ด์— ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” 5๊ฐ€์ง€ ๋ฐฉ๋ฒ•"์œผ๋กœ ๊ฑด๋„ˆ๋›ฐ์‹ญ์‹œ์˜ค. Oracle์˜ ๊ณต์‹ Java ๋ฌธ์„œ์— ๋”ฐ๋ฅด๋ฉด ๋ฐฐ์—ด์€ ๋™์ผํ•œ ๋ฐ์ดํ„ฐ ์œ ํ˜•์— ์†ํ•˜๋Š” ์ผ๋ จ์˜ ๊ฐ’์ž…๋‹ˆ๋‹ค. ์ •์ˆ˜ ์ง‘ํ•ฉ์€ Java์—์„œ ๋ฐฐ์—ด ์˜ ์™„๋ฒฝํ•œ ์˜ˆ์ž…๋‹ˆ๋‹ค . ์ •์˜ํ•œ ๋ชจ๋“  ๊ฐ’์€ ์ธ๋ฑ์Šค ๋ผ๋Š” ๋ฐฐ์—ด ๋‚ด ํŠน์ • ์œ„์น˜์— ์žˆ์Šต๋‹ˆ๋‹ค . ๋ฐฐ์—ด์„ ์„ ์–ธํ•˜๊ณ  ์ดˆ๊ธฐํ™”ํ•˜๋Š” ๋ฐฉ๋ฒ•์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

int[] myArray = new int[10];
int[] myArray1 = {1, 0, 3, 17, 5, 6, 7, 8, 9, 10}
์ฒซ ๋ฒˆ์งธ ๊ฒฝ์šฐ์—๋Š” myArray ๋ฐฐ์—ด์„ ์ •์˜ํ•˜๊ณ  Java๊ฐ€ 10๊ฐœ ์š”์†Œ ๋ฐฐ์—ด์„ ์œ„ํ•œ ๊ณต๊ฐ„์„ ํ• ๋‹นํ•˜๋„๋ก ํ–ˆ์Šต๋‹ˆ๋‹ค. ๋‘ ๋ฒˆ์งธ myArray1 ์—์„œ๋Š” ์ฆ‰์‹œ 10๊ฐœ์˜ ๊ฐ’์„ ์ž…๋ ฅํ–ˆ์Šต๋‹ˆ๋‹ค. ๋‘ ๊ฒฝ์šฐ ๋ชจ๋‘ ์š”์†Œ 11์„ ๋‹จ์ˆœํžˆ ๋ฐฐ์—ด์— ํ‘ธ์‹œํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ๋ฐฐ์—ด ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๊ธฐ ์œ„ํ•ด ๊ฐœ๋ฐœ์ž๋Š” ๋ฐฐ์—ด์— ํฌํ•จ๋œ ๊ฐ’์˜ ์ธ๋ฑ์Šค๋ฅผ ์กฐ์ž‘ํ•ฉ๋‹ˆ๋‹ค. ์–ด๋–ป๊ฒŒ ํ•ด์•ผ ํ•ฉ๋‹ˆ๊นŒ? ๋ฐฐ์—ด์— ์ถ”๊ฐ€ํ•˜๋Š” ๊ฐ€์žฅ ์ผ๋ฐ˜์ ์ธ ๋ฐฉ๋ฒ•์„ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

Java ๋ฐฐ์—ด์— ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” 5๊ฐ€์ง€ ๋ฐฉ๋ฒ•

๋ถˆ๋ณ€์„ ๋ณ€ํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋งŒ๋“œ๋Š” ํŠธ๋ฆญ์ž…๋‹ˆ๋‹ค.
  • ๋ฐฐ์—ด์„ ๋ชฉ๋ก์œผ๋กœ ๋ณ€ํ™˜
  • ๋” ํฐ ์šฉ๋Ÿ‰์˜ ์ƒˆ ์–ด๋ ˆ์ด๋ฅผ ๋งŒ๋“ค๊ณ  ์–ด๋ ˆ์ด์— ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
  • System.arraycopy() ๊ตฌํ˜„
  • Apache Commons๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ฐฐ์—ด ๋ณต์‚ฌ
  • ArrayCopyOf() ๋ฉ”์„œ๋“œ ์ ์šฉ
๋ฐฐ์—ด์— ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ์ด๋Ÿฌํ•œ ๋ฐฉ๋ฒ•์„ ์ž์„ธํžˆ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

1. ๋ฐฐ์—ด์„ ๋ชฉ๋ก์œผ๋กœ ๋ณ€ํ™˜

์ƒˆ ์š”์†Œ๋ฅผ ๋ฐฐ์—ด์— ์ง์ ‘ ์ถ”๊ฐ€ํ•  ์ˆ˜ ์—†์œผ๋ฏ€๋กœ ์ฐจ์„ ์ฑ…์€ ๋ชฉ๋ก์œผ๋กœ ๋ณ€ํ™˜ํ•˜๊ณ  ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•œ ๋‹ค์Œ ๊ฐ’์„ ๋ฐฐ์—ด๋กœ ๋‹ค์‹œ ๋ณ€ํ™˜ํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๋ฐฐ์—ด์„ ๋ชฉ๋ก์œผ๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ์ฒซ ๋ฒˆ์งธ ๋ฐฉ๋ฒ•์€ asList()๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ƒˆ ArrayList๋ฅผ ๋งŒ๋“œ๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ฐ’ ๋ฒ”์œ„๊ฐ€ ์„ฑ๊ณต์ ์œผ๋กœ ๋ณ€ํ™˜๋˜๋ฉด ListAdd()๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๊ฐ’์„ ์‚ฝ์ž…ํ•ฉ๋‹ˆ๋‹ค. ๋” ์ด์ƒ ๋ฐฐ์—ด์„ ํŽธ์ง‘ํ•  ํ•„์š”๊ฐ€ ์—†์œผ๋ฉด toArray() ๋ฉ”์„œ๋“œ ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์›๋ž˜ ๋ฐ์ดํ„ฐ ์œ ํ˜•์œผ๋กœ ๋‹ค์‹œ ๋ณ€ํ™˜ํ•˜์‹ญ์‹œ์˜ค . ๋ชจ๋“  ๋ฐฉ๋ฒ•๊ณผ ๋ณ€ํ™˜์„ ์‚ฌ์šฉํ•˜๋ฉด ์ฒ˜์Œ์—๋Š” ํ˜ผ๋ž€์Šค๋Ÿฌ์›Œ ๋ณด์ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. asList()๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ •๋ฆฌํ•˜๋Š” ์˜ˆ๋ฅผ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค .

// Code for adding Java arrays to a program
import java.lang.*;
import java.util.*;
 
class ArrayDemo{
   //Letโ€™s add a new element to an array
   public static Integer[] addX(Integer myArray[], int x) {
       int i;
       //turn array into ArrayList using asList() method
       List arrList = new ArrayList( Arrays.asList(myArray));
 
       // adding a new element to the array
       arrList.add(x);
 
       // Transforming the ArrayList into an array
       myArray = arrList.toArray(myArray);
       return myArray;
   }
   public static void main(String[] args) {
       int i;
       //initial array
       Integer myArray[] = { 0, 1, 2, 45, 7, 5, 17};
 
       //print the initial array out
       System.out.println("Initial Array: "
                          + Arrays.toString(myArray));
 
       //element to be added
       int x = 28;
 
       // call the method to add x in myArray
       myArray = addX(myArray, x);
 
       // print the updated array out
       System.out.println("Array with " + x + " added: "
                          + Arrays.toString(myArray));
   }
}
์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
์ดˆ๊ธฐ ๋ฐฐ์—ด: [0, 1, 2, 45, 7, 5, 17] 28์ด ์ถ”๊ฐ€๋œ ๋ฐฐ์—ด: [0, 1, 2, 45, 7, 5, 17, 28]
๋”ฐ๋ผ์„œ ํ”„๋กœ๊ทธ๋žจ์—์„œ ์šฐ๋ฆฌ๋Š” 7๊ฐœ์˜ ๊ฐ’์œผ๋กœ ๊ตฌ์„ฑ๋œ myArray ๋ฐฐ์—ด์„ ์„ฑ๊ณต์ ์œผ๋กœ ์ƒ์„ฑ ํ•˜๊ณ  ์ฑ„์šฐ๊ณ  ์ถœ๋ ฅํ–ˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ ๋‹ค์Œ 10๊ฐ€์ง€ ๊ฐ’์œผ๋กœ๋Š” ์ถฉ๋ถ„ํ•˜์ง€ ์•Š๋‹ค๊ณ  ๊ฒฐ์ •ํ–ˆ์Šต๋‹ˆ๋‹ค. ๊ธ€์Ž„, ์šฐ๋ฆฌ๋Š” Arrays.asList ๋ฉ”์„œ๋“œ ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ myArray๋ฅผ ArrayList arrList๋กœ ๋ณ€ํ™˜ํ–ˆ์Šต๋‹ˆ๋‹ค . ์—ฌ๊ธฐ์— ์ถ”๊ฐ€ํ•  ์š”์†Œ์ธ 28์ด ์žˆ์Šต๋‹ˆ๋‹ค. ArrayList arrList ์— ์ถ”๊ฐ€ํ•œ ๋‹ค์Œ toArray() ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋‹ค์‹œ ๋ฐฐ์—ด๋กœ ๋ณ€ํ™˜ ํ•˜๊ณ  ์ƒˆ ๋ฐฐ์—ด์„ ์ธ์‡„ํ–ˆ์Šต๋‹ˆ๋‹ค.

2. ์šฉ๋Ÿ‰์ด ๋” ํฐ ์ƒˆ ์–ด๋ ˆ์ด ์ƒ์„ฑ

๋ฐฐ์—ด์— ๋” ๋งŽ์€ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ๊ฐ€์žฅ ์ผ๋ฐ˜์ ์ธ ๋ฐฉ๋ฒ• ์ค‘ ํ•˜๋‚˜๋Š” ์ฒ˜์Œ๋ถ€ํ„ฐ ์ƒˆ๋กญ๊ณ  ๋” ํฐ ๋ฐฐ์—ด์„ ๋งŒ๋“ค๊ณ  ์ด์ „ ์š”์†Œ๋ฅผ ๋„ฃ๊ณ  ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ํ”„๋กœ์„ธ์Šค์˜ ๋‹จ๊ณ„๋ณ„ ์—ฐ์Šต์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
  • ์šฉ๋Ÿ‰์ด a+n์ธ ์ƒˆ ๋ฐฐ์—ด์„ ๋งŒ๋“ญ๋‹ˆ๋‹ค(a โ€” ์›๋ž˜ ๋ฐฐ์—ด ์šฉ๋Ÿ‰, n โ€” ์ถ”๊ฐ€ํ•˜๋ ค๋Š” ์š”์†Œ ์ˆ˜).
  • ์ƒˆ ๊ฐ’๋ฟ๋งŒ ์•„๋‹ˆ๋ผ ์ด์ „ ๋ฐ์ดํ„ฐ ๋ฒ”์œ„์˜ ๋ชจ๋“  ์š”์†Œ๋ฅผ โ€‹โ€‹์ƒˆ ๋ฐ์ดํ„ฐ ๋ฒ”์œ„์— ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
  • ๊ฒฐ๊ณผ ๋ฐฐ์—ด์„ ์ธ์‡„ํ•ฉ๋‹ˆ๋‹ค.
์ด๋Ÿฌํ•œ ๋ฐฐ์—ด์„ ์ง์ ‘ ๋งŒ๋“ค์–ด๋ณด๊ณ  ์ฝ”๋“œ๋ฅผ ์•„๋ž˜ ์˜ˆ์ œ์˜ ์ฝ”๋“œ์™€ ๋น„๊ตํ•˜์‹ญ์‹œ์˜ค.

// Java Program to add an element in an Array

import java.lang.*;
import java.util.*;

class ArrayDemo {
   //Method to add an element x into array myArray
   public static int[] addX(int myArray[], int x) {
       int i;

       // create a new array of a bigger size (+ one element)
       int newArray[] = new int[myArray.length + 1];

       // insert the elements from the old array into the new one
       for (i = 0; i < myArray.length; i++)
           newArray[i] = myArray[i];

       newArray[myArray.length] = x;
       return newArray;
   }

   public static void main(String[] args) {
       int i;

       // initial array of size 10
       int arr[]
               = {0, 1, 2, 45, 7, 5, 17};

       // print the initial array
       System.out.println("Initial Array: " + Arrays.toString(arr));

       // element to be added
       int x = 28;

       // call the addX method to add x in arr
       arr = addX(arr, x);
       // print the updated array
       System.out.println("Array with " + x + " added:" + Arrays.toString(arr));
   }
}
์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
์ดˆ๊ธฐ ๋ฐฐ์—ด: [0, 1, 2, 45, 7, 5, 17] 28์ด ์ถ”๊ฐ€๋œ ๋ฐฐ์—ด: [0, 1, 2, 45, 7, 5, 17, 28]
์Œ, ๋ฐฐ์—ด์— ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ์ด ๋ฐฉ๋ฒ•์ด ๊ฐ€์žฅ ์‰ฌ์šด ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค.

3. System.arrayCopy() ์ ์šฉ

System.arrayCopy()๋Š” ์†Œ์Šค ๋ฐฐ์—ด์˜ ๋Œ€์ƒ์— ๋” ํฐ ๋ฐฐ์—ด์„ ํ• ๋‹นํ•˜๋Š” ๋ฐ ๋„๋ฆฌ ์‚ฌ์šฉ๋˜๋Š” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค. ๊ฐœ๋ฐœ์ž๋Š” ๋ฉ”์„œ๋“œ์˜ ๊ด„ํ˜ธ ์•ˆ์— ์ƒˆ ๋ฐฐ์—ด์— ๋ณต์‚ฌํ•˜๋ ค๋Š” ์‹œํ€€์Šค๋ฅผ ์ง€์ •ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฐฉ๋ฒ•์ด ์–ด๋–ป๊ฒŒ ์ž‘๋™ํ•˜๋Š”์ง€ ํ™•์ธํ•˜๊ณ  ์ง์ ‘ ์‚ฌ์šฉํ•ด ๋ณด๋ ค๋ฉด ์•„๋ž˜ ์˜ˆ์ œ๋ฅผ ์‚ดํŽด๋ณด๊ณ  ์‹คํ–‰ํ•ด ๋ณด์‹ญ์‹œ์˜ค.

import java.util.Arrays;

class ArrayDemo {
   private static Integer[] addElement(Integer[] myArray, int newElement) {
       //we create a new Object here, an array of bigger capacity 
       Integer[] array = new Integer[myArray.length + 1];
       System.arraycopy(myArray, 0, array, 0, myArray.length);
       array[myArray.length] = newElement;
       return array;
   }

   public static void main(String[] args) {
       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}
์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๊ธฐ ์ „์˜ myArray: [20, 21, 3, 4, 5, 88] ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๊ธฐ ์ „์˜ myArray: [20, 21, 3, 4, 5, 88, 12]
์—ฌ๊ธฐ์—์„œ ์šฐ๋ฆฌ๋Š” myArray ๋ฐฐ์—ด์„ ๋งŒ๋“ค๊ณ  ์ถœ๋ ฅํ•˜๊ณ  System.arrayCopy() ์— ๊ตฌ์ถ•๋œ addElement ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ–ˆ์Šต๋‹ˆ๋‹ค .

4. Apache Commons๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์–ด๋ ˆ์ด ๋ณต์‚ฌ

๋น„ํ‘œ์ค€ ๋ฐฉ์‹์„ ์‚ฌ์šฉํ•ฉ์‹œ๋‹ค. ์ฆ‰, ํƒ€์‚ฌ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ Apache Commons lang์ž…๋‹ˆ๋‹ค. ์žฌ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•œ Java ๊ตฌ์„ฑ ์š”์†Œ์˜ ๋ชจ๋“  ์ธก๋ฉด์— ์ดˆ์ ์„ ๋งž์ถ˜ Apache Commons ํ”„๋กœ์ ํŠธ์˜ ์ผ๋ถ€์ž…๋‹ˆ๋‹ค. ํ”„๋กœ์ ํŠธ์— ๋Œ€ํ•œ ์ง€์‹์€ ๋ถˆํ•„์š”ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. Apache Commons lang์—๋Š” ๋ฐฐ์—ด ํ™•์žฅ์„ ํ—ˆ์šฉํ•˜๋„๋ก ํŠน๋ณ„ํžˆ ์„ค๊ณ„๋œ add() ๋ฉ”์„œ๋“œ๊ฐ€ ์žˆ์–ด ์ฝ”๋”์˜ ์‹œ๊ฐ„๊ณผ ๋…ธ๋ ฅ์„ ๋งŽ์ด ์ ˆ์•ฝํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด Apache Commons add() ๋ฉ”์„œ๋“œ ๋Š” ๊นŒ๋‹ค๋กœ์šด ์‹œํ—˜์ด๋‚˜ ์ธํ„ฐ๋ทฐ ์งˆ๋ฌธ์— ๋‹ตํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ System.arraycopy() ๋ฉ”์„œ๋“œ ํ˜ธ์ถœ์„ ๊ธฐ๋ฐ˜์œผ๋กœ ํ•œ๋‹ค๋Š” ์ ์„ ๋ช…์‹ฌํ•  ๊ฐ€์น˜๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค . ํ”„๋กœ์ ํŠธ์— ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์ถ”๊ฐ€ํ•˜๋ ค๋ฉด Apache Commons ์›น ์‚ฌ์ดํŠธ๋กœ ์ด๋™ํ•˜์—ฌ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ๋‹ค์šด๋กœ๋“œํ•˜์‹ญ์‹œ์˜ค. ๊ทธ๋Ÿฐ ๋‹ค์Œ ํŒŒ์ผ โ†’ ํ”„๋กœ์ ํŠธ ๊ตฌ์กฐ โ†’ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ > +๋กœ ์ด๋™ํ•˜์—ฌ ๋‹ค์šด๋กœ๋“œํ•œ jar ํŒŒ์ผ์„ ์„ ํƒํ•ฉ๋‹ˆ๋‹ค.

import org.apache.commons.lang3.ArrayUtils;
import java.util.Arrays;

class ArrayDemo {
   private static <T> T[] append(T[] arr, T element) {
       return ArrayUtils.add(arr, element);
   }

   public static void main(String[] args) {
       Integer[] myArray = { 0, 1, 2, 3, 4};
       System.out.println("myArray: " + Arrays.toString(myArray));

       myArray = append(myArray, 5);
       System.out.println("new Array with the number added: " + Arrays.toString(myArray));
   }
}
์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
myArray: [0, 1, 2, 3, 4] ์ˆซ์ž๊ฐ€ ์ถ”๊ฐ€๋œ ์ƒˆ ๋ฐฐ์—ด: [0, 1, 2, 3, 4, 5]

5. ArrayCopyOf() ๊ตฌํ˜„

ArrayCopyOf()๋Š” ๋ฐฐ์—ด์— ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ๋˜ ํ•˜๋‚˜์˜ ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค. Apache Commons lang add() ์™€ ๊ฐ™์ด ์ด ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๊ธฐ ์œ„ํ•ด ๋‚ด๋ถ€์ ์œผ๋กœ System.arraycopy()๋ฅผ ํ˜ธ์ถœํ•ฉ๋‹ˆ๋‹ค . ๊ทธ๋Ÿฌ๋‚˜ ๋Œ€๋ถ€๋ถ„์˜ ๊ฐœ๋ฐœ์ž๋Š” ์ฝ”๋“œ๋ฅผ ๊ฐ„๊ฒฐํ•˜๊ณ  ์ฝ๊ธฐ ์‰ฝ๊ฒŒ ์œ ์ง€ํ•  ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ ArrayCopyOf()๋ฅผ ์„ ํ˜ธํ•ฉ๋‹ˆ๋‹ค. ๋‹ค์Œ์€ ArrayCopyOf()๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ฐฐ์—ด์— ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ์˜ˆ์ž…๋‹ˆ๋‹ค .

import java.util.Arrays;
class ArrayDemo {
   private static <X> X[] addElement(X[] myArray, X element) {
       X[] array = Arrays.copyOf(myArray, myArray.length + 1);
       array[myArray.length] = element;
       return array;
   }
   public static void main(String[] args) {
       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}
์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๊ธฐ ์ „์˜ myArray: [20, 21, 3, 4, 5, 88] ์ƒˆ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๊ธฐ ์ „์˜ myArray: [20, 21, 3, 4, 5, 88, 12]

๊ฒฐ๋ก 

๋ฐฐ์—ด์— ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์•„๋Š” ๊ฒƒ์€ ๊ฐœ๋ฐœ์ž๊ฐ€ ๊ธฐ๋Šฅ๊ณผ ๊ฐ€๋…์„ฑ์„ ํฌ์ƒํ•˜์ง€ ์•Š๊ณ  ์ด์ „ ์ฝ”๋“œ๋ฅผ ๋น ๋ฅด๊ฒŒ ์—…๋ฐ์ดํŠธํ•˜๋Š” ๋ฐ ๋„์›€์ด ๋ฉ๋‹ˆ๋‹ค. ๋˜๋Š” ์ธํ„ฐ๋ทฐ๋ฅผ ํ†ต๊ณผํ•˜๊ธฐ ์œ„ํ•ด. Java ๋ฐฐ์—ด์— ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ๋ฐฉ๋ฒ•์—๋Š” ์—ฌ๋Ÿฌ ๊ฐ€์ง€๊ฐ€ ์žˆ์œผ๋ฏ€๋กœ ํŽธํ•œ ๋ฐฉ๋ฒ•์„ ์ž์œ ๋กญ๊ฒŒ ์„ ํƒํ•˜์‹ญ์‹œ์˜ค.

๋” ์ฝ์–ด๋ณด๊ธฐ:

์ฝ”๋ฉ˜ํŠธ
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION