day27--Java集合10

Java集合10

21.集合家庭作业

21.1Homework01

按要求实现：

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

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

新闻二：男子突然想起两个月前掉的鱼还在网兜里，捞起一看赶紧放生
将新闻对象添加到ArrayList集合中，并进行倒序遍历；
在遍历集合的过程中，对新闻标题进行处理，超过十五个字的只保留前十五个，然后在后边加 ”…“；
在控制台打印遍历输出经过处理的新闻标题。

Homework01:

 package practice.collections_homework;
 
import java.util.ArrayList;
import java.util.Collections;
 
@SuppressWarnings("all")
public class HomeWork01 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
 
        arrayList.add(new News("新冠确诊病例超千万，数百万印度信徒赴恒河“圣浴”引民众担忧"));
        arrayList.add(new News("男子突然想起两个月前掉的鱼还在网兜里，捞起一看赶紧放生"));
 
        Collections.reverse(arrayList);//倒序遍历法一
        
        //int size = arrayList.size();
        //for (int i = size-1; i >=0 ; i--) {//倒序遍历法二
           //System.out.println(arrayList.get(i));
        //}
 
        for (Object o : arrayList) {
            System.out.println(o);
        }
 
    }
}
 
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() {//打印对象时只打印标题
        if(title==null){
            return "";
        }
        if (title.length() > 15) {
            // substring:返回一个字符串，该字符串是此字符串的子字符串。
            // 子串开始于指定beginIndex并延伸到字符索引endIndex- 1
            String sub = title.substring(0, 15);
            return sub + "...";
        } else {
            return  title ;
        }
    }
}

21.2Homework02

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

add：添加单个元素
remove：删除指定元素
contains：查找元素是否存在
size：获取元素个数
isEmpty：判断是否为空
clear：清空
addAll：添加多个元素
containsAll：查找多个元素是否都存在
removeAll：删除多个元素

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

Homework02

 package practice.collections_homework;
 
import java.util.ArrayList;
import java.util.Iterator;
 
@SuppressWarnings("all")
public class HomeWork02 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
 
        Car car1 = new Car("宝马", 400_000);
        Car car2 = new Car("宾利", 5_000_000);
        Car car3 = new Car("法拉利", 8_000_000);
 
        //add
        arrayList.add(car1);
        arrayList.add(car2);
        arrayList.add(car3);
 
        //增强for
        for (Object o:arrayList) {
            System.out.println(o);
        }
 
        //remove
        arrayList.remove(car3);
        System.out.println(arrayList);//[Car{name='宝马', price=400000}, Car{name='宾利', price=5000000}]
 
        //contains
        System.out.println(arrayList.contains(car1));//true
 
        //size
        System.out.println(arrayList.size());//2
 
        //isEmpty
        System.out.println(arrayList.isEmpty());//false
 
        //addAll(Collection c)
        ArrayList arrayList2 =new ArrayList();
        arrayList2.addAll(arrayList);
        Iterator iterator2 = arrayList2.iterator();//迭代器
        while (iterator2.hasNext()) {
            Object next =  iterator2.next();
            System.out.println(next);
        }
 
        //clear
        arrayList.clear();
        System.out.println(arrayList);//[]
 
        //containsAlll(Collection c)
        System.out.println(arrayList.containsAll(arrayList2));//false
 
        //removeAlll(Collection c)
        ArrayList arrayList3 = new ArrayList();
        arrayList3.add(car1);
        arrayList2.removeAll(arrayList3);
        System.out.println(arrayList2);//[Car{name='宾利', price=5000000}]
    }
}
 
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(int price) {
        this.price = price;
    }
 
    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

21.3Homework03

按要求完成下列任务：

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

HomeWork03

 package practice.collections_homework;
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
@SuppressWarnings("all")
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);
 
        m.put("jack", 2600);//将jack的工资更改为2600
        System.out.println(m);
 
        //为所有员工工资加薪100
        //使用keySet
        Set keySet = m.keySet();
        for (Object key : keySet) {
            m.put(key, (Integer) m.get(key) + 100);
        }
        System.out.println(m);
 
        //遍历key
        for (Object key : keySet) {
            System.out.println(key);
        }
 
        //遍历value
        for (Object key : keySet) {
            System.out.println(m.get(key));
        }
 
        //使用EntrySet遍历
        Set entrySet = m.entrySet();
        //增强for
        for (Object entry:entrySet) {
            System.out.println(((Map.Entry)entry).getKey());
            System.out.println(((Map.Entry)entry).getValue());
        }
        
 
        //迭代器
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry next = (Map.Entry) iterator.next();
            System.out.println(next.getKey());
            System.out.println(next.getValue());
        }
 
    }
}

