Java笔记028-集合章节练习

编程题

按要求实现：

封装一个新闻类，包含标题和内容属性，提供get、set方法，重写toString方法，打印对象时只打印标题

只提供一个带参构造器，实例化对象时，只初始化标题，并且实例化两个对象：

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

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

将新闻对象添加到ArrayList集合中，并且进行倒叙遍历

在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前15个，然后在后边加“...”

在控制台打印遍历出经过处理的新闻标题

package com14.exercise;

import java.util.ArrayList;

/**
 * @author 甲柒
 * @version 1.0
 * @title exercise01
 * @package com14.exercise
 * @time 2023/2/27 21:07
 */
@SuppressWarnings({"all"})
public class exercise01 {
    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()));
        }
    }

    //专门写一个方法，处理显示新闻标题 process处理
    public static String processTitle(String title) {
        if (title == null) {
            return "";
        }
        if (title.length() > 15) {
            return title.substring(0, 15) + "...";//[0, 15)
        } else {
            return title;
        }
    }
}

/**
 * 按要求实现：
 * 1. 封装一个新闻类，包含标题和内容属性，提供get、set方法，重写toString方法，打印对象时只打印标题
 * 2. 只提供一个带参构造器，实例化对象时，只初始化标题，并且实例化两个对象：
 * 新闻一：新冠确诊病例超过千万，数百万印度教信徒赴恒河“圣浴”引民众担忧
 * 新闻二：男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生
 * 3. 将新闻对象添加到ArrayList集合中，并且进行倒叙遍历
 * 4. 在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前15个，然后在后边加“...”
 * 5. 在控制台打印遍历出经过处理的新闻标题
 */
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 + '\'' +
                '}';
    }
}

编程题

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

add：添加单个元素

remove：删除指定元素

contains：查找元素是否存在

size：获取元素个数

isEmpty：判断是否为null

clear：清空

addAll：添加多个元素

containsAll：查找多个元素是否都存在

removeAll：删除多个元素

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

package com14.exercise;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title Exercise02
 * @package com14.exercise
 * @time 2023/2/27 21:28
 */
@SuppressWarnings({"all"})
public class Exercise02 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        Car car = new Car("宝马", 400000);
        Car car1 = new Car("宾利", 5000000);
//        使用ArrayList完成对 对象Car{name, price}的各种操作
//        1. add：添加单个元素
        list.add(car);
        list.add(car1);
        System.out.println(list);
//        2. remove：删除指定元素
        list.remove(car);
        System.out.println(list);
//        3. contains：查找元素是否存在
        System.out.println(list.contains(car));//false
//        4. size：获取元素个数
        System.out.println(list.size());//1
//        5. isEmpty：判断是否为null
        System.out.println(list.isEmpty());//false
//        6. clear：清空
//        list.clear();
        System.out.println(list);//null
//        7. addAll：添加多个元素
        list.addAll(list);
        System.out.println(list);//2个宾利
//        8. containsAll：查找多个元素是否都存在
        System.out.println(list.containsAll(list));//true
//        9. removeAll：删除多个元素
//        list.removeAll(list);//相当于清空
        System.out.println(list);
//        使用增强for和迭代器来遍历所有的car，需要重写Car的toString方法
        for (Object o : list) {
            System.out.println(o);
        }

        //迭代器
        System.out.println("+++++++迭代器++++++");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

/**
 * 使用ArrayList完成对 对象Car{name, price}的各种操作
 * 1. add：添加单个元素
 * 2. remove：删除指定元素
 * 3. contains：查找元素是否存在
 * 4. size：获取元素个数
 * 5. isEmpty：判断是否为null
 * 6. clear：清空
 * 7. addAll：添加多个元素
 * 8. containsAll：查找多个元素是否都存在
 * 9. removeAll：删除多个元素
 * 使用增强for和迭代器来遍历所有的car，需要重写Car的toString方法
 */
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 +
                '}';
    }
}

编程题

按要求完成下列任务

