java作业

A:简答题
1、请把我们讲解过的所有类中的方法在API中找到，并使用自己的话进行描述
Map
public V put(K key, V value)：添加键和值 
public void clear()： 删除该Map中的键和值
public V remove(Object key): 如果存在这个键，则删除对应的值
public boolean containsKey(Object key)： 判断是否包含 这个键
public boolean containsValue(Object value)：判断是否包含这个值
 public boolean isEmpty(): 判断该Map是否为空
public Set<Map.Entry<K,V>> entrySet()：利用entrySet进行遍历
public V get(Object key): 获取键
public Set<K> keySet() : 获取值
public Collection<V> values():Collection集合
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) 据元素的自然顺序，返回给定 collection 的最大元素。
public static void reverse(List<?> list) 反转指定列表中元素的顺序
public static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。
public static <T> void sort(List<T> list) : 根据自然排序进行升序排序
public static <T> void sort(List<T> list, Comparator<T> c)根据比较器进行产生的顺序进行排序
 
2、请说明Map接口和Collection接口的区别 
（1）Collection集合只能存储单列元素，Map可以存储双列集合。
（2）Collection集合添加元素用的add();Map集合使用的是put();
 (3)Collection集合遍历元素直接用增强for循环，而Map集合用的是keySet或者entrySet.
(4)Map里面有HashMap和treeMap以及LinkedHashMap
 HashMap特点无序唯一，唯一由哈希表实现；
 treeMap特点唯一且可以排序，数据结构是红黑树结构。
   LinkedHashMap特点有序且唯一，底层数据结构是链表和哈希表，由链表实现有序，哈希表提供唯一性。


3、请写出Map集合的遍历方式 keySet()和entrySet(）
4、请说明HashMap和Hashtable的区别
HashMap可以接收null值和null键，Hashtable不可以
HashMap线程不安全效率高
Hashtable 线程安全效率低


5、请解释Collection与Collections的区别
Collection是集合接口，Collections是包装类
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);
}
}
}
Jim
Kevin
 没有重写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:编程题
请编写程序，统计一个字符串中每个字符出现的次数
package wbb;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;


public class test12 {

public static void main(String[] args) {

HashMap<Character, Integer> map = new HashMap<Character, Integer>();

Scanner sc = new Scanner(System.in);
System.out.println("请随便输入一串字母");
String str = sc.nextLine();

char[] chs = str.toCharArray();

for (char key : chs) {

Integer value = map.get(key);
if (value == null) {
map.put(key, 1);


} else {
value++;
map.put(key, value);
}


}



Set<Character> keySet = map.keySet();
StringBuilder sb = new StringBuilder();
for (Character ch : keySet) {
sb.append(ch).append("(").append(map.get(ch)).append(")");


}
System.out.println(sb.toString());


}
}


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


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


public class test6 {



public static void main(String[] args) {
HashMap<String, String> hm = new HashMap<String,String>();
hm.put("王昭君", "李白");
hm.put("紫霞仙子", "至尊宝");
Set<String> keySet = hm.keySet();
for(String key :keySet){

System.out.println(key+"...."+hm.get(key));
System.out.println("........");
Set<Entry<String, String>> entrySet = hm.entrySet();
for( Entry<String, String> key2: entrySet){
System.out.println(key2);
}
}
}
}


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


import java.util.Set;
import java.util.TreeMap;


class test2 {
public static void main(String[] args) {
TreeMap<Integer, String> tm = new TreeMap<Integer,String>();
tm.put(1, "梨");
tm.put(3,"苹果");
tm.put(2, "香蕉");
Set<Integer> keySet = tm.keySet();
for(Integer key: keySet){
System.out.println(key+"..."+tm.get(key));



}


}


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


public class test13 {


public static void main(String[] args) {




HashMap<String, Integer> jcMap = new HashMap<String, Integer>();
jcMap.put("张三", 20);
jcMap.put("李四", 22);
HashMap<String, Integer> jyMap = new HashMap<String, Integer>();
jyMap.put("王五", 21);
jyMap.put("赵六", 23);



HashMap<String, HashMap<String, Integer>> bigMap = new HashMap<String, HashMap<String, Integer>>();


bigMap.put("基础班", jcMap);
bigMap.put("就业班", jyMap);



Set<String> keySet = bigMap.keySet();
for (String bigkey : keySet) {
System.out.println(bigkey);

HashMap<String, Integer> hashMap = bigMap.get(bigkey);
Set<String> minSet = hashMap.keySet();


for (String minkey : minSet) {
System.out.println("\t" + minkey + "---" + hashMap.get(minkey));
}


System.out.println();


}
HashMap嵌套ArrayList
5、请编写程序，完成模拟斗地主案例
package wbb;




import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;


public class test12 {


public static void main(String[] args) {

HashMap<Integer, String> pokerMap = new HashMap<Integer, String>();

String[] colors = { "?", "?", "?", "◆" };

String[] nums = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10",
"J", "Q", "K" };

ArrayList<Integer> indexs = new ArrayList<Integer>();
int index = 0;
for (String num : nums) {


for (String color : colors) {


pokerMap.put(index, num + color);
indexs.add(index);
index++;


}


}



indexs.add(index);
pokerMap.put(index, "大王");
index++;
indexs.add(index);
pokerMap.put(index, "小王");


Collections.shuffle(indexs);
Collections.shuffle(indexs);
Collections.shuffle(indexs);



TreeSet<Integer> zs = new TreeSet<Integer>();
TreeSet<Integer> zs1 = new TreeSet<Integer>();
TreeSet<Integer> sw = new TreeSet<Integer>();
TreeSet<Integer> dp= new TreeSet<Integer>();


for (int i = 0; i < indexs.size(); i++) {
if (i >= pokerMap.size() - 3) {

dp.add(indexs.get(i));
}
if (i % 3 == 0) {
zs.add(indexs.get(i));


} else if (i % 3 == 1) {
zs1.add(indexs.get(i));


} else if (i % 3 == 2) {
sw.add(indexs.get(i));
}


}


// 看牌


lookPai("张三", zs, pokerMap);
lookPai("赵四",zs1, pokerMap);
lookPai("孙五", sw, pokerMap);
lookPai("底牌", dp, pokerMap);


}


private static void lookPai(String name, TreeSet<Integer> list,
HashMap<Integer, String> pokerMap) {
System.out.println(name);

for (Integer in : list) {


String pai = pokerMap.get(in);
System.out.print(pai + " ");


}
System.out.println();


}


}