<div id="readability-page-1" class="page"><div><h2 id="collection">Collection</h2>
<ul>
<li>여러 데이터의 묶음을 컬렉션 이라고 부른다.</li>
<li>컬렉션은 추상된 객체이다.</li>
<li>Collection 추상체의 구상체로는 List가있다.<ul>
<li>List의 구상체로<ul>
<li>LinkedList</li>
<li>ArrayList</li>
<li>Vector</li>
<li>Stack</li>
</ul></li>
<li>Set<ul>
<li>HashSet 등등 존재한다.</li>
</ul></li>
</ul></li>
</ul>
<h3 id="collection-사용해보기">Collection 사용해보기</h3>
<pre><code>public class MyCollection&lt;T&gt; {

 private List&lt;T&gt; list;

 public MyCollection(List&lt;T&gt; list) {
 this.list = list;
 }

 // 제네릭 타입 메서드
 public &lt;U&gt; MyCollection&lt;U&gt; map(Function&lt;T, U&gt; function) {
 List&lt;U&gt; newList = new ArrayList&lt;&gt;();
 foreach(d -&gt; newList.add(function.apply(d)));
 return new MyCollection&lt;&gt;(newList);
 }

 public MyCollection&lt;T&gt; filter(Predicate&lt;T&gt; predicate) {
 List&lt;T&gt; newList = new ArrayList&lt;&gt;();
 foreach(d -&gt; {
 if(predicate.test(d))
 newList.add(d);
 });

 return new MyCollection&lt;&gt;(newList);
 }

 public void foreach(Consumer&lt;T&gt; consumer) {
 for (int i = 0; i &lt; list.size(); i++) {
 T data = list.get(i);
 consumer.accept(list.get(i));
 }
 }
 
}</code></pre>
<pre><code>public class Main {
 public static void main(String[] args) {

 // 메서드 체이닝 방식

 // type T에 맞춰질 것이다.
 new MyCollection&lt;&gt;(Arrays.asList(1, 2, 3, 4))
 .foreach(System.out::println);

 // 형태를 바꿔보기
 new MyCollection&lt;&gt;(Arrays.asList(1, 2, 3, 4, 5))
 .map(String::valueOf).foreach(System.out::println);

 // 필터를 적용해보기
 new MyCollection&lt;&gt;(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
 .filter((i) -&gt; i % 2 == 0).foreach(System.out::println);

 // 필터를 적용해보기
 int size = new MyCollection&lt;&gt;(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
 .filter((i) -&gt; i % 2 == 0).size();
 System.out.println("size = " + size);

 }
}</code></pre>
<h2 id="iterator">Iterator</h2>
<ul>
<li>여러 데이터의 묶음을 풀어서 하나씩 처리할 수 있는 수단을 제공한다.</li>
<li>next()를 통해 다음 데이터를 조회할 수 있다. 역(이전데이터)으로 움직일 수는 없다.</li>
<li></li>
</ul>
<pre><code> public static void main(String[] args) {
 List&lt;String&gt; list = Arrays.asList("A", "B", "C");
 Iterator&lt;String&gt; iter = list.iterator();

 System.out.println(iter.next()); // A
 System.out.println(iter.next()); // B
 System.out.println(iter.next()); // C
 }</code></pre>
<h2 id="stream">Stream</h2>
<ul>
<li>JAVA8 이상에서 부터 사용 가능하다.</li>
<li>데이터의 연속상에서 제공되는 하나만 취급한다.</li>
<li>System.in / System.out 이게 모두 사실 스트림이다.</li>
<li>JAVA8 에서 제공되는 스트림은 input / output에 관련된 스트림과는 다르게 데이터에 관한 스트림이다.</li>
<li>Stream에는 map, filter, forEach 같은 고차함수(함수형 인터페이스를 사용해서 함수를 인자로 받는 함수)가 제공된다.</li>
</ul>
<h3 id="stream-만들기">Stream 만들기</h3>
<ul>
<li>generator / iterator 2가지 방법이 있다.</li>
</ul>
<pre><code> // 스트림 만들기 1
 // 스트림은 데이터의 연속이기 때문에 제너레이터를 이용하면 랜덤 값을 계속 발생시킨다.
 Random r = new Random();
 Stream.generate(() -&gt; r.nextInt())
 .forEach(System.out::println);

 // 제한하고 싶다면?
 Stream.generate(() -&gt; r.nextInt())
 .limit(10)
 .forEach(System.out::println);

 // 스트림 만들기 2
 Stream.iterate(0, (i) -&gt; i + 1)
 .forEach(System.out::println);</code></pre>
<blockquote>
스트림을 사용하면 연속된 데이터에 대해서 풍부한 고차함수들을 사용하여 강력한 기능들을 간결하게 표현할 수 있습니다.
</blockquote>
<h2 id="optional">Optional</h2>
<ul>
<li>NPE(Null Pointer Exception) - 가장 많이 발생하는 에러 중 하나이다.</li>
<li>자바에서는 거의 모든것이 래퍼런스이기 때문에 모든것이 null이 될 수 있다는 뜻을 가진다.</li>
<li>항상 null을 확인할 필요가 있다. <ul>
<li>그래서 많이 피곤한 일들이 생겼다 이게 null이 아닌지 확인하는 작업을 해야했다.</li>
</ul></li>
</ul>
<blockquote>
이제부터 null 쓰지말자 ! ==&gt; 서로 약속을 했다 : 계약을 한다 : 계약을 하고 프로그래밍을 한다.
</blockquote>
<ul>
<li>옵셔널이 있기 전에는 EMPTY(public static final 객체)를 하나 만들어 사용했다.</li>
</ul>
<h3 id="정리">정리</h3>
<ul>
<li>null 데이터 : Optional.empty();</li>
<li>데이터 : Optional.of(data);</li>
<li>확인 : .isEmpty(), .isPresent()</li>
</ul></div></div>

UkJJang

HyoungUk

Collection
여러 데이터의 묶음을 컬렉션 이라고 부른다.
컬렉션은 추상된 객체이다.
Collection 추상체의 구상체로는 List가있다.
List의 구상체로
LinkedList
ArrayList
Vector
Stack
Set
HashSet 등등 존재한다.
Collection 사용해보기
public class MyCollection<T> {
 private List<T> list;
 public MyCollection(List<T> list) {
 this.list = list;
 }
 // 제네릭 타입 메서드
 public MyCollection map(Function<T, U> function) {
 List newList = new ArrayList<>();
 foreach(d -> newList.add(function.apply(d)));
 return new MyCollection<>(newList);
 }
 public MyCollection<T> filter(Predicate<T> predicate) {
 List<T> newList = new ArrayList<>();
 foreach(d -> {
 if(predicate.test(d))
 newList.add(d);
 });
 return new MyCollection<>(newList);
 }
 public void foreach(Consumer<T> consumer) {
 for (int i = 0; i < list.size(); i++) {
 T data = list.get(i);
 consumer.accept(list.get(i));
 }
 }
}
public class Main {
 public static void main(String[] args) {
 // 메서드 체이닝 방식
 // type T에 맞춰질 것이다.
 new MyCollection<>(Arrays.asList(1, 2, 3, 4))
 .foreach(System.out::println);
 // 형태를 바꿔보기
 new MyCollection<>(Arrays.asList(1, 2, 3, 4, 5))
 .map(String::valueOf).foreach(System.out::println);
 // 필터를 적용해보기
 new MyCollection<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
 .filter((i) -> i % 2 == 0).foreach(System.out::println);
 // 필터를 적용해보기
 int size = new MyCollection<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
 .filter((i) -> i % 2 == 0).size();
 System.out.println("size = " + size);
 }
}
Iterator
여러 데이터의 묶음을 풀어서 하나씩 처리할 수 있는 수단을 제공한다.
next()를 통해 다음 데이터를 조회할 수 있다. 역(이전데이터)으로 움직일 수는 없다.
 public static void main(String[] args) {
 List<String> list = Arrays.asList("A", "B", "C");
 Iterator<String> iter = list.iterator();
 System.out.println(iter.next()); // A
 System.out.println(iter.next()); // B
 System.out.println(iter.next()); // C
 }
Stream
JAVA8 이상에서 부터 사용 가능하다.
데이터의 연속상에서 제공되는 하나만 취급한다.
System.in / System.out 이게 모두 사실 스트림이다.
JAVA8 에서 제공되는 스트림은 input / output에 관련된 스트림과는 다르게 데이터에 관한 스트림이다.
Stream에는 map, filter, forEach 같은 고차함수(함수형 인터페이스를 사용해서 함수를 인자로 받는 함수)가 제공된다.
Stream 만들기
generator / iterator 2가지 방법이 있다.
 // 스트림 만들기 1
 // 스트림은 데이터의 연속이기 때문에 제너레이터를 이용하면 랜덤 값을 계속 발생시킨다.
 Random r = new Random();
 Stream.generate(() -> r.nextInt())
 .forEach(System.out::println);
 // 제한하고 싶다면?
 Stream.generate(() -> r.nextInt())
 .limit(10)
 .forEach(System.out::println);
 // 스트림 만들기 2
 Stream.iterate(0, (i) -> i + 1)
 .forEach(System.out::println);
스트림을 사용하면 연속된 데이터에 대해서 풍부한 고차함수들을 사용하여 강력한 기능들을 간결하게 표현할 수 있습니다.
Optional
NPE(Null Pointer Exception) - 가장 많이 발생하는 에러 중 하나이다.
자바에서는 거의 모든것이 래퍼런스이기 때문에 모든것이 null이 될 수 있다는 뜻을 가진다.
항상 null을 확인할 필요가 있다. 
그래서 많이 피곤한 일들이 생겼다 이게 null이 아닌지 확인하는 작업을 해야했다.
이제부터 null 쓰지말자 ! ==> 서로 약속을 했다 : 계약을 한다 : 계약을 하고 프로그래밍을 한다.
옵셔널이 있기 전에는 EMPTY(public static final 객체)를 하나 만들어 사용했다.
정리
null 데이터 : Optional.empty();
데이터 : Optional.of(data);
확인 : .isEmpty(), .isPresent()

[데브코스 2주차 - 4] TIL

댓글