Java 作業 1118/1119

A:簡答題
1、請把我們講解過的所有類中的方法在API中找到，並使用自己的話進行描述
答案：
    Map
        public V put(K key, V value)： 
        放入鍵值對的方法 , 第一次放入返回的值是null 之後返回的是上一次放入的值
        如果下一次和之前放入的鍵值對的鍵一樣,那麼值覆蓋
        public void clear()：
        暴力刪除
        public V remove(Object key): 
        通過鍵移除該鍵值對 並返回被移除的鍵值對的值
        public boolean containsKey(Object key)： 
        判斷集合裏是否包含這個鍵
        public boolean containsValue(Object value)：
        判斷集合裏是否包含這個值
         public boolean isEmpty():
        判斷這個集合是否爲空
        public Set<Map.Entry<K,V>> entrySet()：
        創建一個Set集合 裏面放入鍵值對
        public V get(Object key): 
        通過鍵來返回對應的值
        public Set<K> keySet() : 
        創建一個Set集合裏面放入該集合的鍵
        public Collection<V> values():
        額...
        public int size()： 
        返回該集合的長度
        Collections
        public static <T> void sort(List<T> list) : 
        對該集合進行自然排序
        public static <T> int binarySearch(List<?> list,T key)：
        二分查找
        public static <T> T max(Collection<?> coll) 
        最大值?????
        public static void reverse(List<?> list) 
        反轉該集合
        public static void shuffle(List<?> list) 
        打亂集合
        public static <T> void sort(List<T> list, Comparator<T> c)
        比較器排序

        2、請說明Map接口和Collection接口的區別
        Map是一個雙列集合 Collection是單列集合
        3、請寫出Map集合的遍歷方式
        1) 使用keySet和get方法 
        2) entrySet方法
        4、請說明HashMap和Hashtable的區別
        HashMap是一個雙列集合 非同步 可以使用null 不保證順序
        Hashtable  單列集合 同步  不能使用null 保證順序
        5、請解釋Collection與Collections的區別
            Collection是個接口  Collections是一個方法類
        6、請自己整理份集合知識點文檔

        1、給出以下代碼，請問該程序的運行結果是什麼？如有問題，請說明原因。
            class Test {
                public static void main(String[] args) {
                    HashMap<Integer, String> hm = new HashMap<Integer, String>();
                    hm.put(new Integer(23), "Jim");
                    hm.put(new Integer(23), "Kevin");
                    Set<Integer> keys = hm.keySet();
                    for (Integer key : keys) {
                        String value = hm.get(key);
                        System.out.println( value );
                    }
                }
            }
            運行結果是 Kevin  因爲第二次輸入的鍵和第一次一樣 所以覆蓋
        2、給出以下代碼，已定義好Car類，請問該程序的運行結果是什麼？如有問題，請說明原因。
                class Test {
                    public static void main(String[] args) {
                        HashMap<Car, String> hm = new HashMap<Car, String>();
                        hm.put(new Car("寶馬x5", 2014), "Jim");
                        hm.put(new Car("寶馬x5", 2014), "Kevin");
                        Set<Car> cars = hm.keySet();
                        for (Car car : cars) {
                            String value = hm.get(car);
                            System.out.println(value);
                        }
                    }
                }
            運行結果是 Jim
                        Kevin
                    因爲給出的Car類中沒有重寫HashCode和equals方法
        3、給出以下代碼，請問該程序的運行結果是什麼？如有問題，請說明原因。
                class Test {
                    public static void main(String[] args) {
                        TreeMap<Integer, String> tm = new TreeMap<Integer, String>();
                        tm.put(new Integer(11), "Tom");
                        tm.put(new Integer(45), "David");
                        tm.put(new Integer(23), "Jim");
                        tm.put(new Integer(23), "Kevin");

                        Set<Integer> keys = tm.keySet();
                        for (Integer key : keys) {
                            String value = tm.get(key);
                            System.out.println( key +"--"+value );
                        }
                    }
                }

            結果是  11--Tom
                    23--Kevin
                    45--David
                    因爲第4次輸入的鍵和第三次的一樣所以值覆蓋
                    然後TreeMap自動排序
        4、給出以下代碼，已定義好Car類，請問該程序的運行結果是什麼？如有問題，請說明原因。
                class Test {
                    public static void main(String[] args) {
                        TreeMap<Car, String> tm = new TreeMap<Car, String>(
                                new Comparator<Car>() {
                                    @Override
                                    public int compare(Car c1, Car c2) {
                                        int num1 = c1.getYear() - c2.getYear();
                                        int num2 = (num1 == 0) ? (c1.getBrand().compareTo(c2
                                                .getBrand())) : num1;
                                        return num2;
                                    }
                                });
                        tm.put(new Car("寶馬X5", 2014), "Tom");
                        tm.put(new Car("寶馬X5", 2014), "David");
                        tm.put(new Car("奧迪Q7", 2014), "Jim");
                        tm.put(new Car("奧迪A4L", 2014), "Kevin");
                        Set<Car> cars = tm.keySet();
                        for (Car car : cars) {
                            String value = tm.get(car);
                            System.out.println(car.getBrand() + "--" + car.getYear() + "--"
                                    + value);
                        }
                    }
                }

            結果是 :   奧迪A4L--2014--Kevin
                        奧迪Q7--2014--Jim
                        寶馬X5--2014--David

                        按照比較器裏面的代碼 現比較年份 年份相等
                        然後比較牌子 按照String裏的compareTo 奧迪A4L最小 然後奧迪Q7 然後寶馬X5
                        然後David覆蓋Tom

