本文主要是介绍Java -集合 - 结业作业，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

• 编程题homework01
• 编程题homework02
• 编程题homework03
• 简答题homework04
• 代码分析题homework05
• 编程题HomeWork06
• 试写出Vector和ArrayList的比较
• 课后结论

编程题homework01

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

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

   新闻一：早间新闻567891011121314151617

   新闻二：午间新闻567891011121314151617

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

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

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

package com.taotao.homework_.homework01;

import java.util.ArrayList;
import java.util.List;

/**
 * Create By 刘鸿涛
 * 2022/1/10 3:04
 */
public class HomeWork01 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new News("早间新闻567891011121314151617"));
        list.add(new News("午间新闻567891011121314151617"));

        //倒着输出
        for (int i = list.size() - 1; i >= 0; i--) {
            News news = (News)list.get(i);		//向下转型，使用方法
            System.out.println(Cut(news.getTitle()));

        }

        //在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前15个，然后在后边加“...”
    }
    public static String Cut(String str){
        if(str == null){
            return "";
        }
        if(str.length() > 15){
            str = str.substring(0,15) + "...";
        }
        return str;
    }
}
class News{ //封装新闻类
    private String title;   //标题
    private String body;    //内容

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



    public String getTitle() {
        return title;
    }

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

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    @Override
    public String toString(){
        return "此新闻的标题为：" + title;
    }
}

编程题homework02

• 使用ArrayList完成对 对象 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方法

Car car = new Car(“宝马”,400000);

Car car2 = new Car(“宾利”,500000);

package com.taotao.homework_.homework02;

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

/**
 * Create By 刘鸿涛
 * 2022/1/10 3:42
 */
public class HomeWork02 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        Car car = new Car("宝马", 400000);

        list.add(new Car("宝马",400000));
        list.add(new Car("宾利",500000));
        list.add(new Car("奔驰",600000));

//        1. add:添加单个元素
        list.add(new Car("奥迪A8",800000));
        System.out.println(list);

//        2. remove：删除指定元素
        list.remove(0); //删除宝马

//        3. contains：查找元素是否存在
        System.out.println(list.contains(car));

//        4. size：获取元素个数
        System.out.println(list.size());    //3

//        5. isEmpty：判断是否为空
        System.out.println(list.isEmpty()); //false

//        6. clear：清空
//        list.clear();

//        7. addAll：添加多个元素
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Car("大货车",10));
        list.addAll(0,arrayList);
        System.out.println(list);

//        8. containsAll：查找多个元素是否都存在
        System.out.println(list.containsAll(arrayList));        //true

//        9. removeAll：删除多个元素
        list.removeAll(arrayList);
        System.out.println(list);

//        使用增强for遍历
        System.out.println("增强for");
        for (Object o: list){
            System.out.println(o);
        }

//        使用迭代器遍历
        System.out.println("使用迭代器遍历");
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
class Car{
    private String name;
    private int price;

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

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

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

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

编程题homework03

• 按要求完成下列任务

1. 使用HashMap类实例化一个Map类型的对象m，键（String）和值（int）分别用于存储员工的姓名和工资，存入数据如下：

jack - 650；tom-1200元；smith-2900元；

2. 将jack的工资更改为2600元；

3. 将所有员工工资加薪100元；

4. 遍历集合中的所有员工；

5. 遍历集合中所有的工资；

package com.taotao.homework_.homework03;

import java.util.*;

/**
 * Create By 刘鸿涛
 * 2022/1/10 4:02
 */
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);

//        2. 将jack的工资更改为2600元；
        m.put("jack",2600);

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

//        4. 遍历集合中的所有员工；
        //遍历 EntrySet
        Set entrySet = m.entrySet();
        //迭代器
        System.out.println("迭代器遍历员工");
        Iterator iterator = entrySet.iterator();
        while(iterator.hasNext()){
            Map.Entry next = (Map.Entry)iterator.next();
            System.out.println(next.getKey());
        }
        

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

简答题homework04

• 是分析HashSet和TreeSet分别如何实现去重的

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

代码分析题homework05

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

package com.taotao.homework_.homework05;

import java.util.TreeSet;

/**
 * Create By 刘鸿涛
 * 2022/1/10 5:22
 */
public class HomeWork05 {
    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{
//    @Override
//    public int compareTo(Object o){
//        return 0;
//    }
}

编程题HomeWork06

这道题很有意思，稍不注意就掉进陷阱

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

package com.taotao.homework_.homework06;


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

/**
 * Create By 刘鸿涛
 * 2022/1/10 17:23
 */
public class HomeWork06 {
    public static void main(String[] args) {
        HashSet set = new HashSet();
        Person p1 = new Person(1001, "AA");
        Person p2 = new Person(1002, "BB");
        set.add(p1);
        set.add(p2);
        //注意，这里不能封装
        p1.name = "CC";
        set.remove(p1);     //p1已经不是p1
        System.out.println(set);    //两个单一链条
        set.add(new Person(1001,"CC"));
        System.out.println(set);    //2个同一链条，一个单独链条
        set.add(new Person(1001,"AA"));
        System.out.println(set);    //2个单一链条，2个同一链条

    }
}
class Person{
  int id;
   String name;

    public Person(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;
        Person person = (Person) o;
        return id == person.id && Objects.equals(name, person.name);
    }

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

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

试写出Vector和ArrayList的比较

课后结论

• emm，集合还是挺重要的，很多细节还是很懵逼；
• 树化，红黑树
• 扩容机制，扩容源码阅读
• 安全性，效率性
• 集合的选择
• 集合的遍历，迭代器，增强for，for
• LinkedList双向链表，LinkedHashSet双向链表
• HashMap、HashSet实现原理，数组 + 链表 + 红黑树
• Map遍历方式，k - v，键值对，匿名内部类，迭代器，增强for

这篇关于Java -集合 - 结业作业的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！