Java基础 Collections练习

练习一

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

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

/**
 * @author 小黄debug  on 2022/3/14
 * @version 1.0
 */
public class Homework01 {
    /*
    1、封装一个新闻类，包含标题和内容属性，提供get、set方法，重写toString方法，打印对象时只打印标题；
    2、只提供一个带参数的构造器，实例化对象时，只初始化标题；并且实例化两个对象
    新闻一：新冠确认病例超千万，数百万印度教信徒赴恒河“圣浴”引民众担忧
    新闻二：男突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生
    3、将新闻对象添加到ArrayList集合中，并且进行倒序遍历；
    4、在遍历集合过程中对新闻标题进行处理，超过15个字的只保留前15个，然后在后边加"..."
    5、在控制台打印遍历出经过处理的新闻标题
     */
    public static void main(String[] args) {
        List list = new ArrayList<News>();
        list.add(new News("新冠确认病例超千万，数百万印度教信徒赴恒河“圣浴”引民众担忧"));
        list.add(new News("男突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生"));

        Collections.reverse(list);
        for (int i = 0 ; i < list.size(); i ++) {
            News news = (News)list.get(i);
            if(news.getTitle().length() > 15){
                System.out.println(news.getTitle().substring(0,15)+"...");
            }else{
                System.out.println(news.getTitle());
            }
        }
    }
}

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

import java.sql.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * @author 小黄debug  on 2022/3/14
 * @version 1.0
 */
public class 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方法
     */
    public static void main(String[] args) {
        List list = new ArrayList();
        //add：添加单个元素
        Car bmw = new Car("宝马",320000);
        Car ferrari=new Car("法拉力",520000);
        list.add(bmw);
        list.add(new Car("奔驰",330000));
        list.add(new Car("奥迪",420000));
        list.add(ferrari);
        list.add(new Car("兰博",620000));
        System.out.println(list);
        //remove:删除指定元素
        list.remove(bmw);
        System.out.println(list);
        //contains:查找元素是否存在
        System.out.println(list.contains(ferrari));
        //size:获取元素个数
        System.out.println(list.size());
        //isEmpty:判断是否为空
        System.out.println(list.isEmpty());
        //clear:清空
        list.clear();
        System.out.println(list);

        List dest = new ArrayList();
        dest.add(new Car("奥拓",8000));
        dest.add(new Car("长安",88000));
        dest.add(new Car("奇瑞",98000));
        dest.add(new Car("吉利",108000));
        //addAll:添加多个元素
        list.addAll(dest);
        System.out.println(list);
        //containsAll:查找多个元素是否都存在
        System.out.println(list.containsAll(dest));
        //删除多个元素
        list.removeAll(dest);
        System.out.println(list);
        //增强for
        list.addAll(dest);
        for(Object ocat: list){
            Car car = (Car)ocat;
            System.out.println(car.toString());
        }
        //迭代器
        Iterator iterator = list.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;
    }
    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

练习三

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

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @author 小黄debug  on 2022/3/14
 * @version 1.0
 */
public class Homework03 {
    /*
    1、使用HashMap类实例化一个Map类型的对象m,键（String)和值（int)分别用于存储员工的姓名和蒋，
    存入数据如下：jack - 650元; tom - 1200； smith - 2900;
    2、将jack的工资更改为2600元;
    3、为所有员工工资加薪100元;
    4、遍历集合中所有的员工
    5、遍历集合中所有的工资
     */
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("jack", 650);
        map.put("tom", 1200);
        map.put("smith", 2900);
        System.out.println(map);
        //将jack的工资更改为2600元;
        map.put("jack", 2600);
        System.out.println(map);
        //为所有员工工资加薪100元;
        Set set = map.keySet();
        for (Object key : set) {
            Integer price = (Integer) map.get(key);
            map.put(key, price + 100);
            //遍历集合中所有的员工
            System.out.println(key);
        }
        //遍历集合中所有的工资
        Iterator iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
//            Object next =  iterator.next();
//            System.out.println(map.get(next));
            Map.Entry entry = (Map.Entry) iterator.next();
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }
    }
}