package org.westos.Homwork;

import java.io.File;

/**
 * 1:需求：遞歸刪除帶內容的目錄 假設刪除當前項目下的目錄:demo,demo中可以有文件夾自己給出
 * */
public class DeleteFilePractice {
    public static void main(String[] args) {
        File file = new File("F:\\Practice\\Demo");
        recDel(file);
    }
    public static void recDel(File file) {
        File[] sonFiles = file.listFiles();
        for(File s : sonFiles) {
            if(s.isDirectory()) {
                recDel(s);
            }else {
                s.delete();
            }
        }
        file.delete();
    }



}

package org.westos.Homwork;
/**
 * 2:需求：請大家把E:\JavaSE目錄下所有的java結尾的文件的絕對路徑給輸出在控制檯。
 * */
import java.io.File;
import java.io.FilenameFilter;

public class FilePractice {
    public static void main(String[] args) {
        File file = new File("F:\\JavaSE");
        String [] str = file.list();
        System.out.println("F盤JavaSE下的所有文件和目錄:");
        for(String s : str) {
            System.out.println(s);
        }
        System.out.println("-----------------------------------");
        System.out.println("裏面以java結尾的文件的絕對路徑");
        File[] fi = file.listFiles(new FilenameFilter() {

            @Override
            public boolean accept(File dir, String name) {
                return new File(dir,name).isFile() && name.endsWith("java");
            }

        });
        for(File f : fi) {
            System.out.println(f.getAbsolutePath());
        }
    }
}

3:下面程序段的執行結果是什麼？（   ）
　　public class Foo{ 
　　　public static void main(String[] args){ 
　　　　try{
　　　　　　return;} 
　　　　　　finally{System.out.println("Finally");
　　　　　} 
　　　} 
　　}
B．
A．編譯能通過，但運行時會出現一個例外。  B．程序正常運行，並輸出 "Finally"。
C．程序正常運行，但不輸出任何結果。　D．因爲沒有catch語句塊，所以不能通過編

4:對於已經被定義過可能拋出異常的語句，在編程時（  ）。A
A．必須使用try／catch語句處理異常，或用throw將其拋出。
B．如果程序錯誤，必須使用 try／catch語句處理異常。
C．可以置之不理。
D．只能使用try／catch語句處理。

5:哪個關鍵字可以拋出異常？（C  ） 
A．transient      B．throw     C．finally      D．catch
6:請問所有的異常類皆繼承哪一個類？（  a ）
A．java.lang.Throwable　　     B．java.lang.Exception
C．java.lang.Error　           D．java.io.Exception
7.System類在哪個包中？（ B ）
A．java.awt     B．java.lang   C．java.util   D．java.io

package org.westos.Practice;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

/**
 * 2、請編寫程序，存儲自定義對象到HashMap集合中，並採用兩種方式遍歷
 * 3、請編寫程序，存儲自定義對象到TreeMap集合中，並採用兩種方式遍歷
 * */
