集合的练习

最新推荐文章于 2022-09-28 12:19:09 发布

一个佛系的小码农

最新推荐文章于 2022-09-28 12:19:09 发布

阅读量214

点赞数 1

分类专栏：集合文章标签： java 数据结构算法

本文链接：https://blog.csdn.net/lidong777777/article/details/126092078

版权

集合专栏收录该内容

17 篇文章 1 订阅

订阅专栏

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

练习一：

按要求实现：

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

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

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

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

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 + '\'' +
                '}';
    }
}

练习二：

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

add:添加单个元素
remove:删除指定元素
contains:查找元素是否存在
size:获取元素个数
isEmpty:判断是否为空
clear:清空
addAll:添加多个元素
containsAll:查找多个元素是否都存在
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 +
                '}';
    }
}

练习三：

按要求完成下列任务：

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

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

    }
}

练习四：

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

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

练习五：

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

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

class Person{}

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

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

        /*
            分析源码:
            add 方法，因为 TreeSet() 构造器没有传入Comparator接口的匿名内部类
            所以在底层Comparable<? super K> k = (Comparable<? super K>) 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;
    }
}

练习六：

已知: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

运行结果

[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'}]

练习七：

试写出Vector和ArrayList的比较？

	底层结构	版本	线程安全(同步)效率	扩容倍数
ArrayList	可变数组	jdk1.2	不安全，效率高	如果有参构造1.5倍；如果是无参，第一次扩容10，第二次开始按1.5倍扩容
Vector	可变数组Object[]	jdk1.0	安全，效率不高	如果有参构造2倍，如果是无参，第一次扩容10，第二次开始按2倍扩容