Java面向对象程序设计（第二版）袁绍欣 第十章课后习题答案

8.如何实现集合对象排序？定义一个复数类并按照复数的实部大小对复数对象进行排序。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class Plural{

    private double x;
    private double y;   
    public double getX() {return x;}
    public void setX(double x) {this.x = x;}
    public double getY() {return y;}
    public void setY(double y) {this.y = y;}
    public Plural() {x = 0; y = 0;}
    public Plural(double x, double y) {this.x = x; this.y = y;}
    public void show() {
        if (y == 0)
            System.out.println(x);
        else if(y<0)
            System.out.println(x + " - " + -y + "i");
	        else 
	        	System.out.println(x + " + " + y + "i");
    }
}


class PluralComparator implements Comparator<Plural> {
	//Comparator接口因为有2个参数，所以要单独写一个类
	//而Comparable接口是一个参数，可以写到上面那个类，直接实现接口，这里没有用
    @Override
    public int compare(Plural o1, Plural o2) {
        return o1.getX() < o2.getX() ? 1 : -1;
    }
}
public class test {

    public static void main(String[] args) {
    	ArrayList<Plural> lst = new ArrayList<>();
        lst.add(new Plural(0, 2.3));
        lst.add(new Plural(-5, 4));
        lst.add(new Plural(-1.2, -3));
        lst.add(new Plural(1, 0));
        Collections.sort(lst, Collections.reverseOrder(new PluralComparator()));
        						//获取要不要交换
        for(Plural p : lst)
            p.show();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
10.对第7章第6题进行适当改造，将异常类型与中文提示存储在一种集合类当中，从而实现相应的功能。

import java.util.HashMap;

class myException{
    @SuppressWarnings("rawtypes")//用哈希图来存储
    public HashMap<Class, String> hm = new HashMap<>();
    public myException() {
        hm.put(NullPointerException.class, "空指针异常");
        hm.put(ArithmeticException.class, "算术异常");
        hm.put(Exception.class, "其他异常");
    }
}
public class test {

    public static void main(String[] args) {
        myException ex=  new myException();
        try {
        	String s = null;
            //System.out.println(1/0);//除零异常
            System.out.println(s.charAt(0));//空指针异常
        }catch (NullPointerException e) {
        	Class<?> c = NullPointerException.class;
            System.out.println(ex.hm.get(c));
        }catch (ArithmeticException e) {
        	Class<?> c = ArithmeticException.class;
            System.out.println(ex.hm.get(c));
        }catch (Exception e) {
        	Class<?> c = Exception.class;
            System.out.println(ex.hm.get(c));
            e.printStackTrace();
            //在命令行打印异常信息在程序中出错的位置及原因
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
编写程序测试各种常用集合类的基本用法（包括向集合添加元素，删除元素，遍历集合元素）
List:
List接口及其实现类是容量可变的列表，可按索引访问集合中的元素。
特点：集合中的元素有序、可重复；
(1)ArrayList 动态数组结构，插入移除数据慢，查询数据快，按索引查找，不是线程安全的。
(2)LinkedList 链表结构，插入移除数据块，只需要替换首尾节点地址就行，查询数据慢，需要按列表节点顺序依次查找。不是线程安全。
(3)Vector 实现可自动增长的数组结构，有序，可重复，线程安全。
(4)Stack继承Vector，有着先进后出的特性,线程安全

Set:
Set的特点：无序，不重复。
(1)HashSet 能够快速定位一个元素。通过散列码来存储元素，要尽量避免散列冲突。存入HashSet中的对象必须实现HashCode方法和equals方法。
(2)TreeSet 如果想要排序，可以使用

Map:
Map是一种把键对象和值对象进行关联的一种容器。
特点：key不允许重复。
(1)HashMap 实现一个键到值映射的哈希表，通过键取得对象，没有顺序，通过get(key)来获取value，允许存储空对象，而且允许键是空(由于键必须是唯一，当然只能有一个)。
(2)HashTable实现一个映像，所有的键必须非空，线程安全。
(3)TreeMap treemap结构是红黑树，是一种自平衡二叉查找树。
红黑树的五点规定：
a每个节点都只能是红色或者黑色
b根节点是黑色
c每个叶节点（叶子节点，空节点）是黑色的。
d从每个叶子到根的所有路径上不能有两个连续的红色节点。
e从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

实际上线程安全的用的不多，这里就不研究了。

ArrayList：

import java.util.ArrayList;
import java.util.Iterator;

public class test {
	public static void main(String[] args) {
		ArrayList<Integer> li = new ArrayList<Integer>();
		for( int i=0;i<10;i++ ) //给数组增加10个Int元素
		li.add(i); 

		//第一种普通for循环
		for (int i = 0; i < li.size(); i++) {
			int n = li.get(i);
			System.out.print(n+" ");
		}
		System.out.println(" ");
		li.add(0,99);//在第一个位置添加
		
		//第二种加强型for
		for (Integer n:li) {
			System.out.print(n+" ");
		}
		System.out.println(" ");
		li.remove(1);//移除第二个元素
		li.remove((Integer)5);//移除遇到的第一个指定个元素
		
		//第三种迭代器
		Iterator<Integer> it = li.iterator();
		while (it.hasNext()) {
			int n = it.next();
			System.out.print(n+" ");
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
LinkedList：

import java.util.Iterator;
import java.util.LinkedList;

public class test {
	public static void main(String[] args) {
		String String = new String("AAA");
		String String2 = new String("BBB");
		String String3 = new String("CCC");

		//创建LinkedList集合，适合进行删除，插入等功能
		LinkedList<String> li = new LinkedList<String>();
		li.add(String);
		li.add(String2);
		li.add(String3);

		//遍历，同样跟ArrayList一样也能用三种
		//第一种普通for循环
		for (int i = 0; i < li.size(); i++) {
			String n = li.get(i);
			System.out.println(n);
		}
		System.out.println(" ");
		li.add(0,String3);//在第一个位置添加
		
		//第二种加强型for
		for (String n:li) {
			System.out.println(n);
		}
		System.out.println(" ");
		li.remove(1);//移除第二个元素
		li.remove("CCC");//移除遇到的第一个指定个元素
		//第三种迭代器
		Iterator<java.lang.String> it = li.iterator();
		//这个地方好像是因为我用的String类型的链表，所以需要指定对应库里的迭代器
		while (it.hasNext()) {
			String n = (java.lang.String) it.next();
			System.out.println(n);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
HashSet：

import java.util.HashSet;
import java.util.Iterator;

public class test {   
    public static void main(String[] args) {   
        HashSet<Character> set = new HashSet<Character>();
        //默认初始容量是 16，加载因子是 0.75，Character是char的包装类
        set.add('a');   
        set.add('b');   
        set.add('c');   
        set.add('d');   
        set.add('e');   
 //我没有存对象，存的元素，所以不允许重复，如果add两遍'a'，不会报错，但第二个a不会被添加
        //迭代遍历：
        Iterator<Character> it = set.iterator();
        while (it.hasNext()) {
          char str = it.next();
          System.out.print(str+" ");
        }
        System.out.println();
        set.remove('c');//去掉指定元素
        
        //for循环遍历：
        for (char str : set) {
              System.out.print(str+" ");
        }
        System.out.println(set.size());//输出大小
    }   
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
TreeSet：

import java.util.Iterator;
import java.util.TreeSet;
 
public class test {
	public static void main(String[] args) {
		TreeSet<Pet>  t = new TreeSet<Pet>();//放入treeset中的类必须实现Comparable接口
		Pet cat=new Pet("cat",3);
		t.add(new Pet("dog",2));
		t.add(new Pet("dog",3));
		t.add((Pet)cat);
		
		Iterator<Pet> it = t.iterator();
		while(it.hasNext()){
			Pet pet = (Pet) it.next();
			System.out.println(pet.getAge()+"  "+ pet.getName());
		}
		System.out.println();
		t.pollLast();//获取并移除最后一个（最高）元素
		System.out.println(t.contains((Pet)cat));//是否包含
		t.remove((Pet)cat);
		for(Pet stu: t) {
	        System.out.println(stu.getAge()+"  "+stu.getName());
	    }
	}
}
 
class Pet implements Comparable<Object>{
	private String name;
	private int age;
	
	public Pet(String name, int age) {
		this.age = age;
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	@Override
	public int compareTo(Object o) {
		if(!(o instanceof Pet))//判断是不是自定义的Pet类
			throw new RuntimeException("不是pet");
		Pet p = (Pet) o;
		if(this.age>p.age)
			return 1;
		else if(this.age == p.age){
			return this.name.compareTo(p.name);//先按age排序然后按照name排序
		}else
		return -1;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
HashMap：

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

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

		HashMap<Integer, String> hashMap = new HashMap<>();
		// 添加元素
		for (int i = 0; i < 5; i++) {
			hashMap.put(i, "随机数" + (int) (Math.random() * 100));
		}
		// 获取元素数量
		System.out.println("size: "+hashMap.size());
		// map的遍历
		for(Map.Entry<Integer, String> entry :hashMap.entrySet() ) {
			System.out.println(entry.getKey()+"  "+entry.getValue());
		}
		// 获取key是3的元素
		System.out.println("key是3: "+hashMap.get(2));
		
		//遍历所有的key
		for(int key:hashMap.keySet()) {
			System.out.print(key+" ");
		}
		//遍历所有的value
		for(String value:hashMap.values()) {
			System.out.print(value+" ");
		}
		System.out.println();
		System.out.println("包含键值为4的吗？ "+hashMap.containsKey(4));
		System.out.println("包含指定值为100的吗？ "+hashMap.containsValue("随机数100"));
		//迭代器遍历
		Iterator<Entry<Integer, String>> it = hashMap.entrySet().iterator();
		while(it.hasNext()) {
			Entry<Integer, String> next = it.next();
			System.out.println(next.getKey()+"  "+next.getValue());
		}
		System.out.println("-----------------");
		hashMap.remove(3);//移除键值为3的元素
		//通过键找值遍历
		for(int k: hashMap.keySet()) {
			System.out.println(k+"  "+hashMap.get(k));
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
TreeMap：

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

public class test {
    public static void main(String[] args) {
        TreeMap<Integer,String> map = new TreeMap<Integer,String>();
        map.put(1,"hello");
        map.put(2,"byebye");
        map.put(3,"mygold");   
        
        Set<Integer> keys = map.keySet();//通过key的迭代器遍历
        Iterator<Integer> iter = keys.iterator();
        while(iter.hasNext())
        {
               int key = iter.next();
               System.out.println(key+" : "+map.get(key));
        }
        System.out.println();
        map.remove(2);//移除key=2的元素
        
        Set<Entry<Integer, String>> value = map.entrySet();
        Iterator<Entry<Integer, String>> iter1 = value.iterator();
        while(iter1.hasNext())
        {
               Entry<Integer, String> key = iter1.next();
               System.out.println(key.getKey()+" : "+key.getValue());
        }
    }
}