[제네릭] 외우기

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class class4s {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<Long> lList = new ArrayList<Long>();

        for (int i = 0; i < 10; i++) {
            lList.add((long) 5 * i);
        }

        System.out.println(class4.
                <Long>sumList(lList));


        ///////////////여기까지 첫번째
        System.out.println(
        );
        List<Number> numList =
                new ArrayList<Number>();

        for (int i = 0; i < 10; i++) {
            numList.add((Integer) 3 * i);
        }

        System.out.println(class4.max(numList));
///여기까지 두번쨰
        System.out.println();
        Map<String, Integer> map =
                new HashMap<String, Integer>();

        for (int i = 0; i < 10; i++) {
            map.put(String.valueOf(i),
                    Integer.valueOf(
                            (int) (Math.random() * 100) + 1)
            );
            System.out.print(" "+
                    map.get(String.valueOf(i)) + " "
            );
        }

        System.out.println();
        System.out.println("결과 : "+
                class4.maxKey(map)
        );
    }

    //리스트를 받아서 리스트 요소의 합계를 리턴
    public static <T extends Number> double
    sumList(List<T> tList) {
        double sum = 0.0;

        for (T t : tList) {
            sum += t.doubleValue();
        }

        return sum;
    }

    //와일드카드는 매개변수로만 사용가능하다.
    public static int
    max(List<? super Integer> list) {
        int max = (int) list.get(0);

        for (int i = 1; i < list.size(); i++) {
            if ((int) list.get(i) > max) {
                max = (int) list.get(i);
            }
        }

        return max;
    }

    public static <K, V extends Number>
    int sumMapValue(Map<K, V> map) {
        int sum = 0;

        for (V v : map.values()) {
            sum += (int) v;
        }

        return sum;
    }

    //Map의 value의 맥스값을 찾고 해당 키값을 리턴하는 메소드
    public static <K, V extends Number>
    K maxKey(Map<K, V> map) {
        K maxkey = null;
        V maxval = null;

        int index = 0;
        for (Map.Entry<K, V> ent : map.entrySet()) {
            if (index == 0) {
                maxkey = ent.getKey();
                maxval = ent.getValue();
            } else {
                if (ent.getValue().doubleValue()
                        > maxval.doubleValue()) {
                    maxkey = ent.getKey();
                    maxval = ent.getValue();
                }
            }

            index++;
        }


        return maxkey;
    }
}

//맵을 받고 V는 넘버를 상속받음. 밸류 맥스값의 키값을 리턴 맵을 인자로 받음.

//인티저를 수퍼로 받는 리스트에서 가장 큰 값을 꺼내서 리턴. 리스트를 인자로 받음. 인트리턴

//맵에서 V는 숫자를 상속. 전체합을 리턴

// T리스트. T는 숫자를 상속. 리스트를 인자로 받음. sum을 리턴

//두 리시트를 병합하고 공통 요소를 반환