Java 학습노트 - 019일

7230 단어
일일 요점
Map
  • HashMap
  • TreeMap
  • /*      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));
            }
    

    범용
    일반 (generic) - 프로그램의 하드 코드가 아닌 형식을 만듭니다. (하드 코드)
    이 extends는 계승이 아니라 일반 한정입니다. 한정된 T 형식은Comparable 인터페이스의 하위 형식이어야 합니다. public static > void bubbleSort(T[] array)예.
    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));
        }
    }
    

    정책 모드
    GoF 디자인 모드 - 정책 모드(상속 구조로 가변적인 할인 정책을 봉인)
    연습하다
  • 도서컴퓨터류: 7.8% 할인 체육류: 8.8% 할인 관광음식류: 6.8% 할인 교재교재: 10위안 이상 1권당 2위안 만화: 단가 20위안 초과 성 3위안 50위안 성 10위안 100위안 성 30위안 기타 책은 일절 할인하지 않고 실제 수혜를 얼마나 받았는가:
  • 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;
        }
    }
    

    좋은 웹페이지 즐겨찾기