Homework01
按要求实现:
(1)封装一个新闻类，包含标题和内容属性，提供get、set方法,重写toString方法，打印对象时只打印标题;
(2)只提供一个带参数的构造器，实例化对象时，只初始化标题;并且实例化两个对象:
新闻一:新冠确诊病例超千万，数百万印度教信徒赴恒河“圣浴”引民众担忧
新闻二:男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生
(3)将新闻对象添加到ArrayList集合中，并且进行倒序遍历;
(4)在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前15个，然后在后边加“…."
(5)在控制台打印遍历出经过处理的新闻标题;
自己写的
package com.yt.collectionhomework;
import java.util.ArrayList;
import java.util.Iterator;
public class Homework01 {
public static void main(String[] args) {
News news1 = new News("新冠确诊病例超千万，数百万印度教信徒赴恒河“圣浴”引民众担忧");
News news2 = new News("男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生");
ArrayList arrayList = new ArrayList();
arrayList.add(news1);
arrayList.add(news2);
System.out.println("arrayList=" + arrayList);
//实现倒序遍历
System.out.print("倒序遍历");
for (int i = arrayList.size()-1; i >= 0; i--) {
System.out.print(arrayList.get(i));
}
System.out.println();
System.out.println();
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
//向下转型为News对象，方便获得title的字符串
String str = ((News)next).getTitle();
if (str.length() > 15){
System.out.println(str.substring(0, 15) + "...");
}
}
}
}
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 "\nNews{" +
"title='" + title + '\'' +
'}';
}
}
对比老师写的
重写写一个方法来处理标题的内容，这种重新写方法的思想要建立
import java.util.ArrayList;
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()));
}
}
//专门写一个方法，处理现实新闻标题 process处理
public static String processTitle(String title) {
if(title == null) {
return "";
}
if(title.length() > 15) {
return title.substring(0, 15) + "..."; //[0,15)
} else {
return title;
}
}
}
/**
* 按要求实现：
* (1) 封装一个新闻类，包含标题和内容属性，提供get、set方法，重写toString方法，打印对象时只打印标题；
* (2) 只提供一个带参数的构造器，实例化对象时，只初始化标题；并且实例化两个对象：
* 新闻一：新冠确诊病例超千万，数百万印度教信徒赴恒河“圣浴”引民众担忧
* 新闻二：男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生
* (3) 将新闻对象添加到ArrayList集合中，并且进行倒序遍历；
* (4) 在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前15个，然后在后边加“…”
* (5) 在控制台打印遍历出经过处理的新闻标题；
*/
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 + '\'' +
'}';
}
}
Homework02
使用ArrayList完成对对象Car {name, price}的各种操作
l.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(“宾利".5000000);
package com.yt.collectionhomework;
import java.util.ArrayList;
import java.util.Iterator;
public class Homework02 {
public static void main(String[] args) {
Car car = new Car("宝马", 400000);
Car car1 = new Car("宾利", 5000000);
ArrayList list = new ArrayList();
//添加单个元素
list.add(car);
list.add(car1);
System.out.println("list=" + list);
//删除指定元素
list.remove(1);
System.out.println("list=" + list);
//查找元素是否存在,判断的是对象
System.out.println(list.contains(car));
//获取元素个数
System.out.println(list.size());
//判断是否为空
System.out.println(list.isEmpty());
//添加多个元素
ArrayList list1 = new ArrayList();
list1.add("hello1");
list1.add("你好啊");
list.addAll(list1);
System.out.println("list=" + list);
//查找多个元素是否存在
System.out.println(list.containsAll(list1));
//删除多个元素
//使用增强for来遍历
for (Object obj : list){
System.out.println(obj);
}
//使用迭代器遍历
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;
}
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 +
'}';
}
}
Homework03
按要求完成下列任务
1)使用HashMap类实例化一个Map类型的对象m，键(String）和值(int);分别用于存储员工的姓名和工资，存入数据如下:
jack—650元; tom—1200元;smith——2900元;
2)将jack的工资更改为2600元
3)为所有员工工资加薪100元;
4)遍历集合中所有的员工;
package com.yt.collectionhomework;
import java.util.*;
public class Homework03 {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("jack",new Emp("jack",650));
map.put("tom",new Emp("tom",1200));
map.put("smith",new Emp("smith",2900));
System.out.println("map=" + map);
//将jack的工资更改为2600元
map.replace("jack",new Emp("jack",2600));
System.out.println(map);
//为所有员工工资加薪100元;
//使用循环来完成
Set keySet0 = map.keySet();
for (Object obj : keySet0){
Emp e = (Emp)map.get(obj);
double newSalay = e.getSalary()+100;
System.out.println(obj + "-" +newSalay);
}
//遍历集合中所有的员工
Set keySet = map.keySet();
for (Object obj : keySet){
System.out.println(obj + "-" + map.get(obj));
}
Collection values = map.values();
for (Object obj : values){
System.out.println(obj);
}
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry next = (Map.Entry)iterator.next();
System.out.println(next);
}
}
}
class Emp{
private String name;
private double salary;
public Emp(String name, double salary) {
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Emp{" +
"name='" + name + '\'' +
", salary=" + salary +
"}\n";
}
}
老师写的
为所有员工工资加薪100元;这个地方思考不一样
import java.util.*;
public class Homework03 {
public static void main(String[] args) {
Map m = new HashMap();
m.put("jack", 650);//int->Integer
m.put("tom", 1200);//int->Integer
m.put("smith", 2900);//int->Integer
System.out.println(m);
m.put("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);
System.out.println("=============遍历=============");
//遍历 EntrySet
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);
}
}
}
/**
* 按要求完成下列任务
* 1）使用HashMap类实例化一个Map类型的对象m，键（String）和值（int）分别用于存储员工的姓名和工资，
* 存入数据如下： jack—650元；tom—1200元；smith——2900元；
* 2）将jack的工资更改为2600元
* 3）为所有员工工资加薪100元；
* 4）遍历集合中所有的员工
* 5）遍历集合中所有的工资
*/
Homework04
试分析HashSet和TreeSet分别如何实现去重的
(1) HashSet的去重机制:hashCode()+ equals() ,底层先通过存入对象,进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放;如果有数据，就进行equals比较[遍历比较]，如果比较后，不相同,就加入，否则就不加入.
(2) TreeSet的去重机制:如果你传入了一个Comparator匿名对象，就使用实现的compare去重，如果方法返回0,就认为是相同的元素/数据，就不添加，如果你没有传入一个Comparator匿名对象,则以你添加的对象实现的Compareable接口的compareTo去重.
Homework05
下面代码运行会不会抛出异常，并从源码层面说明原因.[考察读源码+接口编程+动态绑定]
TreeSet treeSet = new TreeSet);
treeSet.add(new Person0);
import java.util.TreeSet;
public class Homework05 {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
//分析源码
//add 方法，因为 TreeSet() 构造器没有传入Comparator接口的匿名内部类
//所以在底层 Comparable<? super K> k = (Comparable<? super K>) key;
//即 把 Perosn转成 Comparable类型,但是创建的Person类并没有实现Comparable接口
//补充：String 实现了Comparable接口，因此在传入相同字符串的时候不能重复
treeSet.add(new Person());//ClassCastException.
treeSet.add(new Person());//ClassCastException.
treeSet.add(new Person());//ClassCastException.
treeSet.add(new Person());//ClassCastException.
treeSet.add(new Person());//ClassCastException.
System.out.println(treeSet);
}
}
class Person {
}
如何解决上述问题呢？
import java.util.TreeSet;
public class Homework05 {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
//分析源码
//add 方法，因为 TreeSet() 构造器没有传入Comparator接口的匿名内部类
//所以在底层 Comparable<? super K> k = (Comparable<? super K>) key;
//即 把 Perosn转成 Comparable类型,但是创建的Person类并没有实现Comparable接口
//补充：String 实现了Comparable接口，因此在传入相同字符串的时候不能重复
treeSet.add(new Person());
treeSet.add(new Person());
treeSet.add(new Person());
treeSet.add(new Person());
treeSet.add(new Person());
System.out.println(treeSet);//返回1
//因为compareTo方法返回的值都一样，没有做比较处理
}
}
class Person implements Comparable{
@Override
public int compareTo(Object o) {
return 0;
}
}
Homework06
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";
set.remove(p1);//删除的时候也会hash
System.out.println(set);//2，p1.name = "CC"之后p1的hash变化，无法删除
set.add(new Person(1001,"CC"));
System.out.println(set);//3
set.add(new Person(1001,"AA"));
System.out.println(set);//4
}
}
class Person {
public String name;
public int id;
public Person(int id, String name) {
this.name = name;
this.id = id;
}
@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(name, id);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", id=" + id +
'}';
}
}
试写出Vector和ArrayList的比较?
