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