Java -集合 - 结业作业

编程题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元;

  1. 将jack的工资更改为2600元;

  2. 将所有员工工资加薪100元;

  3. 遍历集合中的所有员工;

  4. 遍历集合中所有的工资;

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的比较

底层结构版本线程安全(同步)效率扩容倍数
ArrayList可变数组jdk1.2不安全,效率高如果有参构造器,就按照1.5倍扩容,如果无参,1,第一次扩容10; 2,从第二次开始按照1.5倍扩容
Vector可变数组Object[]jdk1.0安全,效率不高如果是无参,默认是10,满后按照2倍扩容;如果有参数,则每次按照2倍扩容

课后结论

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鬼鬼骑士

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值