21.4Homework04

简答题：试分析HashSet和TreeSet分别如何实现去重的

1）HashSet的去重机制：

hashCode()+equals()

底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的数组下标索引，如果发现table索引所在的位置没有数据，就直接存放；如果有数据，就进行equals比较[遍历]（默认判断标准：属性是否相同），如果比较中发现对象不相同，就将新对象加入；如果发现对象相同，则新值覆盖旧值

2）TreeSet的去重机制：

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

这就是为什么自定义类未实现Comparable接口会报错：类型转换异常

21.5Homework05

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

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

答案：会报错。

add方法，因为TreeSet（）构造器没有传入Comparator接口的匿名内部类，所以在底层Comparable k = (Comparable) key;中会把Person转成Comparable类型，但是此时Person没有实现Comparable接口，因此会报错：ClassCastException

解决办法是自定义类实现接口Comparable：

 package practice.collections_homework;
 
import java.util.TreeSet;
 
public class HomeWork05 {
    public static void main(String[] args) {
        TreeSet treeSet =new TreeSet();
        treeSet.add(new Person());
    }
}
 
class Person implements Comparable{
 
    public int  compareTo(Object o){
        //方法体xxxx
        return 0;
    }
}

实现接口Comparable后不再报错：

21.6Homework06

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

 package practice.collections_homework;
 
import java.util.HashSet;
import java.util.Objects;
 
public class HomeWork06 {
    public static void main(String[] args) {
        HashSet set =new HashSet();//ok
        Person p1 =new Person(1001,"AA");//ok
        Person p2 =new Person(1002,"BB");//ok
        set.add(p1);//ok
        set.add(p2);//ok
        p1.name ="CC";//ok
        set.remove(p1);//删除失败，因为p1的值变了，不能匹配到
        System.out.println(set);//还是两个：[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
 
        set.add(new Person(1001,"CC"));//重写了hashCode和equals，添加成功
        System.out.println(set);//3个
 
        set.add(new Person(1001,"AA"));
        System.out.println(set);//4个，p1的name已经改变了，比较认为是不同的对象，可以添加进去
    }
}
 
class Person {
    public int id;
    public String name;
 
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        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 + '\'' +
                '}';
    }
}

首先分析 set.remove(p1);//删除失败:

即，改变了P1的name值，但是当初存放p1的索引位置是由原来的1001和“AA”经过HashCode方法计算出来的，因此删除时用1001和“CC”经过hashCode计算出来的索引下标找不到该节点，因此删除失败

添加set.add(new Person(1001,"CC"));时，由于重写了hashCode和equals，因此计算下来的索引位置与之前的都不一样，添加成功
set.add(new Person(1001,"AA"));添加成功，原因：

当初存放p1的索引位置是由原来的1001和“AA”经过HashCode方法计算出来的，存放过后又改变了p1 的name值，因此当新添加一个对象{1001，“AA”}时，我们先使用hashCode（）方法计算索引，发现与p1的下标索引一样，接着使用equals()方法，发现name不一样（因为此时p1的name已经改为“CC”），所以认为新对象是和p1不同的对象，因此可以添加进去

21.7Homework07

试写出Vector和ArrayList的比较？

	底层结构	版本	线程安全（同步）效率	扩容倍数
ArrayList	可变数组	jdk1.2出现	不安全，效率高	如果是无参构造，第一次扩容10，第二次开始按照1.5倍扩容；如果使用有参构造器，就按照1.5倍扩容；
Vector	可变数组 Object[]	jdk1.0出现	安全，效率不高	如果是无参，默认10，满后按照 2倍扩容；如果是指定大小创建Vector，则每次按照2倍扩容

相关阅读:
优雅的MVC思想
 redis为什么使用跳跃表而不是树
 实用新型专利的特点是什么
 如何提取图片中的文字?
Android样式和主题
 水果店圈子：一家水果店要准备什么，开个水果店前期准备什么
 伦敦金周末可以交易吗，黄金休市时间是那些？
关于视频封装格式和视频编码格式的简介
 vue3插槽的使用
 【算法与数据结构】17、LeetCode电话号码的字母组合