public class Homework02 {
    public static void main(String[] args) {
        HashShow();
        TreeShow();
    }
    //HashMap自定義對象及遍歷
    public static void HashShow() {
        System.out.println("HashMap自定義對象及遍歷");
        HashMap<Student , Integer> hm = new  HashMap<Student , Integer>();
        hm.put(new Student("流通",21),1402);
        hm.put(new Student("趙歡",23),1402);
        hm.put(new Student("瑤瑤",20),1402);
        //第一種
        Set<Student> keySet = hm.keySet();
        for(Student key: keySet) {
            System.out.println(key+"=="+hm.get(key));
        }
        System.out.println("-----------");
        //第二種
        Set<Entry<Student, Integer>> entrySet = hm.entrySet();
        for(Entry<Student, Integer>  entry: entrySet) {
            System.out.println(entry);
        }
    }
    //TreeMap自定義對象 構造器排序及遍歷
    public static void TreeShow() {
        System.out.println("TreeMap自定義對象 構造器排序及遍歷");
        TreeMap<Student , Integer> tm = new  TreeMap<Student , Integer>(new Comparator<Student>() {

            @Override
            public int compare(Student s1, Student s2) {
                int num1 = s1.getAge()-s2.getAge();
                int num2 = num1==0? s1.getName().compareTo(s2.getName()): num1;
                return num2;
            }
        });
        tm.put(new Student("流通",21),1402);
        tm.put(new Student("趙歡",23),1402);
        tm.put(new Student("瑤瑤",20),1402);
        //第一種
        Set<Student> keySet = tm.keySet();
        for(Student key : keySet) {
            System.out.println(key+"--"+tm.get(key));
        }
        System.out.println("-----------");
        //第二種
        Set<Entry<Student, Integer>> entrySet = tm.entrySet();
        for(Entry<Student, Integer>  entry: entrySet) {
            System.out.println(entry);
        }
    }
}

package org.westos.Practice;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

/**
 * 4、請編寫程序，完成集合嵌套,並遍歷
            jc  基礎班
                    張三      20
                    李四      22
            jy  就業班
                    王五      21
                    趙六      23
 * */
public class Homework03 {
    public static void main(String[] args) {
        HashMap<String, Integer> jc = new HashMap<String, Integer>();
        HashMap<String, Integer> jy = new HashMap<String, Integer>();
        jc.put("張三", 20);
        jc.put("李四", 22);
        jy.put("王五", 21);
        jy.put("趙六", 23);
        HashMap<HashMap, String> home = new HashMap<HashMap, String>();
        home.put(jc,"基礎班");
        home.put(jy, "就業班");

        Set<HashMap> homeKey = home.keySet();
        for(HashMap s : homeKey ) {
            System.out.println(home.get(s));
            Set<String> key = s.keySet();
            for(String s1: key) {
                System.out.println(s1+"--"+s.get(s1));
            }
        }

    }
}

package org.westos.Practice;
/**
 * 鬥地主發牌
 * */
import java.util.ArrayList;
import java.util.Collections;
import java.util.Set;
import java.util.TreeMap;

public class Homework04 {
    public static void main(String[] args) {
        TreeMap<Integer, String> tm= new TreeMap<Integer, String>();
        String[] color = {"♥","♠","♦","♣"};
        String[] number = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        int i=54;
        for(String n : number) {
            for(String c : color) {
                tm.put(i, c+n);
                i--;
            }
        }
        tm.put(2, "☆");
        tm.put(1, "★");
        ArrayList<Integer> al = new ArrayList<Integer>();
        for(int x=0; x<54; x++) {
            al.add(x+1);
        }
        Collections.shuffle(al);
        Collections.shuffle(al);
        Collections.shuffle(al);
        TreeMap<Integer, String> yaoyao= new TreeMap<Integer, String>();
        TreeMap<Integer, String> zhaohuan= new TreeMap<Integer, String>();
        TreeMap<Integer, String> liutong= new TreeMap<Integer, String>();
        TreeMap<Integer, String> dipai= new TreeMap<Integer, String>();
        Set<Integer> key = tm.keySet();
        //System.out.println(tm);
        for(Integer k : key) {
            k = k-1;
            if(k>50) {
                dipai.put(al.get(k),tm.get(al.get(k)));
            }else if(k%3 == 1) {
                yaoyao.put(al.get(k),tm.get(al.get(k)));
            }else if(k%3 == 2) {
                zhaohuan.put(al.get(k),tm.get(al.get(k)));
            }else if(k%3 == 0) {
                liutong.put(al.get(k),tm.get(al.get(k)));
            }
        }
        System.out.println("底牌");
        show(dipai);
        System.out.println("瑤瑤");
        show(yaoyao);
        System.out.println("趙歡");
        show(zhaohuan);
        System.out.println("流通");
        show(liutong);

    }
    public static void show(TreeMap tm) {
        Set<Integer> keySet = tm.keySet();
        for(Integer k : keySet) {
            System.out.print(tm.get(k)+" ");
        }
        System.out.println();
    }
}