集合的练习

之前我们博客所讲的集合到这里就告一段落，我们来做一些练习结束集合。

练习一：

按要求实现：

1. 封装一个新闻类，包含标题和内容的属性，提供get、set方法，重写toString方法，打印对象时只打印标题；
2. 只提供一个带参数的构造器，实例化对象时，只初始化标题，并且实例化两个对象；

新闻一：新冠确诊病例超千万，数百万印度教信徒赴恒河"圣浴"引民众担忧

新闻二：男子突然想起2个月前钓的鱼还在网兜李，捞起一看赶紧放生

3. 将新闻对象添加到ArrayList集合中，并且进行倒序遍历；
4. 在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前15个，然后在后边加“…”;
5. 在控制台打印遍历出经过处理的新闻标题。

public class Homework01 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new News("新冠确诊病例超千万，数百万印度教信徒赴恒河\"圣浴\"引民众担忧"));
        arrayList.add(new News("男子突然想起2个月前钓的鱼还在网兜李，捞起一看赶紧放生"));
        int size = arrayList.size();
        for (int i = size - 1;i>=0;i--){
            //System.out.println(arrayList.get(i));
            News news = (News)arrayList.get(i);
            System.out.println(processTitle(news.getTitle()));
        }
    }
    //专门写一个方法，处理实现新闻标题
    public static String processTitle(String title){
        if(title == null){
            return "";
        }
        if(title.length()>15){
            return title.substring(0,15)+"...";
        }else{
            return title;
        }
    }
}

class News{
    private String title;
    private String content;

    public News(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "News{" +
                "title='" + title + '\'' +
                '}';
    }
}
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
54
55
56

练习二：

使用ArraryList 完成对 对象Car{name,price}的各种操作

1. add:添加单个元素
2. remove:删除指定元素
3. contains:查找元素是否存在
4. size:获取元素个数
5. isEmpty:判断是否为空
6. clear:清空
7. addAll:添加多个元素
8. containsAll:查找多个元素是否都存在
9. removeAll:删除多个元素

使用增强for和迭代器来遍历所有的car，需要重写Car的toString方法

public class Homework02 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        Car car = new Car("宝马",400000);
        Car car1 = new Car("宾利",5000000);

        arrayList.add(car);
        arrayList.add(car1);
        System.out.println(arrayList);

        arrayList.remove(car);
        System.out.println(arrayList);

        System.out.println(arrayList.contains(car1));

        System.out.println(arrayList.size());

        System.out.println(arrayList.isEmpty());

        //arrayList.clear();

        arrayList.addAll(arrayList);
        System.out.println(arrayList);

        System.out.println(arrayList.containsAll(arrayList));

        //arrayList.removeAll(arrayList);

        System.out.println("=====增强for======");
        for (Object o : arrayList) {
            System.out.println(o);
        }
        System.out.println("======迭代器=====");
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }

    }
}
class Car{
    private String name;
    private double price;

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

练习三：

按要求完成下列任务：

1. 使用HashMap类实例化一个Map类型的对象m，键(String)和值(int)分别用于存储员工的姓名和工资，存入数据如下：jack—650元；tom—1200元，smith—2900元；
2. 将jack的工资更改为2600元；
3. 为所有员工工资加薪100元；
4. 遍历集合中所有的员工；
5. 遍历集合中所有的工资；

public class Homework03 {
    public static void main(String[] args) {
        Map m = new HashMap();
        m.put("jack",650);
        m.put("tom",1200);
        m.put("smith",2900);

        System.out.println(m);
        m.put("jack",2600);//替换，更新
        System.out.println(m);

        //为所有员工工资加薪100元；
        Set keySet = m.keySet();
        for (Object key : keySet) {
            //更新
            m.put(key,(Integer)m.get(key)+100);
        }
        System.out.println(m);

        System.out.println("=====遍历=======");
        //遍历    Entry
        Set entrySet = m.entrySet();
        //迭代器
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry entry = (Map.Entry) iterator.next();
            System.out.println(entry.getKey()+"-"+entry.getValue());
        }

        System.out.println("======遍历所有的工资=====");
        Collection values = m.values();
        for (Object value : values) {
            System.out.println("工资="+value);
        }

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

练习四：

试分析HashSet和TreeSet分别如何实现去重的？

1. HashSet的去重机制：hashCode()+equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放；如果有数据，就进行equals比较[遍历比较]，如果比较后，不相同就加入，否则就不加入。
2. TreeSet的去重机制：如果你传入了一个Comparator匿名对象，就使用实现的compare去重，如果方法返回0，就认为是相同的元素/数据，就不添加，如果你没有传入一个Comparator匿名对象，则以你添加的对象实现的Compareable接口的compareTo去重。

练习五：

下面代码运行会不会抛出异常，并从源码层面说明原因。[考察 读源码+接口编程+动态绑定]

TreeSet treeSet = new TreeSet();
treeSet.add(new Person());

class Person{}
1
2
3
4

分析源码:
add 方法，因为 TreeSet() 构造器没有传入Comparator接口的匿名内部类
所以在底层Comparable<? super K> k = (Comparable<? super K>) key;(向上转型)
即把 Person转成 Comparable类型，没有实现Comparable所以会抛出异常
1
2
3
4

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

        /*
            分析源码:
            add 方法，因为 TreeSet() 构造器没有传入Comparator接口的匿名内部类
            所以在底层Comparable k = (Comparable) key;(向上转型)
            即把 Person转成 Comparable类型，没有实现Comparable所以会抛出异常
         */
        TreeSet treeSet = new TreeSet();
        treeSet.add(new Person());
        System.out.println(treeSet);
        //解决方法：Person类实现Comparable接口，重写compareTo方法
    }
}
class Person implements Comparable{
    @Override
    public int compareTo(Object o) {
        return 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

练习六：

已知:Person类按照id和name重写了hashCode和equals方法，问下面代码输出什么？

HashSet set = new HashSet();
Person1 p1 = new Person1(1001,"AA");
Person1 p2 = new Person1(1002,"BB");
set.add(p1);
set.add(p2);
p1.name = "CC";
set.remove(p1);
System.out.println(set);//2
set.add(new Person1(1001,"CC"));
System.out.println(set);//3
set.add(new Person1(1001,"AA"));
System.out.println(set);//4
1
2
3
4
5
6
7
8
9
10
11
12

• 运行结果

[Person1{id=1002, name='BB'}, Person1{id=1001, name='CC'}]
[Person1{id=1002, name='BB'}, Person1{id=1001, name='CC'}, Person1{id=1001, name='CC'}]
[Person1{id=1002, name='BB'}, Person1{id=1001, name='CC'}, Person1{id=1001, name='CC'}, Person1{id=1001, name='AA'}]
1
2
3

练习七：

试写出Vector和ArrayList的比较？