public static void main(String[] args) {
    System.out.println(1.03-0.42); // 0.6100000000000001
    System.out.println(1.00 - 9 * 0.10); // 0.09999999999999998
}

double funds = 1.00;
int itemsBought = 0;
for (double price = 0.10 ; funds >= price ; price += 0.10){
    funds -= price;
    itemsBought++;
}
System.out.println(itemsBought + "개 구입"); // 3개 구입
System.out.println("잔돈(달러):"+ funds ); // 잔돈(달러):0.3999999999999999

// BigDecimal을 활용한 정확한 계산
final BigDecimal TEN_CENTS = new BigDecimal("0.10");
BigDecimal funds = new BigDecimal("1.00");
int itemsBought = 0;
for (BigDecimal price = TEN_CENTS ; funds.compareTo(price) >= 0 ; price = price.add(TEN_CENTS)){
    funds = funds.subtract(price);
    itemsBought++;
}
System.out.println(itemsBought + "개 구입");
System.out.println("잔돈(달러):"+ funds );

// java9의 inputStream에 추가된 transferTo Method

public static void main(String[] args) throws IOException {
    try(InputStream in = new URL(args[0]).openStream()){
        in.transferTo(System.out); //url 내용을 console에 출력
    }
}

// collection 순회
for(Iterator<Element> i = c.iterator(); i.haxNext(); ){
    Element e = i.next();
}
// 배열 순회
for(int i = 0; i < a.length ; i++){
    //a[i];
}

for ( Element e : elements ){
    // e
}

/***
* Returns the element at the specified position in this list. --> method가 무엇을 하는지 기술하는 요약 설명 
                                                                (this:호출된 method가 가르키는 객체)
* <p> This method is <i> not </i> guaranteed to run in constant time. 
* In some complementations it may run in time proportional to element position 
*
*  @param index  idnex of element to return; must be non-negative and less than the size of this list
*  @return the element at the specified position in this list
*  @throws IndexOutOfBoundsException if the index is out of range 
*           ( {@code index< 0 || index >= this.size() })
*/

E get(int index);

/**
* A suspect , such as Colonel Mustard or {@listeral Mrs.} Peacok.
*/
public class Suspect{...}

/**
* {@summary A suspect , such as Colonel Mustard or Peacok.}
*/
public class Suspect{...}

- ArrayList (int intialCapacity) : Constructs an empty list with the specified initial capacity

- Instant : An instantaneous point on the time-line.

// collection에서 최댓값을 구하는 method로 collection이 비어있으면 IllegalArgumentException을 던진다. 
public static <E extends Comparable<E>> E max(Collection<E> c){
    if(c.isEmpty()){
        throw new IllegalArgumentException("빈 collection");
    }
    E result = null;
    for (E e : c) {
        if(result == null || e.compareTo(result)>0){
            result = Objects.requireNonNull(e);
        }
    }
    return result;
}

public static <E extends Comparable<E>> Optional<E> max(Collection<E> c){
    if(c.isEmpty()){
       return Optional.empty();
    }
    E result = null;
    for (E e : c) {
        if(result == null || e.compareTo(result)>0){
            result = Objects.requireNonNull(e);
        }
    }
    return Optional.of(result);
}

public static <E extends Comparable<E>> Optional<E> max(Collection<E> c){
    return c.stream().max(Comparator.naturalOrder());
}

private final List<Cheese> cheeseInStock = null;

public List<Cheese> getCheese(){
    return cheeseInStock.isEmpty() ? null : new ArrayList<>(cheeseInStock);
}

List<Cheese> cheese = shop.getCheese();
if(cheese != null){
    // ...
}

static int sum(int... args){
        int sum = 0;
        for (int arg : args) {
            sum += arg;
        }
        return sum;
}

static int min(int... args){
    if(args.length == 0){
        throw new IllegalArgumentException("인수가 1개 이상 필요합니다.");
    }
    int min = args[0];
    for(int i = 1; i< args.length ; i++) {
        if (args[i] < min) {
            min = args[i];
        }
    }
    return min;
}

static int min(int firstArg , int... remainingArgs){
        int min = firstArg;
        for (int arg : remainingArgs) {
            if(arg<min){
                min = arg;
            }
        }
        return min;
    }

public class CollectionClassifier {

    public static String classify(Set<?> s){
        return "set";
    }
    public static String classify(List<?> lst){
        return "list";
    }
    public static String classify(Collection<?> c){
        return "others";
    }

    public static void main(String[] args) {
        Collection<?>[] collections = {
                new HashSet<String>(),
                new ArrayList<BigInteger>(),
                new HashMap<String,String>().values()
        };

        for (Collection<?> c : collections) {
            System.out.println(classify(c));
        }
    }
}

class Wine{
    String name() {return "Wine";}
}

class SparklingWine extends Wine{
    @Override
    String name() {return "SparklingWine";}
}
class Champagne extends SparklingWine{
    @Override
    String name() {return "Champagne";}
}

public class Overriding {

    public static void main(String[] args) {
        List<Wine> wineList = List.of(new Wine(), new SparklingWine(), new Champagne());
        for (Wine wine : wineList) {
            System.out.println("wine.name() = " + wine.name());
        }
    }
}

public static String classify(Collection<?> c){
    return c instanceof Set ? "set" : c instanceof List ? "list" : "others";
}