Thread, Generic, Lambda, Collection Framework

cpu(코어): 하나의 cpu 당 하나의 프로세스(프로그램이 하나의 작업실을 차지했다 라고 생각하면 된다)

그 프로세스 안에서(이클립스같은 프로그램 안에서) 멀티 스레드가 생성(main메서드도 스레드)

​

멀티태스킹: 여러 프로세스, 스레드가 동시에 작업(다같이 동시에가 아니고 돌아가면서 하나씩 수행중인것이다/빨라서 같이 돌아가는 형태로 보임)

​

process&Thread

​

스레드

동시성: 동시에 실행하기 위해 번갈아 작업하는 특성

벙렬성

중요한 스레드는 이미 구현되어 있으니 스레드 처리를 할 일은 별로 없다.

​

Network

file download: 스레드로 구현되어 다운로드 받고있다.

​

스케줄링

스레드의 개수가 코어의 수보다 많을 경우

스레드를 순서를 정해서 어떻게 동시성으로 실행할지 결정(wait 시켰다가 끝나면 다음 스레드를 awake 함)

​

제너릭(Generic)

- 제너릭(generic)

​

자바5부터 제너릭타입이 새로 추가 되었는데 제너릭타입을 사용함으로서 잘못된 타입이 사용될

수 있는 문제를 컴파일단계에서부터 방지할 수가 있게 되었다.

제너릭은 컬렉션, 스트림, 람다식, NIO에서 널리 사용되기 때문에 제너릭을 이해하지 못하고서는

API 문서를 이해할 수가 없다.

​

제너릭은 클래스와 인터페이스, 메서드를 정의할 때 타입을 매개값으로 사용할 수 있도록 한다.

타입파라미터는 코드 작성시에 구체적인 타입으로 대체되어 다양한 코드를 생성할 수 있도록 한다.

​

제너릭을 사용하는 이점은

1. 컴파일시 강한 타입체크를 할 수 있다.(빨간오류로 알려주게된다)

2. 타입변환을 하지 않아도 된다.

​

제너릭타입(클래스명<T>, 인터페이스명<T>)

​

제너릭타입은 타입을 파라미터로 갖는 클래스와 인터페이스를 말한다. 제너릭타입은 클래스 또는

인터페이스 이름뒤에 "<>"부호가 붙고 그 사이에 타입파라미터를 지정한다.

​

타입파라미터는 변수명과 동일한 규칙에 따라 작성이 가능하지만 일반적으로 대문자 알파벳 한

글자로 표현한다.

 

​- 제네릭메서드(<T,R>R method(T t))

​

제너릭메서드는 매개타입과 리턴타입으로 타입파라미터를 갖는 메서드를 말한다.

메서드를 선언하는 방법은 리턴타입 앞에 <>기호를 추가하고 타입파라미터를 기술한

후에 리턴타입과 매개타입으로 타입파라미터를 사용하면 된다.

​

일반: public String method(String a){}

제네릭: public <T>Box<T> method(T t){}

-> public <타입파라미터,...> 리턴타입<T> 메서드명(매개변수){}

​

제네릭메서드는 2가지 방법으로 호출할 수 있다. 코드에서 타입파라미터의 구체적인

타입을 명시적으로 지정하거나 컴파일러가 매개값의 타입을 보고 구체적인 타입을 추정

할 수도 있다.

컬렉션(Collection)

List계열

​

Map계열(key,value)

---

제너릭(Generic)1

:nongeneric 일 때

public class Box {
    
    private Object object;
 
    public Object getObject() {
        return object;
    }
 
    public void setObject(Object object) {
        this.object = object;
    }
    
}
 
class Apple{
    @Override
    public String toString() {
        return "사과";
    }
}

public class BoxMain {
 