使用HashMap类实例化一个Map类型的对象m，键(String)和值(int)分别用于存储员工的姓名和工资，存入数据如下：jack——650￥；tom——1200￥；smith——2900￥

将jack的工资更改为2600￥

为所有员工工资加薪100￥

遍历集合中所有的员工

遍历集合中所有的工资

package com14.exercise;

import java.util.*;

/**
 * @author 甲柒
 * @version 1.0
 * @title Exercise03
 * @package com14.exercise
 * @time 2023/2/27 21:57
 */
@SuppressWarnings({"all"})
public class Exercise03 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("jack", 650);//int->Integer
        map.put("tom", 1200);//int->Integer
        map.put("smith", 2900);//int->Integer
        System.out.println(map);
        map.replace("jack", 2600);//替换
        System.out.println(map);
//        为所有员工工资加薪100￥
        Set keySet = map.keySet();
        for (Object o : keySet) {
            //更新
            map.put(o, (Integer) map.get(o) + 100);
        }
        System.out.println(map);
        //遍历集合中所有的员工
        //entrySet
        System.out.println("====遍历集合中所有的员工====");
        Set entrySet = map.entrySet();
        //迭代器
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry next = (Map.Entry) iterator.next();
            System.out.println(next.getKey());
        }

        //遍历集合中所有的工资
        System.out.println("=====遍历所有的工资=====");
        Collection values = map.values();
        for (Object o : values) {
            System.out.println("工资=" + o);
        }

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

简答题

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

HashSet的去重机制：hashCode() + equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，如果有数据，就进行equals比较[遍历比较]，如果比较后，不相同，就加入，否则就不加入。

TreeSet的去重机制：如果你传入了一个数据Comparator匿名对象，就使用实现的compare去重，如果方法返回0，就认为是相同的元素/数据，就不添加，如果你没有传入一个Comparator匿名对象，则以你添加的对象实现的Comparable接口的compareTo去重。

package com14.exercise;

import java.util.TreeSet;

/**
 * @author 甲柒
 * @version 1.0
 * @title Exercise04
 * @package com14.exercise
 * @time 2023/2/28 19:11
 */
public class Exercise04 {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add("甲柒");
        treeSet.add("tom");
        treeSet.add("king");
        treeSet.add("甲柒");//加入不了
        System.out.println(treeSet);

    }
}

代码分析题

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

package com14.exercise;

import java.util.TreeSet;

/**
 * @author 甲柒
 * @version 1.0
 * @title Exercise05
 * @package com14.exercise
 * @time 2023/2/28 19:36
 */
@SuppressWarnings({"all"})
public class Exercise05 {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        //分析源码
        //add方法，因为TreeSet()构造器没有传入Comparator接口的匿名内部类
        //所以把底层Comparable<? super K> K = (Comparable<? super K>) key;
        //即 把Person转成Comparable
        treeSet.add(new Person());//ClassCastException
    }
}

class Person {
}
//解决方法
//class Person implements Comparable {
//
//    @Override
//    public int compareTo(Object o) {
//        return 0;
//    }
//}

下面的代码输出什么

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

package com14.exercise;

import java.util.HashSet;
import java.util.Objects;

/**
 * @author 甲柒
 * @version 1.0
 * @title Exercise06
 * @package com14.exercise
 * @time 2023/2/28 19:50
 */
@SuppressWarnings({"all"})
public class Exercise06 {
    public static void main(String[] args) {
        HashSet set = new HashSet();//ok
        Person06 p1 = new Person06(1001, "AA");//ok
        Person06 p2 = new Person06(1002, "BB");//ok
        set.add(p1);//ok
        set.add(p2);//ok
        p1.name = "CC";
        set.remove(p1);
        System.out.println(set);
        set.add(new Person06(1001, "CC"));
        System.out.println(set);
        set.add(new Person06(1001, "AA"));
        System.out.println(set);
    }
}

class Person06 {
    public int id;
    public String name;

    public Person06(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person06 person06 = (Person06) o;
        return id == person06.id && Objects.equals(name, person06.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }

    @Override
    public String toString() {
        return "Person06{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}