[TIL] 221020 - Java의 Collection

프레임워크를 위한 JAVA - Java의 Collection 이야기

 

1. Collection

여러 데이터의 묶음을 컬렉션이라고 합니다.

• 컬렉션은 추상체 입니다.
• Collection
  • List
    • LinkedList
    • ArrayList
    • Vector
    • Stack
  • Set
    • HashSet

 

범용적인 형태의 Collection..

// MyCollection.java
package com.programmers.java.collection;

import com.programmers.java.iter.MyInterator;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

public class MyCollection<T> {
    private List<T> list;

    public MyCollection(List<T> list){
        this.list = list;
    }

    public MyCollection<T> filter(Predicate<T> predicate){
        List<T> newList = new ArrayList<>();
        foreach(d -> {
            if (predicate.test(d)) { //test 값 -> 필터가 참이면
                newList.add(d);
            }
        });
        return new MyCollection<>(newList);
    }

    // 이 메서드에서 <U>를 제네릭으로 활용해라
    public <U> MyCollection<U> map(Function<T,U> function){
        List<U> newList = new ArrayList<>();
        foreach(d -> newList.add(function.apply(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(data);
        }
    }

    int size(){
        return list.size();
    }
    // 인터페이스를 메개변수로 넣어도되는것이군,,,,,,

    public MyInterator<T> iterator(){
        return new MyInterator<T>() {
            private int idx = 0;
            @Override
            public boolean hasNext() {
                return idx < list.size();
            }
            @Override
            public T next() {
                return list.get(idx++);
            }
        };
    }
}

// Main.java
package com.programmers.java.collection;

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
//        MyCollection<String> c1 = new MyCollection<>(Arrays.asList("11","2222","3","444","5"));
//        c1.foreach(str -> System.out.println(str));
//
//        MyCollection<Integer> c2 = c1.map(str ->str.length());
//        c2.foreach(str -> System.out.println(str));

        /////////////////////////////////////////
        // 메소드 체이닝 방식
        int s = new MyCollection<>(Arrays.asList("11","2222","3","444","5"))
                .map(str ->str.length())
                .filter(i ->i%2 == 1)
                .size();
        System.out.println(s);
                //.foreach(str -> System.out.println(str));
    }
}

⇒ 어떤 종류의 데이터가 들어오더라도 처리할 수 있도록.

⇒ Mycollection class의 내용자체를 변경하지 않고 재활용 가능!!

 

 

---

Collection을 다루는 방법 👇

 

2. Iterator

여러 데이터의 묶음을 풀어서 하나씩 처리하는 방식을 제공

• next()를 통해서 다음 데이터를 조회할 수 있습니다.
• 역으로 움직일 수 없습니다. (이전 데이터를 조회할 수 없다.)

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A","CC","BF","DFD");
        Iterator<String> iter = list.iterator();

        while(iter.hasNext()){
            System.out.println(iter.next());
        }
    }
}

데이터 한건한건에 대한 더미 처리는 할 수 없다.

 

3. Stream

데이터의 연속이다. 끊어지지않는 데이터의 흐름

• System.in / System.out
• Collections.stream() 제공 (java 8 이상)
• filter, map, forEach 같은 고차함수(함수를 인자로 받는 함수)가 제공됩니다.

public class Main {
    public static void main(String[] args) {
        Arrays.asList("SD","AA","GFE","WQW","q")
                .stream()
                .map(s -> s.length())
                .filter(i -> i % 2 == 1)
                .forEach(i -> System.out.println(i));
    }
}

 

•  list의 Stream (형변환)

Arrays.asList(1,2,3).stream();

// IntStream : primitive 타입을 위한 stream 타입
IntStream s = Arrays.stream( new int [] {1,2,3});

Stream<Integer> ss = Arrays.stream( new int [] {1,2,3}).boxed();
// List<Integer> l = ss.collect(Collectors.toList());
ss.toArray(Integer[] :: new); // type을 지정해주지 않으면 Object

 

Array(배열)와 List(리스트의 차이)

배열은 인덱스를 가진 데이터 집합(String[] str)이고, 리스트는 인덱스 없이 순차적으로 저장되는 데이터 집합(ArrayList<> str)니다. 배열은 크기를 꼭 할당해줘야하며 메모리에 연속적으로 할당된다. 리스트를 구현하는 가장 일반적인 방법은 Linked List이며 메모리에 분산 되어 저장된다. 

 

• Stream은 Stream.generate 와 Stream.iterate로 만들 수 있다.

Stream.generate(()-> 1)
                .limit(10)
                .forEach(System.out::println);

Stream.iterate(0,(i) -> i+1)
                .limit(10)
                .forEach(System.out::println); //seed 값부터

 

• 스트림을 사용하면 연속된 데이터에 대해서 풍부한 고차함수들을 사용하여 강력한 기능을 간결하게 표현할 수 있습니다.

 

 

Collection.forEach와 Stream.forEach의 차이.....추가예정

 https://dundung.tistory.com/247

---

4. Optioal

• NPE : Null Pointer Exception → 가장 많이 나는 에러중 하나
  • 자바에서는 (거의) 모든 것이 레퍼런스 ⇒ (거의) 모든것이 null이 될 수 있다.
  ⇒ 항상 null을 확인할 필요가 있습니다.

 

• 이제부터 null을 쓰지말자 → 약속 : 계약을 하고 프로그래밍을 한다.

1. EMPTY 객체를 사용하자.

// User.java
public class User {
    public static User EMPTY = new User(0,"");
    private int age;
    private String name;
}

// Main.java
public class Main {
    public static void main(String[] args) {
        User user = User.EMPTY;
				if (user != User.EMPTY){ ...
				}
    }
}

 

 2. Optional을 사용한다.

public static void main(String[] args) {
        // 값이 없을때
        Optional<User> optionalUser = Optional.empty();

        // 값이 있을때
        optionalUser = Optional.of(new User(5,"kim"));

        optionalUser.isEmpty(); // 값이 없으면(==null) ture
        optionalUser.isPresent(); // 값이 있으면 ture

				optionalUser.ifPresent(user -> {});
        optionalUser.ifPresentOrElse(user -> {}, () ->{});
    }