[2017.11.18]作业12

A:简答题
1、请把我们讲解过的所有类中的方法在API中找到，并使用自己的话进行描述

Map
public V put(K key, V value)： 将指定的值与此映射中的指定键关联
public void clear()： 从此映射中移除所有映射关系
public V remove(Object key): 如果存在一个键的映射关系，则将其从此映射中移除
public boolean containsKey(Object key)： 如果此映射包含指定键的映射关系，则返回 true
public boolean containsValue(Object value)：如果此映射将一个或多个键映射到指定值，则返回 true
public boolean isEmpty():如果此映射未包含键-值映射关系，则返回 true
public Set

容器内可存储的元素个数不同
Collection每个位置只有一个元素

3、请写出Map集合的遍历方式

第一种：通过Map.keySet遍历key和value
第二种：通过Map.entrySet使用iterator遍历key和value
第三种：通过Map.entrySet遍历key和value
第四种：通过Map.values()遍历所有的value

4、请说明HashMap和Hashtable的区别

Hashtable线程安全,HashMap线程不安全

5、请解释Collection与Collections的区别

Collection是一个集合接口,有很多具体的实现
Collections不能实例化

6、请自己整理份集合知识点文档

B:看程序写结果(写出自己的分析理由)，程序填空，改错，看程序写结果。

class Car {
private String brand;//品牌
private int year; //制造年份
public Car () {}
public Car (String brand, int year) {
this.brand = brand;
this.year = year;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getBrand(){
return brand;
}
public void setYear(int year) {
this.year = year;
}
public int getYear(){
return year;
}
}

一个获取车辆品牌和制造年份的类

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,Jim被覆盖了

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

kevin 
Jim 
没有重写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 
Treemap对键进行自然排序,kevin替代了jim

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 
实现了comparator接口

C:编程题
1、请编写程序，统计一个字符串中每个字符出现的次数

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

public class Homework1 {

public static void main(String[] args) {
    HashMap<Character,Integer > hm = new  HashMap<Character,Integer>();
     Scanner sc = new Scanner(System.in);

     System.out.println("请输入一串字符");
     String next = sc.next();
     char[] ca = next.toCharArray();

     for(char s:ca) {
         Integer put = hm.put(s, 1);
             if(put==null)
                 put=1;
             put++;
          hm.put(s, put);
    }

     Set<Entry<Character,Integer>> entrySet = hm.entrySet();
     for(Entry<Character,Integer> s1:entrySet) {
         System.out.println(s1.getKey()+"--"+s1.getValue());
     }
  }
}

2、请编写程序，存储自定义对象到HashMap集合中，并采用两种方式遍历

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

public class Homework2 {
public static void main(String[] args) {
    HashMap<Student,Integer> hm = new  HashMap<Student,Integer>();

    hm.put(new Student(20,"Lily"), 1);
    hm.put(new Student(17,"Jackson"), 2);
    hm.put(new Student(39,"Jay"), 3);
    hm.put(new Student(32,"Ed"), 4);
    Set<Entry<Student, Integer>> es = hm.entrySet();
    for(Entry<Student, Integer> s:es) {
       System.out.println(s.getKey()+"==="+s.getValue());
    }

    Set<Student> keySet = hm.keySet();

    for(Student s1:keySet) {
        System.out.println(s1+"---"+hm.get(s1));
    }
  }
}

3、请编写程序，存储自定义对象到TreeMap集合中，并采用两种方式遍历

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

public class Homework3 {
public static void main(String[] args) {

    TreeMap<Student, Integer> tm = new TreeMap<>(new Comparator<Student>() {


        @Override
        public int compare(Student s1, Student s2) {
            int num=s1.getAge()-s2.getAge();
            int num1= num == 0 ?

            s1.getName().compareTo(s2.getName()):num;           
            return num1;
        }

    });

    tm.put(new Student(20,"Lily"), 1);
    tm.put(new Student(17,"Jackson"), 2);
    tm.put(new Student(39,"Jay"), 3);
    tm.put(new Student(32,"Ed"), 4);

    Set<Entry<Student, Integer>> es = tm.entrySet();

    for(Entry<Student, Integer> s:es) {
        System.out.println(s.getKey()+"---"+s.getValue());
    }
    System.out.println("-----------------");

    Set<Student> keySet = tm.keySet();

    for(Student s1:keySet) {
        System.out.println(s1+"=="+tm.get(s1));
    }
  }
}

4、请编写程序，完成集合嵌套,并遍历
jc 基础班
张三 20
李四 22
jy 就业班
王五 21
赵六 23
HashMap嵌套HashMap
HashMap嵌套ArrayList

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

public class Homework4 {
    public static void main(String[] args) {
        HashMap<String,HashMap<String, Integer>> bighm = new HashMap<String,HashMap<String, Integer>>();
        HashMap<String, Integer> hm = new HashMap<String,Integer>();
        HashMap<String, Integer> hm1 = new HashMap<String,Integer>();

        hm.put("张三", 20);
        hm.put("李四", 22);
        bighm.put("基础班",hm);

        hm1.put("王五", 23);
        hm1.put("赵六", 24);
        bighm.put("就业班", hm1);

        Set<Entry<String, HashMap<String, Integer>>> bigen = bighm.entrySet();
        for(Entry<String, HashMap<String, Integer>> s:bigen) {
            System.out.println(s.getKey());

            Set<Entry<String,Integer>> entrySet = s.getValue().entrySet();
            for(Entry<String,Integer> s1:entrySet) {

                                   System.out.println("\t"+s1.getKey()+"=="+s1.getValue());
            }
        }
    }

}

5、请编写程序，完成模拟斗地主案例

import java.util.ArrayList;
import java.util.Collections;
import java.util.Set;
import java.util.TreeMap;

public class Homework5 {

