JavaRush /Java Blog /Random-KO /Java 8์˜ ๋ฐฐ์—ด์— ๋Œ€ํ•œ ๋ณ‘๋ ฌ ์ž‘์—… - ๋ฒˆ์—ญ
billybonce
๋ ˆ๋ฒจ 29
ะœะพัะบะฒะฐ

Java 8์˜ ๋ฐฐ์—ด์— ๋Œ€ํ•œ ๋ณ‘๋ ฌ ์ž‘์—… - ๋ฒˆ์—ญ

Random-KO ๊ทธ๋ฃน์— ๊ฒŒ์‹œ๋˜์—ˆ์Šต๋‹ˆ๋‹ค
๊ธฐ์‚ฌ ๋ฒˆ์—ญ
//Java 8์˜ ๋ณ‘๋ ฌ ๋ฐฐ์—ด ์ž‘์—… //Eric Bruno ์ž‘์„ฑ, 2014๋…„ 3์›” 25์ผ //drdobbs.com/jvm/parallel-array-Operations-in-java-8/240166287 //Eric Bruno๋Š” ๊ธˆ์œต ๋ถ€๋ฌธ ๋ฐ ๋ธ”๋กœ๊ทธ์—์„œ ๊ทผ๋ฌด ์›น์‚ฌ์ดํŠธ Dr. ๋•์Šค.
์ƒˆ๋กœ์šด Java ๋ฆด๋ฆฌ์Šค๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ฐฐ์—ด๊ณผ ๋ณ‘๋ ฌ๋กœ ์ƒํ˜ธ ์ž‘์šฉํ•˜๋Š” ๊ฒƒ์ด ๋” ์‰ฌ์›Œ์ ธ ์ตœ์†Œํ•œ์˜ ์ฝ”๋”ฉ์œผ๋กœ ์„ฑ๋Šฅ์ด ํฌ๊ฒŒ ํ–ฅ์ƒ๋ฉ๋‹ˆ๋‹ค. ์ด์ œ ์˜ค๋ผํด์€ ์–ธ์–ด ์ธก๋ฉด์—์„œ ํฐ ๋ฐœ์ „์„ ์ด๋ฃฌ Java SE 8์„ ์ถœ์‹œํ•ฉ๋‹ˆ๋‹ค. ์ด๋ฒˆ ๋ฆด๋ฆฌ์Šค์˜ ์ค‘์š”ํ•œ ๊ธฐ๋Šฅ ์ค‘ ํ•˜๋‚˜๋Š” ํ–ฅ์ƒ๋œ ๋™์‹œ์„ฑ์ด๋ฉฐ, ๊ทธ ์ค‘ ์ผ๋ถ€๋Š” java.util.Arrays ๊ธฐ๋ณธ ํด๋ž˜์Šค์— ๋‚˜ํƒ€๋‚ฉ๋‹ˆ๋‹ค. ์ด ํด๋ž˜์Šค์—๋Š” ์ƒˆ๋กœ์šด ๋ฉ”์„œ๋“œ๊ฐ€ ์ถ”๊ฐ€๋˜์—ˆ์œผ๋ฉฐ, ์ด ๊ธฐ์‚ฌ์—์„œ๋Š” ์ด์— ๋Œ€ํ•ด ์„ค๋ช…ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค. ์ด๋“ค ์ค‘ ์ผ๋ถ€๋Š” JDK8์˜ ๋˜ ๋‹ค๋ฅธ ์ƒˆ๋กœ์šด ๊ธฐ๋Šฅ์ธ ๋žŒ๋‹ค์—์„œ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์‚ฌ์—…์„ ์‹œ์ž‘ํ•ฉ์‹œ๋‹ค.
๋ฐฐ์—ด.paralellSort()
ParallelSort์˜ ๋งŽ์€ ๊ธฐ๋Šฅ์€ ๋ฐฐ์—ด์„ ๋ฐ˜๋ณต์ ์œผ๋กœ ์—ฌ๋Ÿฌ ๋ถ€๋ถ„์œผ๋กœ ๋ถ„ํ• ํ•˜๊ณ  ์ •๋ ฌํ•œ ๋‹ค์Œ ๋™์‹œ์— ์ตœ์ข… ๋ฐฐ์—ด๋กœ ์žฌ๊ฒฐํ•ฉํ•˜๋Š” ๋ณ‘๋ ฌ ๋ณ‘ํ•ฉ ์ •๋ ฌ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ๊ธฐ๋ฐ˜์œผ๋กœ ํ•ฉ๋‹ˆ๋‹ค. ๊ธฐ์กด์˜ ์ˆœ์ฐจ Arrays.sort ๋ฉ”์„œ๋“œ ๋Œ€์‹  ์ด๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋Œ€๊ทœ๋ชจ ๋ฐฐ์—ด์„ ์ •๋ ฌํ•  ๋•Œ ์„ฑ๋Šฅ๊ณผ ํšจ์œจ์„ฑ์ด ํ–ฅ์ƒ๋ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ์•„๋ž˜ ์ฝ”๋“œ๋Š” ๋™์ผํ•œ ๋ฐ์ดํ„ฐ ๋ฐฐ์—ด์„ ์ •๋ ฌํ•˜๊ธฐ ์œ„ํ•ด ์ˆœ์ฐจ sort() ๋ฐ ๋ณ‘๋ ฌ parallelSort()๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. public class ParallelSort { public static void main(String[] args) { ParallelSort mySort = new ParallelSort(); int[] src = null; System.out.println("\nSerial sort:"); src = mySort.getData(); mySort.sortIt(src, false); System.out.println("\nParallel sort:"); src = mySort.getData(); mySort.sortIt(src, true); } public void sortIt(int[] src, boolean parallel) { try { System.out.println("--Array size: " + src.length); long start = System.currentTimeMillis(); if ( parallel == true ) { Arrays.parallelSort(src); } else { Arrays.sort(src); } long end = System.currentTimeMillis(); System.out.println( "--Elapsed sort time: " + (end-start)); } catch ( Exception e ) { e.printStackTrace(); } } private int[] getData() { try { File file = new File("src/parallelsort/myimage.png"); BufferedImage image = ImageIO.read(file); int w = image.getWidth(); int h = image.getHeight(); int[] src = image.getRGB(0, 0, w, h, null, 0, w); int[] data = new int[src.length * 20]; for ( int i = 0; i < 20; i++ ) { System.arraycopy( src, 0, data, i*src.length, src.length); } return data; } catch ( Exception e ) { e.printStackTrace(); } return null; } } ํ…Œ์ŠคํŠธ๋ฅผ ์œ„ํ•ด ์ด๋ฏธ์ง€์˜ ์›์‹œ ๋ฐ์ดํ„ฐ๋ฅผ ๋ฐฐ์—ด์— ๋กœ๋“œํ–ˆ๋Š”๋ฐ, ์ด๋Š” 46,083,360๋ฐ”์ดํŠธ๋ฅผ ์ฐจ์ง€ํ–ˆ์Šต๋‹ˆ๋‹ค. (์‚ฌ์šฉ์ž์˜ ๋ฐ์ดํ„ฐ๋Š” ์ด๋ฏธ์ง€์— ๋”ฐ๋ผ ๋‹ฌ๋ผ์ง‘๋‹ˆ๋‹ค.) ๋‹น์‹ ์ด ์‚ฌ์šฉํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค). 4์ฝ”์–ด ๋…ธํŠธ๋ถ์—์„œ ๋ฐฐ์—ด์„ ์ •๋ ฌํ•˜๋Š” ๋ฐ ์ˆœ์ฐจ ์ •๋ ฌ ๋ฐฉ๋ฒ•์€ ๊ฑฐ์˜ 3,000๋ฐ€๋ฆฌ์ดˆ๊ฐ€ ๊ฑธ๋ ธ๊ณ , ๋ณ‘๋ ฌ ์ •๋ ฌ ๋ฐฉ๋ฒ•์€ ์ตœ๋Œ€ ์•ฝ 700๋ฐ€๋ฆฌ์ดˆ๊ฐ€ ๊ฑธ๋ ธ์Šต๋‹ˆ๋‹ค. ๋™์˜ํ•˜์„ธ์š”. ์ƒˆ๋กœ์šด ์–ธ์–ด ์—…๋ฐ์ดํŠธ๋กœ ์ˆ˜์—… ์„ฑ๊ณผ๊ฐ€ 4๋ฐฐ ํ–ฅ์ƒ๋˜๋Š” ๊ฒฝ์šฐ๋Š” ์ž์ฃผ ๋ฐœ์ƒํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
๋ฐฐ์—ด.parallelPrefix()
parallelPrefix ๋ฉ”์†Œ๋“œ๋Š” ์ง€์ •๋œ ์ˆ˜ํ•™ ํ•จ์ˆ˜๋ฅผ ๋ฐฐ์—ด ์š”์†Œ์— ์ง‘ํ•ฉ์ ์œผ๋กœ ์ ์šฉํ•˜์—ฌ ๋ฐฐ์—ด ๋‚ด์˜ ๊ฒฐ๊ณผ๋ฅผ ๋ณ‘๋ ฌ๋กœ ์ฒ˜๋ฆฌํ•ฉ๋‹ˆ๋‹ค. ์ด๋Š” ๋Œ€๊ทœ๋ชจ ์–ด๋ ˆ์ด์˜ ์ˆœ์ฐจ ์ž‘์—…์— ๋น„ํ•ด ์ตœ์‹  ๋ฉ€ํ‹ฐ ์ฝ”์–ด ํ•˜๋“œ์›จ์–ด์—์„œ ํ›จ์”ฌ ๋” ํšจ์œจ์ ์ž…๋‹ˆ๋‹ค. ๋‹ค์–‘ํ•œ ๊ธฐ๋ณธ ์œ ํ˜•์˜ ๋ฐ์ดํ„ฐ ์ž‘์—…(์˜ˆ: IntBinaryOperator, DoubleBinaryOperator, LongBinaryOperator ๋“ฑ)๊ณผ ๋‹ค์–‘ํ•œ ์œ ํ˜•์˜ ์ˆ˜ํ•™ ์—ฐ์‚ฐ์ž์— ๋Œ€ํ•ด ์ด ๋ฉ”์„œ๋“œ๋ฅผ ๊ตฌํ˜„ํ•˜๋Š” ๋ฐฉ๋ฒ•์ด ๋งŽ์ด ์žˆ์Šต๋‹ˆ๋‹ค. ๋‹ค์Œ์€ ์ด์ „ ์˜ˆ์™€ ๋™์ผํ•œ ๋Œ€ํ˜• ์–ด๋ ˆ์ด๋ฅผ ์‚ฌ์šฉํ•œ ๋ณ‘๋ ฌ ์–ด๋ ˆ์ด ์Šคํƒœํ‚น์˜ ์˜ˆ์ž…๋‹ˆ๋‹ค. ์ด ์ž‘์—…์€ 4์ฝ”์–ด ๋…ธํŠธ๋ถ์—์„œ ์•ฝ 100๋ฐ€๋ฆฌ์ดˆ ๋งŒ์— ์™„๋ฃŒ๋˜์—ˆ์Šต๋‹ˆ๋‹ค. public class MyIntOperator implements IntBinaryOperator { @Override public int applyAsInt(int left, int right) { return left+right; } } public void accumulate() { int[] src = null; // accumulate test System.out.println("\nParallel prefix:"); src = getData(); IntBinaryOperator op = new ParallelSort.MyIntOperator(); long start = System.currentTimeMillis(); Arrays.parallelPrefix(src, new MyIntOperator()); long end = System.currentTimeMillis(); System.out.println("--Elapsed sort time: " + (end-start)); } ... }
๋ฐฐ์—ด.parallelSetAll()
์ƒˆ๋กœ์šด parallelSetAll() ๋ฉ”์„œ๋“œ๋Š” ํšจ์œจ์„ฑ์„ ๋†’์ด๊ธฐ ์œ„ํ•ด ๋ณ‘๋ ฌ์„ฑ์„ ์‚ฌ์šฉํ•˜์—ฌ ๋ฐฐ์—ด์„ ์ƒ์„ฑํ•˜๊ณ  ํ•ด๋‹น ๊ฐ’์„ ์ƒ์„ฑํ•œ ํ•จ์ˆ˜์— ๋”ฐ๋ผ ๊ฐ ๋ฐฐ์—ด ์š”์†Œ๋ฅผ ๊ฐ’์œผ๋กœ ์„ค์ •ํ•ฉ๋‹ˆ๋‹ค. ์ด ๋ฐฉ๋ฒ•์€ ๋žŒ๋‹ค(๋‹ค๋ฅธ ์–ธ์–ด์—์„œ๋Š” "ํด๋กœ์ €"๋ผ๊ณ  ํ•จ)๋ฅผ ๊ธฐ๋ฐ˜์œผ๋กœ ํ•ฉ๋‹ˆ๋‹ค. (๊ทธ๋ ‡์Šต๋‹ˆ๋‹ค. ๋žŒ๋‹ค์™€ ํด๋กœ์ €๋Š” ๋‹ค๋ฅด๊ธฐ ๋•Œ๋ฌธ์— ์ด๊ฒƒ์€ ์ž‘์„ฑ์ž์˜ ์‹ค์ˆ˜์ž…๋‹ˆ๋‹ค.) , ์ด๋Š” ํ–ฅํ›„ ๊ธฐ์‚ฌ์—์„œ ๋…ผ์˜ํ•  JDK8์˜ ๋˜ ๋‹ค๋ฅธ ์ƒˆ๋กœ์šด ๊ธฐ๋Šฅ์ž…๋‹ˆ๋‹ค. -> ์—ฐ์‚ฐ์ž๋กœ ๊ตฌ๋ฌธ์„ ์‰ฝ๊ฒŒ ์ธ์‹ํ•  ์ˆ˜ ์žˆ๋Š” ๋žŒ๋‹ค๋Š” ์ „๋‹ฌ๋œ ๋ชจ๋“  ์š”์†Œ์— ๋Œ€ํ•ด ํ™”์‚ดํ‘œ ๋’ค ์˜ค๋ฅธ์ชฝ์—์„œ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•œ๋‹ค๋Š” ์ ๋งŒ ์•Œ์•„๋‘๋ฉด ์ถฉ๋ถ„ํ•ฉ๋‹ˆ๋‹ค. ์•„๋ž˜ ์ฝ”๋“œ ์˜ˆ์ œ์—์„œ๋Š” i๋กœ ์ธ๋ฑ์Šค๋œ ๋ฐฐ์—ด์˜ ๊ฐ ์š”์†Œ์— ๋Œ€ํ•ด ์ž‘์—…์ด ์ˆ˜ํ–‰๋ฉ๋‹ˆ๋‹ค. Array.parallelSetAll()์€ ๋ฐฐ์—ด ์š”์†Œ๋ฅผ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด ๋‹ค์Œ ์ฝ”๋“œ๋Š” ์ž„์˜์˜ ์ •์ˆ˜ ๊ฐ’์œผ๋กœ ํฐ ๋ฐฐ์—ด์„ ์ฑ„์›๋‹ˆ๋‹ค. public void createLargeArray() { Integer[] array = new Integer[1024*1024*4]; // 4M Arrays.parallelSetAll( array, i -> new Integer( new Random().nextInt())); } ๋ณด๋‹ค ๋ณต์žกํ•œ ๋ฐฐ์—ด ์š”์†Œ ์ƒ์„ฑ๊ธฐ(์˜ˆ: ์‹ค์ œ ์„ผ์„œ์˜ ํŒ๋…๊ฐ’์„ ๊ธฐ๋ฐ˜์œผ๋กœ ๊ฐ’์„ ์ƒ์„ฑํ•˜๋Š” ์ƒ์„ฑ๊ธฐ)๋ฅผ ์ƒ์„ฑํ•˜๋ ค๋ฉด ๋‹ค์Œ๊ณผ ์œ ์‚ฌํ•œ ์ฝ”๋“œ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋‹ค์Œ์€ public void createLargeArray() { Integer[] array = new Integer[1024*1024*4]; // 4M Arrays.parallelSetAll( array, i -> new Integer( customGenerator(getNextSensorValue()))); } public int customGenerator(int arg){ return arg + 1; // some fancy formula here... } public int getNextSensorValue() { // Just random for illustration return new Random().nextInt(); } getNextSensorValue๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค. ์‹ค์ œ๋กœ๋Š” ์„ผ์„œ(์˜ˆ: ์˜จ๋„๊ณ„)์— ํ˜„์žฌ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•˜๋„๋ก ์š”์ฒญํ•ฉ๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ๋Š” ์˜ˆ๋ฅผ ๋“ค์–ด ์ž„์˜์˜ ๊ฐ’์ด ์ƒ์„ฑ๋ฉ๋‹ˆ๋‹ค. ๋‹ค์Œ customGenerator() ๋ฉ”์„œ๋“œ๋Š” ์„ ํƒํ•œ ์‚ฌ๋ก€์— ๋”ฐ๋ผ ์„ ํƒํ•œ ๋…ผ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์š”์†Œ ๋ฐฐ์—ด์„ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์— ์•ฝ๊ฐ„์˜ ์ถ”๊ฐ€ ์‚ฌํ•ญ์ด ์žˆ์ง€๋งŒ ์‹ค์ œ ๊ฒฝ์šฐ์—๋Š” ๋” ๋ณต์žกํ•ด์ง‘๋‹ˆ๋‹ค.
๋ถ„ํ• ๊ธฐ๋ž€ ๋ฌด์—‡์ž…๋‹ˆ๊นŒ?
๋™์‹œ์„ฑ๊ณผ ๋žŒ๋‹ค๋ฅผ ํ™œ์šฉํ•˜๋Š” Arrays ํด๋ž˜์Šค์— ์ถ”๊ฐ€๋œ ๋˜ ๋‹ค๋ฅธ ๊ธฐ๋Šฅ์€ ๋ฐฐ์—ด์„ ๋ฐ˜๋ณตํ•˜๊ณ  ๋ถ„ํ• ํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋˜๋Š” Spliterator์ž…๋‹ˆ๋‹ค. ๊ทธ ํšจ๊ณผ๋Š” ๋ฐฐ์—ด์—๋งŒ ๊ตญํ•œ๋˜์ง€ ์•Š๊ณ  ์ปฌ๋ ‰์…˜ ํด๋ž˜์Šค ๋ฐ IO ์ฑ„๋„์—๋„ ์ž˜ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค. ๋ถ„ํ• ๊ธฐ๋Š” ์ž๋™์œผ๋กœ ๋ฐฐ์—ด์„ ์—ฌ๋Ÿฌ ๋ถ€๋ถ„์œผ๋กœ ๋ถ„ํ• ํ•˜๋Š” ๋ฐฉ์‹์œผ๋กœ ์ž‘๋™ํ•˜๋ฉฐ, ์—ฐ๊ฒฐ๋œ ํ•˜์œ„ ๋ฐฐ์—ด์— ๋Œ€ํ•œ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๊ธฐ ์œ„ํ•ด ์ƒˆ๋กœ์šด ๋ถ„ํ• ๊ธฐ๊ฐ€ ์„ค์น˜๋ฉ๋‹ˆ๋‹ค. ๊ทธ ์ด๋ฆ„์€ ์ด๋™ ๋ฐ˜๋ณต ์ž‘์—…์„ ์—ฌ๋Ÿฌ ๋ถ€๋ถ„์œผ๋กœ "๋ถ„ํ• "ํ•˜๋Š” Iterator๋กœ ๊ตฌ์„ฑ๋ฉ๋‹ˆ๋‹ค. ๋™์ผํ•œ ๋ฐ์ดํ„ฐ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์–ด๋ ˆ์ด์—์„œ ๋ถ„ํ• ๋œ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋Ÿฌํ•œ ๋ฐฉ์‹์œผ๋กœ ๋ฐ์ดํ„ฐ์— ๋Œ€ํ•œ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๋ฉด ๋ณ‘๋ ฌ์„ฑ์„ ํ™œ์šฉํ•ฉ๋‹ˆ๋‹ค. ๊ฐ ํ•˜์œ„ ๋ฐฐ์—ด์˜ ์ตœ์†Œ ํฌ๊ธฐ์™€ ๊ฐ™์€ ๋ถ„ํ•  ๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ์„ค์ •ํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค. public void spliterate() { System.out.println("\nSpliterate:"); int[] src = getData(); Spliterator spliterator = Arrays.spliterator(src); spliterator.forEachRemaining( n -> action(n) ); } public void action(int value) { System.out.println("value:"+value); // Perform some real work on this data here... }
์ŠคํŠธ๋ฆผ - ์ฒ˜๋ฆฌ
๋งˆ์ง€๋ง‰์œผ๋กœ ๋ฐฐ์—ด์—์„œ ์ŠคํŠธ๋ฆผ ๊ฐœ์ฒด๋ฅผ ์ƒ์„ฑํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ๊ฐœ์ฒด๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์ „์ฒด ๋ฐ์ดํ„ฐ ์ƒ˜ํ”Œ์— ๋Œ€ํ•œ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ๋ฅผ ํ—ˆ์šฉํ•˜๊ณ  ์ŠคํŠธ๋ฆผ ์‹œํ€€์Šค๋กœ ์ผ๋ฐ˜ํ™”ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฐ์ดํ„ฐ ์ปฌ๋ ‰์…˜๊ณผ ์ƒˆ๋กœ์šด JDK8์˜ ์ŠคํŠธ๋ฆผ ์‚ฌ์ด์˜ ์ฐจ์ด์ ์€ ์ŠคํŠธ๋ฆผ์ด ๊ทธ๋ ‡์ง€ ์•Š์€ ๊ฒฝ์šฐ์—๋„ ์ปฌ๋ ‰์…˜์„ ์‚ฌ์šฉํ•˜๋ฉด ์š”์†Œ๋ฅผ ๊ฐœ๋ณ„์ ์œผ๋กœ ์ž‘์—…ํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด ์ปฌ๋ ‰์…˜์„ ์‚ฌ์šฉํ•˜๋ฉด ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๊ณ  ์ œ๊ฑฐํ•˜๊ณ  ์ค‘๊ฐ„์— ์‚ฝ์ž…ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ŠคํŠธ๋ฆผ ์‹œํ€€์Šค๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ฐ์ดํ„ฐ ์„ธํŠธ์˜ ๊ฐœ๋ณ„ ์š”์†Œ๋ฅผ ์กฐ์ž‘ํ•  ์ˆ˜ ์—†์ง€๋งŒ ๋Œ€์‹  ๋ฐ์ดํ„ฐ ์ „์ฒด์— ๋Œ€ํ•œ ๊ธฐ๋Šฅ์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ง‘ํ•ฉ์—์„œ ํŠน์ • ๊ฐ’๋งŒ ์ถ”์ถœ(๋ฐ˜๋ณต ๋ฌด์‹œ), ๋ฐ์ดํ„ฐ ๋ณ€ํ™˜ ์ž‘์—…, ๋ฐฐ์—ด์˜ ์ตœ์†Œ๊ฐ’๊ณผ ์ตœ๋Œ€๊ฐ’ ์ฐพ๊ธฐ, ๋งต ์ถ•์†Œ ํ•จ์ˆ˜(๋ถ„์‚ฐ ์ปดํ“จํŒ…์— ์‚ฌ์šฉ๋จ) ๋ฐ ๊ธฐํƒ€ ์ˆ˜ํ•™ ์—ฐ์‚ฐ๊ณผ ๊ฐ™์€ ์œ ์šฉํ•œ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋‹ค์Œ์˜ ๊ฐ„๋‹จํ•œ ์˜ˆ์—์„œ๋Š” ๋™์‹œ์„ฑ์„ ์‚ฌ์šฉํ•˜์—ฌ ๋ฐ์ดํ„ฐ ๋ฐฐ์—ด์„ ๋ณ‘๋ ฌ๋กœ ์ฒ˜๋ฆฌํ•˜๊ณ  ์š”์†Œ๋ฅผ ํ•ฉ์‚ฐํ•ฉ๋‹ˆ๋‹ค. public void streamProcessing() { int[] src = getData(); IntStream stream = Arrays.stream(src); int sum = stream.sum(); System.out.println("\nSum: " + sum); }
๊ฒฐ๋ก 
Java 8์€ ํ™•์‹คํžˆ ์–ธ์–ด์— ๋Œ€ํ•œ ๊ฐ€์žฅ ์œ ์šฉํ•œ ์—…๋ฐ์ดํŠธ ์ค‘ ํ•˜๋‚˜๊ฐ€ ๋  ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์— ์–ธ๊ธ‰๋œ ๋ณ‘๋ ฌ ๊ธฐ๋Šฅ, ๋žŒ๋‹ค ๋ฐ ๊ธฐํƒ€ ์—ฌ๋Ÿฌ ํ™•์žฅ ๊ธฐ๋Šฅ์€ ์šฐ๋ฆฌ ์‚ฌ์ดํŠธ์˜ ๋‹ค๋ฅธ Java 8 ๋ฆฌ๋ทฐ์˜ ์ฃผ์ œ๊ฐ€ ๋  ๊ฒƒ์ž…๋‹ˆ๋‹ค.
์ฝ”๋ฉ˜ํŠธ
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION