Java 학습노트 - 019일

/*      Map map = new HashMap<>();
        map.put(1, "apple");
        map.put(2, "grape");
        map.put(100, "shit");
        map.put(1, "banana");
        System.out.println(map.size());
        map.remove(100);
        for (Integer key : map.keySet()) {
            System.out.println(key + " ---> " + map.get(key));
        }*/
//      Map map = new HashMap<>();
        Map map = new TreeMap<>();
        map.put("apple", "  ");
        map.put("grape", "  ");
        map.put("shit", "  ");
        map.put("banana", "  ");
        map.put("apple", "  ");
        map.put("eggplant", "  ");
        System.out.println(map.size());
        map.remove("shit");
        for (String key : map.keySet()) {
            System.out.println(key + " ---> " + map.get(key));
        }

package com.jack.test;

import java.util.Arrays;
import java.util.Comparator;

class Student implements Comparable{
    private String name;
    private int age;
    
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name + ":" + age;
    }

    @Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    
}

class Test02 {
    
    public static int max(int x, int y) {
        return x > y ? x : y;
    }
    
    //   (generic) -              (hard code)
    //    extends             T     Comparable      
    /**
     *     
     * @param array       
     */
    public static > void bubbleSort(T[] array) {
        boolean swapped = true;
        for (int i = 1;swapped && i < array.length; i++) {
            swapped = false;
            for (int j = 0; j < array.length - i; j++) {
                if (array[j].compareTo(array[j + 1]) > 0) {
                    T temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }
    
    /**
     *     
     * @param array       
     * @param comp Comparator    (   )
     */
    public static  void bubbleSort(T[] array, Comparator comp) {
        boolean swapped = true;
        for (int i = 1;swapped && i < array.length; i++) {
            swapped = false;
            for (int j = 0; j < array.length - i; j++) {
                if (comp.compare(array[j], array[j + 1]) > 0) {
                    T temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }

    public static void main(String[] args) {
        Integer[] x = {23, 13, 21, 56, 78, 62};
        // String[] x = {"killer", "grape", "apple", "blue"};
        Student[] student = {
                new Student("Li bai", 56),
                new Student("Dachui WANG", 22),
                new Student("ZhiZhang", 33)
        }; 
        bubbleSort(x);
        System.out.println(Arrays.toString(x));
        bubbleSort(student, new Comparator() {

            @Override
            public int compare(Student o1, Student o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        bubbleSort(student, (o1, o2) -> {
            return o1.getName().compareTo(o2.getName());
        });
        System.out.println(Arrays.toString(student));
    }
}

public class Book {
    private String isbn;
    private String title;
    private double price;
    private String type;
    
    // GoF     -     (                )
    private DiscountStrategy discountStrategy;
    
    public Book(String isbn, String title, double price, String type) {
        this.isbn = isbn;
        this.title = title;
        this.price = price;
        this.type = type;
    }
    
    public void setStrategy(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }
    
    public double getDiscountedPrice() {
        return price - discountStrategy.getDiscount(price);
    }

    public String getIsbn() {
        return isbn;
    }

    public String getTitle() {
        return title;
    }

    public double getPrice() {
        return price;
    }

    public String getType() {
        return type;
    }
}

/**
 *        
 * @author Kygo
 *
 */
public interface DiscountStrategy {

    /**
     *     
     * @param originalPrice   
     * @return   
     */
    public double getDiscount(double originalPrice);
}

/**
 *        
 * @author Kygo
 *
 */
public class PercentageDiscount implements DiscountStrategy {
    private double rate;
    
    public PercentageDiscount(double rate) {
        this.rate = rate;
    }
    
    @Override
    public double getDiscount(double originalPrice) {
        return originalPrice * rate;
    }
}

/**
 *       
 * @author Kygo
 *
 */
public class FixedDiscount implements DiscountStrategy {
    private double fixed;
    private double minPrice;
    
    public FixedDiscount(double fixed, double minPrice) {
        this.fixed = fixed;
        this.minPrice = minPrice;
    }

    @Override
    public double getDiscount(double originalPrice) {
        return originalPrice >= minPrice ? fixed : 0;
    }
}

/**
 *       
 * @author Kygo
 *
 */
public class SegmentedDiscount implements DiscountStrategy {

    @Override
    public double getDiscount(double originalPrice) {
        if (originalPrice < 20) {
            return 0;
        }
        else if (originalPrice < 50) {
            return 3;
        }
        else if (originalPrice < 100) {
            return 10;
        }
        else {
            return 30;
        }
    }
}

/**
 *      
 * @author Kygo
 *
 */
public class NoDiscount implements DiscountStrategy {

    @Override
    public double getDiscount(double originalPrice) {
        return 0;
    }
}