    public static void main(String[] args) {

        TreeMap<Integer, String> tm= new TreeMap<Integer, String>();
        String[] color = {"♥","♠","♦","♣"};
        String[] number = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        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> dipai= new TreeMap<Integer, String>();
        TreeMap<Integer, String> Lily= new TreeMap<Integer, String>();
        TreeMap<Integer, String> Jackson= new TreeMap<Integer, String>();
        TreeMap<Integer, String> Jay= new TreeMap<Integer, String>();

        Set<Integer> key = tm.keySet();

        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) {
                Lily.put(al.get(k),tm.get(al.get(k)));
            }else if(k%3 == 2) {
               Jackson.put(al.get(k),tm.get(al.get(k)));
            }else if(k%3 == 0) {
               Jay.put(al.get(k),tm.get(al.get(k)));
            }
        }
        System.out.println("底牌");
        show(dipai);
        System.out.println("Lily");
        show(Lily);
        System.out.println("Jackson");
        show(Jackson);
        System.out.println("Jay");
        show(Jay);

    }

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

1:需求：递归删除带内容的目录 假设删除当前项目下的目录:demo,demo中可以有文件夹自己给出

import java.io.File;

public class Homework1 {

    public static void main(String[] args) {
        File file = new File("F:\\Demo\\a\\b\\c");
        System.out.println(file.mkdirs());
        deleteFile(file);
    }

    public static void deleteFile(File file) {
        File[] fileArray = file.listFiles();
        if (fileArray != null) {
            for (File str : fileArray) {
                if (file.isDirectory()) {
                    deleteFile(file);
                } else {
                    System.out.println(str.getName());
                }
            }
        }
        System.out.println(file.getName() + file.delete());
    }
}

2:需求：请大家把E:\JavaSE目录下所有的java结尾的文件的绝对路径给输出在控制台。

import java.io.File;
import java.io.FilenameFilter;

public class Homework2 {
    public static void main(String[] args) {
        File file = new File("e:\\JavaSE");
        File[] strArray = file.listFiles(new FilenameFilter() {
            public boolean accept(File dir, String name) {
                File file = new File(dir, name);
                boolean flag1 = file.isFile();
                boolean flag2 = name.endsWith(".java");
                return flag1 && flag2;
            }
        });

        if(file.length()!=0){
            for (File array :strArray) {
                System.out.println(array.getName() +                  array.getAbsolutePath());
            }
        }
    }
}

3:下面程序段的执行结果是什么？（D）
　　public class Foo{
　　　public static void main(String[] args){
　　　　try{
　　　　　　return;}
　　　　　　finally{System.out.println(“Finally”);
　　　　　}
　　　}
　　}
A．编译能通过，但运行时会出现一个例外。 B．程序正常运行，并输出 “Finally”。
C．程序正常运行，但不输出任何结果。　D．因为没有catch语句块，所以不能通过编

4:对于已经被定义过可能抛出异常的语句，在编程时（A）。
A．必须使用try／catch语句处理异常，或用throw将其抛出。
B．如果程序错误，必须使用 try／catch语句处理异常。
C．可以置之不理。
D．只能使用try／catch语句处理。

5:哪个关键字可以抛出异常？（B）
A．transient B．throw C．finally D．catch

6:请问所有的异常类皆继承哪一个类？（B ）
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