原文地址：https://www.cnblogs.com/liyuelian/p/16629099.html

	package practice.collections_homework;

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

	@SuppressWarnings("all")
	public class HomeWork01 {
	public static void main(String[] args) {
	ArrayList arrayList = new ArrayList();

	arrayList.add(new News("新冠确诊病例超千万，数百万印度信徒赴恒河“圣浴”引民众担忧"));
	arrayList.add(new News("男子突然想起两个月前掉的鱼还在网兜里，捞起一看赶紧放生"));

	Collections.reverse(arrayList);//倒序遍历法一

	//int size = arrayList.size();
	//for (int i = size-1; i >=0 ; i--) {//倒序遍历法二
	//System.out.println(arrayList.get(i));
	//}

	for (Object o : arrayList) {
	System.out.println(o);
	}

	}
	}

	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() {//打印对象时只打印标题
	if(title==null){
	return "";
	}
	if (title.length() > 15) {
	// substring:返回一个字符串，该字符串是此字符串的子字符串。
	// 子串开始于指定beginIndex并延伸到字符索引endIndex- 1
	String sub = title.substring(0, 15);
	return sub + "...";
	} else {
	return title ;
	}
	}
	}

	package practice.collections_homework;

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

	@SuppressWarnings("all")
	public class HomeWork02 {
	public static void main(String[] args) {
	ArrayList arrayList = new ArrayList();

	Car car1 = new Car("宝马", 400_000);
	Car car2 = new Car("宾利", 5_000_000);
	Car car3 = new Car("法拉利", 8_000_000);

	//add
	arrayList.add(car1);
	arrayList.add(car2);
	arrayList.add(car3);

	//增强for
	for (Object o:arrayList) {
	System.out.println(o);
	}

	//remove
	arrayList.remove(car3);
	System.out.println(arrayList);//[Car{name='宝马', price=400000}, Car{name='宾利', price=5000000}]

	//contains
	System.out.println(arrayList.contains(car1));//true

	//size
	System.out.println(arrayList.size());//2

	//isEmpty
	System.out.println(arrayList.isEmpty());//false

	//addAll(Collection c)
	ArrayList arrayList2 =new ArrayList();
	arrayList2.addAll(arrayList);
	Iterator iterator2 = arrayList2.iterator();//迭代器
	while (iterator2.hasNext()) {
	Object next = iterator2.next();
	System.out.println(next);
	}

	//clear
	arrayList.clear();
	System.out.println(arrayList);//[]

	//containsAlll(Collection c)
	System.out.println(arrayList.containsAll(arrayList2));//false

	//removeAlll(Collection c)
	ArrayList arrayList3 = new ArrayList();
	arrayList3.add(car1);
	arrayList2.removeAll(arrayList3);
	System.out.println(arrayList2);//[Car{name='宾利', price=5000000}]
	}
	}

	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(int price) {
	this.price = price;
	}

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

	package practice.collections_homework;

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

	@SuppressWarnings("all")
	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);

	m.put("jack", 2600);//将jack的工资更改为2600
	System.out.println(m);

	//为所有员工工资加薪100
	//使用keySet
	Set keySet = m.keySet();
	for (Object key : keySet) {
	m.put(key, (Integer) m.get(key) + 100);
	}
	System.out.println(m);

	//遍历key
	for (Object key : keySet) {
	System.out.println(key);
	}

	//遍历value
	for (Object key : keySet) {
	System.out.println(m.get(key));
	}

	//使用EntrySet遍历
	Set entrySet = m.entrySet();
	//增强for
	for (Object entry:entrySet) {
	System.out.println(((Map.Entry)entry).getKey());
	System.out.println(((Map.Entry)entry).getValue());
	}


	//迭代器
	Iterator iterator = entrySet.iterator();
	while (iterator.hasNext()) {
	Map.Entry next = (Map.Entry) iterator.next();
	System.out.println(next.getKey());
	System.out.println(next.getValue());
	}

	}
	}

	package practice.collections_homework;

	import java.util.TreeSet;

	public class HomeWork05 {
	public static void main(String[] args) {
	TreeSet treeSet =new TreeSet();
	treeSet.add(new Person());
	}
	}

	class Person implements Comparable{

	public int compareTo(Object o){
	//方法体xxxx
	return 0;
	}
	}

	package practice.collections_homework;

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

	public class HomeWork06 {
	public static void main(String[] args) {
	HashSet set =new HashSet();//ok
	Person p1 =new Person(1001,"AA");//ok
	Person p2 =new Person(1002,"BB");//ok
	set.add(p1);//ok
	set.add(p2);//ok
	p1.name ="CC";//ok
	set.remove(p1);//删除失败，因为p1的值变了，不能匹配到
	System.out.println(set);//还是两个：[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]

	set.add(new Person(1001,"CC"));//重写了hashCode和equals，添加成功
	System.out.println(set);//3个

	set.add(new Person(1001,"AA"));
	System.out.println(set);//4个，p1的name已经改变了，比较认为是不同的对象，可以添加进去
	}
	}

	class Person {
	public int id;
	public String name;

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

	public int getId() {
	return id;
	}

	public void setId(int id) {
	this.id = id;
	}

	public String getName() {
	return name;
	}

	public void setName(String name) {
	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 + '\'' +
	'}';
	}
	}