    public static void main(String[] args) {
        
        Box box = new Box();
        box.setObject("망치");//Object 이니까 String클래스의 상속관계인건 당연.
//        box.setObject(new String("망치")); 위와 동일
        //Object가 String으로 형변환
        
        String hammer = (String)box.getObject(); 
//        생성자는 String이지만 이 메서드는 꺼내올 땐 
//        return변수형인 Object형으로 나오니까 강제형변환이 필요함
        
        box.setObject(new Apple());
//        String apple = (String) box.getObject();
//        System.out.println(apple);
//        컴파일전엔 오류가 없는걸로 보이지만 실제로는 String이 아니라 Apple객체가 들어가 있어서
//        실행시 오류가 남, 즉 뭐가 들어있는지 일일이 확인해야 함.
        
        box.setObject(new Apple());
        Apple apple1 = (Apple) box.getObject();
//        String str = (String) box.getObject();
//        위와 동일한 이유로 오류.
        System.out.println(apple1);        
    }
 
}

---

제너릭(Generic)2

:generic 일 때

public class Box<T> {
 
    private T t;
 
    public T getT() {
        return t;
    }
 
    public void setT(T t) {
        this.t = t;
    }
 
}
 
class Apple {
    @Override
    public String toString() {
        return "사과";
    }
}

public class BoxMain {
 
    public static void main(String[] args) {
 
        Box<Apple> box =new Box<>();
        box.setT(new Apple());
//        box.setT(1); 
//        당연히 오류, 위에서 제너릭지정해줬기 때문에 대입까지도 가능했지만 출력시 오류
//        (Object니까 다 들어가짐)
        
        Apple apple = box.getT();//형변환도 필요없음. 반환형도 T로 설정했기 때문
//        String str = (String)box.getT();
//        nongeneric에서는 에러가 걸리지 않았지만 여기선 컴파일부분부터 에러로 표시해줌
        System.out.println(apple);
        
        Box<String> toolBox = new Box<>();
        toolBox.setT("망치");
        String hammer = toolBox.getT();
        System.out.println(hammer);
        
    }
}

---

제너릭(Generic)3

:두개의 생성한 객체를 가지고 실습

public class Product<T,V> {
 
    private T kind;
    private V model;
    
    public T getKind() {
        return kind;
    }
    public void setKind(T kind) {
        this.kind = kind;
    }
    public V getModel() {
        return model;
    }
    public void setModel(V model) {
        this.model = model;
    }
}
 
class Car{
    
    @Override
    public String toString() {
        return "Car";
    }
}
class TV{
    
    @Override
    public String toString() {
        return "TV";
    }
}

    public static void main(String[] args) {
 
        Product<TV, String> tv = new Product<TV, String>();
        //<> 둘중 하나에만 선언해도 된다 자바7버전부터
        tv.setKind(new TV());
        tv.setModel("스마트TV");
        TV tvProduct = tv.getKind();
        String tvModel = tv.getModel();
        
        Product<Car,String> car = new Product<Car, String>();
        car.setKind(new Car());
        car.setModel("포르쉐");
        Car carProduct = car.getKind();
        String carModel = car.getModel();
        
        //String, String
        Product<String,String> str = new Product<String, String>();
        str.setKind("String");
        str.setModel("문자열");
        String strProduct = str.getKind();
        String strModel = str.getModel();
        
        //Integer, Integer
        Product<Integer,Integer> itg = new Product<Integer, Integer>();
        itg.setKind(1234);
        itg.setModel(5678);
        Integer itgProduct = itg.getKind();
        Integer itgModel = itg.getModel();
        
        System.out.println(tvProduct);  //TV
        System.out.println(tvModel);    //스마트TV
        System.out.println();
        System.out.println(carProduct); //Car
        System.out.println(carModel);   //포르쉐
        System.out.println();
        System.out.println(strProduct); //String
        System.out.println(strModel);   //문자열
        System.out.println();
        System.out.println(itgProduct); //1234
        System.out.println(itgModel);   //5678
        
    }

---

제네릭(Generic) 메서드

public class Box<T> {
 
    private T t;
    public T get() {return t;}//getter
    public void set(T t) {this.t = t;}//setter
}

public class Util {
 
    //1. 일반메서드
    public static Box1 boxing1(String t) {//String이 들어와야함
        Box1 box1 = new Box1();
        box1.set(t);
        return box1;
    }
    