练习四

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

//    HashSet的底层是HashMap
//    HashMap的底层是数组+链表+红黑树
//    hashMap通过key进行hashCode计算，然后右移16位得到hash值
//    hash通过取余数组大小得到所在数组位置
//    通过hash值所在位置的链表遍历是否有key值在不为空的情况下相等，如hash和key两者都相等，则证明是同一个
    （1）HashSet的去重机制：hashCode()+equals(),底层先通过存入对象，进行运算得到一个hash值，
    通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，
    如果有数据，就进行equals比较【遍历】比较，如果比较后不相同就加入，不则就不加入
    TreeSet的底层是TreeMap
    TreeMap根据Comparator匿名对象，就使用实现的compare去重，如果方法返回0，就认为相同的元素/数据，
    就不添加，如果你没有传入一个Comparator匿名对象，则以你添加的对象实现的Compareable接口的compareTo去重

练习五

代码分析题
下面代码运行会不会抛出异常，并从源码层面说明原因。【考察 读源码+接口编程+动态绑定】
TreeSet treeSet = new TreeSet();
treeSet.add(new Person());
//分析
add方法，因为TreeSet()构造器没有传入Comparator接口的匿名内部类
所以在底层 Comparable<? super K> k = (Comparable<? super K>) key;
即把Person转成Comparable类型//ClassCastException
//解决办法
在Person去实现下Comparable接口的compareTo方法

import java.util.TreeSet;

/**
 * @author 小黄debug  on 2022/3/14
 * @version 1.0
 */
public class Homework05 {
    /*
    代码分析题
    下面代码运行会不会抛出异常，并从源码层面说明原因。【考察 读源码+接口编程+动态绑定】
    TreeSet treeSet = new TreeSet();
    treeSet.add(new Person());
    //分析
    add方法，因为TreeSet()构造器没有传入Comparator接口的匿名内部类
    所以在底层 Comparable<? super K> k = (Comparable<? super K>) key;
    即把Person转成Comparable类型//ClassCastException
    //解决办法
    在Person去实现下Comparable接口的compareTo方法
     */
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(new Person());
    }
}
class Person implements Comparable{

    @Override
    public int compareTo(Object o) {
        return 0;
    }
}

练习六

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

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";
System.out.println(set);
set.remove(p1); //因为Person重写了hashCode方法，name改变后，hash也改变了，但p1对象仍然还有原来的位置上，所以删除失败
System.out.println(set);
System.out.println("--------------------------------");
set.add(new Person(1001,"CC")); //同理可得hash位置上为空，所以加进去了
System.out.println(set);

set.add(new Person(1001,"AA"));//由于与1001，CC的位置相同，会进行equals比较，但是value值name不同,所以也加进来了
System.out.println(set);

/**
 * @author 小黄debug  on 2022/3/14
 * @version 1.0
 */
public class Homework06 {
    /*
    已知：Person类按照id和name重写了hashCode和equals方法，问下面代码输出什么

     */
    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";
        System.out.println(set);
        set.remove(p1); //因为Person重写了hashCode方法，name改变后，hash也改变了，但p1对象仍然还有原来的位置上，所以删除失败
        System.out.println(set);
        System.out.println("--------------------------------");
        set.add(new Person(1001,"CC")); //同理可得hash位置上为空，所以加进去了
        System.out.println(set);

        set.add(new Person(1001,"AA"));//由于与1001，CC的位置相同，会进行equals比较，但是value值name不同,所以也加进来了
        System.out.println(set);

    }
}

class Person{
    Integer id;
    String name;

    public Person(Integer 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 Objects.equals(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	可变数组	jdk1.0	安全，效率不高	如果无参，默认10，满后，按2倍扩容 ，如果是指定大小创建Vector,则每次按照2倍扩容