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();
    }
}