    //2. 제너릭메서드
    public static <T>Box<T> boxing(T t) {
        //앞의 <T> 는 매개변수가 제너릭 타입임을 나타냄
        //뒤는 클래스 자체가 제너릭형이 되었기때문에 Box<T>로 쓰임
        Box<T> box = new Box<>();
        box.set(t);
        return box;
    }
    
}
 
//그냥 일반 메서드 예시를 위해 만든 박스
class Box1{
    
    private String t;
    public String get() {return t;}
    public void set(String t) {this.t = t;}
}

public class GenericMain {
 
    public static void main(String[] args) {
 
        Box<Integer> boxA = Util.boxing(100); // static메서드, 생성자생성메서드
        int val1 = boxA.get();
        System.out.println(val1);
        
        Box<String> boxB = Util.<String>boxing("Hammer");
        String val2 = boxB.get();
        System.out.println(val2);
        
        Box<Apple> boxC = Util.<Apple>boxing(new Apple());
//        Box<Apple> boxC = Util.boxing(new Apple()); 메서드앞 리턴타입<Apple>생략가능
        Apple apple = boxC.get();
        System.out.println(apple);
    }
 
}
 
class Apple {
    @Override
    public String toString() {
        return "사과";
    }
}

public class Pair<K, V> {
    
    private K key;
    private V value;
    
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
 
    public K getKey() {
        return key;
    }
 
    public void setKey(K key) {
        this.key = key;
    }
 
    public V getValue() {
        return value;
    }
 
    public void setValue(V value) {
        this.value = value;
    }
}

public class Util {
 
    public static <K, V> boolean compare(Pair<K,V> p1 , Pair<K,V> p2) {
        //<K, V> boolean 이 메서드는 제너릭타입으로 K,V를 매개변수로 가져올거다.
        boolean keyCompare = p1.getKey().equals(p2.getKey());
        boolean valCompare = p1.getValue().equals(p2.getValue());
        return keyCompare && valCompare;
    }
}

    public static void main(String[] args) {
 
        Pair<Integer, String> p1 = new Pair<>(1, "소향");
        Pair<Integer, String> p2 = new Pair<>(1, "소향");
 
//        1. 명시적으로 제네릭메서드 호출
        boolean result = Util.<Integer, String>compare(p1, p2);
 
        if (result) {
            System.out.println("논리적으로 동등한 객체");
        } else {
            System.out.println("논리적으로 다른 객체");
        }
 
//        2. 묵시적으로 제네릭메서드 호출
        Pair<String, String> p3 = new Pair<String, String>("홍길동", "951118-1234567");
        Pair<String, String> p4 = new Pair<String, String>("홍길동", "881118-1234567");
 
        result = Util.compare(p3, p4);//String, String 컴파일러가 알아서 형 변환해줌
        if (result) {
            System.out.println("논리적으로 동등한 객체");
        } else {
            System.out.println("논리적으로 다른 객체");
        }
    }

---

public class Util {
    // 제네릭타입에 extends키워드를 사용하면 특정타입의 자손만
    // 대입할 수 있도록 제한할 수 있다.
    
    public static <T extends Number> int compare(T t1, T t2) {
        double v1 = t1.doubleValue();
        double v2 = t2.doubleValue();
        System.out.println(v1);
        System.out.println(v2);
        return Double.compare(v1,v2);// -1, 0, 1
    }
}

public class BoundedMain {
 
    public static void main(String[] args) {
 
        //타입을 Number의 자손 즉, int,double 등만 대입되도록 제한되어 있다.
        //int val = Util.compare("A", 20); (x)
        
        int val = Util.compare(10, 20);//메서드안에서 자동 형변환 이뤄짐
        System.out.println(val);
        
        
        val = Util.compare(205, 4.5);
        System.out.println(val);
        
        val = Util.compare(2, 2);
        System.out.println(val);
        
//        출력
//        10.0
//        20.0
//        -1
//        205.0
//        4.5
//        1
//        2.0
//        2.0
//        0
    
    }
}