Collection / Container

import org.junit.Test;

import java.util.*;
import java.util.function.Function;

// 아래 코드의 문제점 3개

// Object[] data = new Object[10];
// => 클래스 계층의 시작.
// 모든 객체가 가져야 하는 특징
// 부모의 참조 변수는 자식의 객체를 참조할 수 있다. - Upcasting

// 1. list.add(new Integer(5));
// -> wrapper class
// => 원시 타입을 객체로 다룰 필요가 있기 때문에
// list.add(5);
// -> list.add(Integer.valueOf(5));


// 2. Generic 이 아니다.
// : Java5 - Auto Boxing
// Auto Unboxing

// 3. List<Integer> l = new ArrayList<>();

// Factory -> 객체를 생성하는 역활
// 정적 팩토리 메소드
// : 정적 메소드인데 객체를 생성하는 역활을 한다.
// 팩토리 클래스
// : 다른 객체를 생성하는 역활을 하는 클래스

// Method Reference


// Lint
// : 코드의 잠재적인 오류를 알려주는 시스템
public class Java0319 {


	static class Sample {
	}

	@Test
	public void goo() {
		Integer i = null;
		Integer j = 42;
		Integer k = new Integer(42);

		// null 은 레퍼런스 타입만 가질 수 있다.
		// => 객체 타입을 다룰 때, 반드시
		// NullPointerReference 오류를
		// 방지해야 한다.

		if (Integer.compare(i, j) == 0) {
			// if (i != null && i.equals(k)) {
			// if (i == k) {
			System.out.println("same");
		}

		// Auto boxing
		// => X Integer i = new Integer(42);
		// => O Integer i = Integer.valueOf(42);
		// : 정적 팩토리 메소드
		// 1) 가독성이 높다.
		// 2) 기존 코드 수정 없이 객체 생성의 정책을 변경하는 것이
		//

		// Wrapper Class => 불변 객체
		// 불변 객체는 객체가 생성되고, 내부의 상태(값)을 변경하는 것이
		// 불가능하다.
		// 1. 공유가 쉽다.
		// 2. 스레드 안전성이 있다.

		// int j = 42;
	}


	public static void foo() {
		// ArrayList, LinkedList, HashMap, TreeMap
		// => 자료구조(Collection / Container)

		// Object 기반으로 설계되어 있다.
		// 1. 모든 객체의 참조를 저장하는 것이 가능하다.
		// => 위의 방법은 좋은 방법이 아니다.
		// => 다양한 타입을 저장한 다는 것은
		// 어떠한 타입인지에 대한 추가적인 정보가 필요하다.
		// => 다양한 타입을 저장할 수 있지만, 하나의 타입만 저장하는 것이 편리하다.

		// 2. 반드시 꺼낼 때 캐스팅이 필요하다.

		// Generic 기반의 컬렉션을 사용한다면, 위의 문제를 해결하는 것이 가능하다.
		ArrayList<Double> arr = new ArrayList<>();
		// Java 7 부터는 객체 생성시의 제네릭 인자를 생략하는 것이 가능하다.
		// => Diamond operator

		arr.add(10.0);
		arr.add(3.14);
		// arr.add(42);

		Double d = arr.get(0);

		// Generic
		// 1. 불필요한 캐스팅을 제거할 수 있다.
		// 2. 컴파일 타임에 잘못된 타입에 대한 오류를 알려준다.

		/*
		ArrayList arr2 = new ArrayList();
		arr2.add(10); // Integer
		// arr.add(new Sample());
		arr2.add(3.14); // Double

		Double d = (Double) arr.get(1); // Integer, Double, Sample, ..
		*/

	}


	public static void main(String[] args) {
		List<Integer> list1 = new ArrayList<>();
		list1.add(5);
		list1.add(4);
		list1.add(2);
		list1.add(0);
		list1.add(1);
		list1.add(3);

		List<Integer> list2 = new ArrayList<>(list1.subList(1, 4));

		print(list1, list2);

		Collections.sort(list1);
		Collections.sort(list2);
		print(list1, list2);

		System.out.println("list1.containsAll(list2):" + list1.containsAll(list2));

	}

	class User {
		private int age;
		private String name;

		public int getAge() {
			return age;
		}

		public String getName() {
			return name;
		}
	}

	interface Function<T, R> {
		R apply(T e);
	}

	<T, R extends Comparable<? super T>> Comparator<T> comparing(Function<T, R> func) {
		return new Comparator<T>() {
			@Override
			public int compare(T o1, T o2) {
				return func.apply(o1).compareTo(o2);
			}
		};
	}

	@Test
	public void hoo() {
		User[] arr = {};

	// Comparator comparing
	// : 특정 객체의 특정 값을 키로 뽑아내고 싶을 때

	// Comparator.comparing => Comparator<>

	// Arrays.sort(arr, Java0319.comparing(User::getName));

		Arrays.sort(arr, Comparator.comparing(User::getName));


	}


	private static void print(List<Integer> list1, List<Integer> list2) {
	// Integer[] arr = {1, 3, 5, 7, 9};
		User[] arr = {};

	// Arrays.sort(arr, (o1, o2) -> Integer.compare(o1, o2));
	// Arrays.sort(arr, Integer::compare);


		Arrays.sort(arr, Comparator.comparingInt(User::getAge));


	}
}