集合
分析数组的问题
- 长度开始时必须指定，而且一旦指定,不能更改保存的
- 必须为同一类型的元素
- 使用数组进行增加元素的示意代码-比较麻烦
集合的优点
- 可以动态保存任意多个对象,使用比较方便!
- 提供了一系列方便的操作对象的方法:add、remove,set、get等
- 使用集合添加,删除新元素的示意代码-简洁了
框架体系图
collection类：单列集合
Map类：双列集合
collection类（list+set）
优点
- collection实现子类可以存放多个元素，每个元素可以是Object
- 有些Collection的实现类,可以存放重复的元素,有些不可以
- 有些Collection的实现类，有些是有序的(List)，有些不是有序(Set)
- Collection接口没有直接的实现子类,是通过它的子接口Set 和 List 来实现的
常用方法
- add: 添加单个元素remove:删除指定元素
- contains: 查找元素是否存在size:获取元素个数
- isEmpty: 判断是否为空
- clear: 清空
- addAll: 添加多个元素
- containsAlI: 查找多个元素是否都存在
- removeAll: 删除多个元素
实例演示(以Arraylist为例)
package muster;
import java.util.ArrayList;
import java.util.List;
public class collection01 {
public static void main(String[] args) {
List list = new ArrayList();
// add :添加单个元素
list.add("jack");
list.add(10);//list.add(new Integer(10))
list.add(true);
System.out.println("list=" + list);
// remove:删除指定元素
list.remove(0);//删除第一个元素
list.remove(true);//指定删除某个元素
// contains:查找元素是否存在
System.out.println(list.contains( "jack"));
//size:获取元素个数
System.out.println(list.size());
//isEmpty:判断是否为空
System.out.println(list.isEmpty());//Fclear:清空
//list.clear();
System.out.println("list=" + list);
// addAll:添加多个元素
ArrayList list2 = new ArrayList();
list2.add("红楼梦");
list2.add("三国演义");
list.addAll(list2);
System.out.println("list=" + list);
// containsAll:查找多个元素是否都存在
System.out.println(list.containsAll(list2));//T
// removeAll:删除多个元素
list.add("聊斋");
list.removeAll(list2);
System.out.println("list=" +list);//[聊斋]
}
}
实现接口遍历方式
iterator迭代器
- Iterator对象称为迭代器，主要用于遍历 Collection集合中的元素。
- 所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了lterator接口的对象,即可以返回一个迭代器。
- Iterator仅用于遍历集合,Iterator本身并不存放对象。
执行流程
-
terator iterator = coll.iterator();//得到一个集合的迭代器
//hasNext():判断是否还有下一个元素 -
while(iterator.hasNext()){
next()//作用:1.下移2.将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
**注意：**在调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用，且下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
增强for循环
增强for就是简化版的iterator ,本质一样。只能用于遍历集合或数组。
基本语法
for(元素类型元素名:集合名或数组名){
访问元素
}
练习题
package muster;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class collection_work01 {
public static void main(String[] args) {
// 创建3个 Dog {name, age}对象,放入到ArrayList 中，赋给List 引用
// 用迭代器和增强for循环两种方式来遍历
// 重写Dog的toString方法,输出name和age
List dogs = new ArrayList();
dogs.add(new dog("大壮",10));
dogs.add(new dog("小强",20));
dogs.add(new dog("永恩",1));
// 增强for循环
for (Object o :dogs) {
System.out.println(o);
}
Iterator iterator1 = dogs.iterator();
while (iterator1.hasNext()) {
Object next = iterator1.next();
System.out.println(next);
}
}
}
class dog{
String name;
int age;
public dog(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
List接口
基本介绍
- List 接口是 Collection 接口的子接口
- List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
- List集合中的每个元素都有其对应的顺序索引，即支持索引。
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
常用方法
- int indexOf(Object obj): 返回obj在集合中首次出现的位置
- int lastlndexOf(Object obj): 返回obj在当前集合中末次出现的位置
- Object remove(int index): 移除指定index位置的元素，并返回此元素
- Object set(int index, Object ele): 设置指定index位置的元素为ele,相当于是替换.
- List subList(int fromlndex, int tolndex): 返回从fromlndex到tolndex位置的子集合
实例演示
package muster;
import java.util.ArrayList;
import java.util.List;
public class list_method {
public static void main(String[] args) {
List list = new ArrayList();
list.add("张三丰");
list.add("贾宝玉");
// void add(int index,0bject ele):在index位置插入ele元素
// 在index =1的位置插入一个对象
list.add(1,"韩顺平");
System.out.println("list=" + list);
// boolean addAll(int index，Collection eles):
// 从index位置开始将eles中的所有元素添加进来
List list2 = new ArrayList();
list2.add("jack");
list2.add("tom");
list.addAll(1,list2);
System.out.println("list="+list);
//Object get(int index):获取指定index位置的元素//说过
// int indexOf(Object obj):返回obj在集合中首次出现的位置
System.out.println(list.indexOf( "tom"));//2
System.out.println("list=" + list);
// Object set(int index，Object ele):
// 设置指定index位置的元素为ele，相当于是替换。下标位置一定要存在，否则会报错
list.set(1,"玛丽");
System.out.println("list=" + list);
// List subList(int fromIndex，int toIndex):
// 返回从fromIndex到toIndex位置的子集合//注意返回的子集合
// fromIndex <= subList < toIndex
List returnlist = list.subList(0,2);
System.out.println("returnlist=" + returnlist);
}
}
练习题
package muster;
import java.util.*;
public class list_work01 {
public static void main(String[] args) {
// 添加10个以上的元素（比如String "hello" )，
// 在2号位插入一个元素"lalal"，获 得第5个元素，删除第6个元素，
// 修改第7个元素，
// 在使用迭代器遍历集合，
// 要求:使用List的实现类ArrayList完成
List list=new ArrayList();
for (int i = 0; i < 10; i++) {
list.add("hello"+i);
}
System.out.println(list);
list.add(1,"lalal");
System.out.println(list);
System.out.println(list.get(4));
list.remove(5);
System.out.println(list);
list.set(6,"hhhh");
System.out.println(list);
//三种遍历方式
//第一种：iterator遍历
Iterator iterator1 =list.iterator();
while (iterator1.hasNext()) {
Object next = iterator1.next();
System.out.println(next);
}
//第二种：增强for遍历
for (Object o :list) {
System.out.println(o);
}
//第三种：普通for循环
for (int i = 0; i <list.size() ; i++) {
System.out.println(list.get(i));
}
// 使用List的实现类添加三本图书，并遍历，打印如下效果
// 名称:xx 价格:xx 作者:xx
// 名称:xX 价格:xx 作者:xx
// 名称:xX 价格:xXx 作者:xx
// 要求
// 1)按价格排序,从低到高(使用冒泡法)
// 2)要求使用ArrayList、LinkedList 和Vector三种集合实现
List list2 = new ArrayList();
// List list2 = new Vector();
// List list2 = new LinkedList();
list2.add(new book("红楼梦",10));
list2.add(new book("西游记",30));
list2.add(new book("三国演义",20));
List relist=sortlist(list2);
System.out.println(relist);
}
public static List sortlist(List list){
for (int i = 0; i < list.size()-1; i++) {
for (int j = 0; j <list.size()-i-1 ; j++) {
book book1=(book)list.get(j);
book book2=(book)list.get(j+1);
if(book1.price>book2.price){
list.set(j,book2);
list.set(j+1,book1);
}
}
}
return list;
}
}
class book{
String name;
double price;
public book(String name, double price) {
this.name = name;
this.price = price;
}
@Override
public String toString() {
return "book{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
Arraylist
基本介绍
- ArrayList 可以加入null,并且多个
- ArrayList是由数组来实现数据存储的
- ArrayList基本等同于Vector，除了ArrayList是线程不安全(执行效率高)在多线程情况下，不建议使用
底层操作机制
- ArrayList中维护了一个Object类型的数组elementData.transient Object[] elementData;
- 当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第1次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍。
- 如果使用的是指定大小的构造器，则初始elementData容量为指定大小,如果需要扩容,则直接扩容elementData为1.5倍。
源码执行分析图
vector
- Vector底层也是一个对象数组，protected Objectll elementData;
- Vector是线程同步的,即线程安全, Vector类的操作方法带有synchronized
- 在开发中,需要线程同步安全时,考虑使用Vector
底层操纵流程
Vector和ArrayList的比较
Linkedlist
- LinkedList实现了双向链表和双端队列特点)
- 可以添加任意元素(元素可以重复)，包括null)
- 线程不安全,没有实现同步
底层操作机制
- LinkedList底层维护了一个双向链表、
- LinkedList中维护了两个属性first和last分别指向首节点和尾节点
- 每个节点(Node对象),里面又维护了prev、next、item三个属性，其中通过prev指向前一个,通过next指向后一个节点。最终实现双向链表.
- 所以LinkedList的元素的添加和删除,不是通过数组完成的，相对来说效率较高。
源码解读
remove()源码
ArrayList和LinkedList的比较
- 如果我们改查的操作多，选择ArrayList
- 如果我们增删的操作多，选择LinkedList
- 一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选择ArrayList
- 在一个项目中，根据业务灵活选择,也可能这样，一个模块使用的是ArrayList,另外一个模块是LinkedList.
set接口
基本介绍
- 无序（添加和取出的顺序不一致)，没有索引，虽然是无序的，但是存放以后位置是固定的
- 不允许重复元素，所以最多包含一个null
常用方法
和List接口一样,Set接口也是Collection的子接口，因此，常用方法和Collection接口一样.
遍历方式
- 可以使用迭代器
- 增强for
- 不能使用索引的方式来获取.
HashSet
介绍
-
HashSet实现了Set接中
-
HashSet实际上是HashMap
-
可以存放null值,但是只能有一个null
-
HashSet不保证元素是有序的,取决于hash后,再确定索引的结果
-
.不能有重复元素/对象.在前面Set 接口使用已经讲过
-
在执行add方法后，会返回一个boolean值。如果添加成功,返回true,否则返回false
-
可以通过remove指定删除哪个对象
底层机制
- HashSet底层是HashMap
- 添加一个元素时，先得到hash值-会转成->索引值
- 找到存储数据表table，看这个索引位置是否已经存放的有元素如果没有，直接加入。如果有，调用equals比较，如果相同，就放弃添加,如果不相同，则添加到最后
- 在Java8中，如果一条链表的元素个数超过 TREEIFY_THRESHOLD(默认是8)，并且table的大小>=MIN TREEIFY CAPACITY(默认64),就会进行树化(红黑树)
源码分析
代码练习
package generic;
import java.util.HashSet;
import java.util.Objects;
public class work01 {
public static void main(String[] args) {
// 定义一个Employee类，该类包含:private成员属性name,age要求:
// 1.创建3个Employee放入 HashSet中
// 2.当name和age的值相同时，认为是相同员工,不能添加到HashSet集合中
HashSet hashSet = new HashSet();
boolean p1 = hashSet.add(new Employee("小明", 18,new MyDate(1,1,1)));
System.out.println(p1);
boolean p2 = hashSet.add(new Employee("小明", 18,new MyDate(1,1,1)));
System.out.println(p2);
boolean p3 = hashSet.add(new Employee("小明", 18,new MyDate(1,1,1)));
System.out.println(p3);
// 定义一个Employee类，该类包含: private成员属性name,sal,
// birthday(MyDate类型)，其中 birthday 为 MyDate类型
// (属性包括:year, month, day)，要求:
// 1.创建3个Employee 放入 HashSet中
// 2.当name和birthday的值相同时，认为是相同员工,不能添加到HashSet集合中
}
}
class MyDate{
private int year;
private int month;
private int day;
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() { return year; }
public void setYear(int year) { this.year = year; }
public int getMonth() { return month; }
public void setMonth(int month) { this.month = month; }
public int getDay() { return day; }
public void setDay(int day) { this.day = day; }
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof MyDate)) return false;
MyDate myDate = (MyDate) o;
return getYear() == myDate.getYear() &&
getMonth() == myDate.getMonth() &&
getDay() == myDate.getDay();
}
@Override
public int hashCode() {
return Objects.hash(getYear(), getMonth(), getDay());
}
}
class Employee{
private String name;
private int age;
private MyDate birthday;
public Employee(String name, int age,MyDate myDate) {
this.name = name;
this.age = age;
this.birthday=myDate;
}
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public MyDate getBirthday() { return birthday; }
public void setBirthday(MyDate birthday) { this.birthday = birthday; }
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Employee)) return false;
Employee employee = (Employee) o;
return Objects.equals(getName(), employee.getName()) &&
Objects.equals(birthday, employee.birthday);
}
@Override
public int hashCode() {
return Objects.hash(getName(), birthday);
}
}
LinkedHashSet
说明
- LinkedHashSet是 HashSet的子类
- LinkedHashSet底层是一个LinkedHashMap，底层维护了一个数组+双向链表
- LinkedHashSet根据元素的hashCode值来决定元素的存储位置,同时使用链表维护元素的次序(图)，这使得元素看起来是以插入顺序保存的。
- LinkedHashSet 不允许添重复元素
底层机制示意图
源码分析
代码练习
package generic;
import java.util.LinkedHashSet;
import java.util.Objects;
public class work02 {
public static void main(String[] args) {
// Car 类(属性:name,price),如果name和price一样,。
// 则认为是相同元素，就不能添加。
LinkedHashSet linkedHashSet = new LinkedHashSet();
boolean c1 = linkedHashSet.add(new Car("小明", 100));
System.out.println(c1);
boolean c2 = linkedHashSet.add(new Car("小明", 100));
System.out.println(c2);
}
}
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 boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Car)) return false;
Car car = (Car) o;
return Double.compare(car.getPrice(), getPrice()) == 0 &&
Objects.equals(getName(), car.getName());
}
@Override
public int hashCode() {
return Objects.hash(getName(), getPrice());
}
}
Map接口
介绍
- Map用于保存具有映射关系的数据:Key-Value
- Map 中的key和 value可以是任何引用类型的数据，会封装到HashMap$Node对象中
- Map中的key 不允许重复,原因和HashSet一样,前面分析过源码.
- Map 中的value可以重复
- Map 的key可以为null, value 也可以为null，注意key为null, 只能有一个,value为null ,可以多个.
- 常用String类作为Map的key
- key 和 value之间存在单向一对一关系，即通过指定的key 总能找到对应的value
- Map存放数据的key-value示意图,一对k-v是放在一个Node中的，有因为Node实现了Entry 接口,有些书上也说一对k-v就是一个Entry
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jVcTCJg7-1666786931549)(E:\自学路线\java基础\笔记\image-20221024200152619.png)]
体系继承图
常用方法
- put: 添加
- remove: 根据键删除映射关系get:根据键获取值
- size: 获取元素个数
- isEmpty: 判断个数是否为0
- clear: 清除键值对
- containsKey: 查找键是否存在
遍历方法
package Map;
import java.util.*;
public class Map01 {
public static void main(String[] args) {
Map map = new HashMap();
map.put("邓超", "孙俪");
map.put("王宝强", "马蓉");
map.put("宋喆", "马蓉");
map.put("刘令博", null);
map.put(null, "刘亦菲");
map.put("鹿晗", "关晓彤");
//第一组:先取出所有的Key ,通过Key取出对应的Value
Set keyset = map.keySet();
//(1)增强for
System.out.println("-----第一种方式---—---");
for (Object key : keyset) {
System.out.println(key + "_" + map.get(key));
}
//(2)迭代器
System.out.println("----第二种方式--—----");
Iterator iterator = keyset.iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
System.out.println(key + "-" + map.get(key));
}
//第二组:把所有的values取出
Collection values = map.values();
//这里可以使用所有的Collections使用的遍历方法//(1）增强for
System.out.println("---取出所有的value增强for---- ");
for (Object value : values) {
System.out.println(value);
}
//(2)迭代器
System.out.println("---取出所有的value 迭代器----");
Iterator iterator2 = values.iterator();
while (iterator2.hasNext()) {
Object value = iterator2.next();
System.out.println(value);
}
//第三组:通过EntrySet 来获取k-v
Set entrySet = map.entrySet();// EntrySet<Map.Entry<K, V>>
// (1)增强for
System.out.println("----使用EntrySet的 for增强(第3种)---- ");
for (Object entry : entrySet) {
//将entry 转成 Map. Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey() + "-" + m.getValue());
}
//(2〕迭代器
Iterator iterator3 = entrySet.iterator();
while (iterator3.hasNext()) {
Object next = iterator3.next();
Map.Entry m = (Map.Entry)next;
System.out.println(m.getKey() + "-" + m.getValue());
}
}
}
代码练习
package Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class work01 {
public static void main(String[] args) {
// 使用HashMap添加3个员工对象,要求键:员工id
// 值:员工对象
// 并遍历显示工资>18000的员工(遍历方式最少两种)
// 员工类:姓名、工资、员工id
HashMap hashMap = new HashMap();
hashMap.put(1, new Employee("小张", 18, 1));
hashMap.put(2, new Employee("小明", 19, 2));
hashMap.put(3, new Employee("小兰", 20, 3));
Set set = hashMap.keySet();
for (Object o :set) {
System.out.println(o+" "+hashMap.get(o));
}
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next+ "-" + hashMap.get(next));
}
}
}
class Employee{
private String name;
private int age;
private int id;
public Employee(String name, int age,int id) {
this.name = name;
this.age = age;
this.id=id;
}
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; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
}
HashMap
小结
- Map接口的常用实现类:HashMap、Hashtable和Properties.
- HashMap是 Map接口使用频率最高的实现类。
- HashMap 是以 key-val对的方式来存储数据
- key不能重复,但是是值可以重复允许使用null键建和null值。
- 如果添加相同的key,则会覆盖原来的key-val ,等同于修改.(key不会替换,val会替换)
- 与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的.
- HashMap没有实现同步，因此是线程不安全的
底层存放示意图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-akT7XD66-1666786931549)(E:\自学路线\java基础\笔记\image-20221025110955082.png)]
扩容机制
- HashMap底层维护了Node类型的数组table,默认为null
- 当创建对象时，将加载因子(loadfactor)初始化为0.75.
- 当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素如果没有元素直接添加。如果该索引处有元素,继续判断该元素的key是否和准备加入的key相等，如果相等，则直接替换val;如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。
- 第1次添加，则需要扩容table容量为16，临界值(threshold)为12.
- 以后再扩容，则需要扩容table容量为原来的2倍，临界值为原来的2倍,即24,依次类推.
- 在Java8中,如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8)，并且table的大小>= MIN_TREEIFY_CAPACITY(默认64),.就会进行树化(红黑树)
源码阅读
HashTable
基本介绍
- 存放的元素是键值对:即K-V
- hashtable的领和值都不能为null
- hashTable使用方法基本上和HashMap一样
- hashTable是线程安全的，hashMap是线程不安全的
- 底层有数组 Hashtable$Entry[]
- 初始化大小为11临界值threshold 8 = 11 * 0.75
- 扩容:按照自己的扩容机制来进行即可。
Hashtable和 HashMap对比
Properties
介绍
- Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据。
- 他的使用特点和Hashtable类似
- Properties还可以用于 从 xxx.properties文件中,加载数据到Properties类对象,并进行读取和修改
基本使用
TreeSet
-
当我们使用无参构造器，创建TreeSet时，仍然是无序的
-
如果希望添加的元素按一定的规则进行排序，使用TreeSet提供的一个构造器，可以传入一个比较器(匿名内部类)并指定排序规则
TreeMap
Collections工具类
Collections是一个操作 Set、List 和 Map等集合的工具类，Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作
开发中如何选择集合实现类
- 先判断存储的类型(一组对象或一组键值对)
- 一组对象:Collection接口
- 允许重复:List
- 增删多:LinkedList [底层维护了一个双向链表]
- 改查多: ArrayList [底层维护 Object类型的可变数组]
- 不允许重复:Set
- 无序:HashSet[底层是HashMap，维护了一个哈希表即(数组+链表+红黑树)J]
- 排序:TreeSet
- 插入和取出顺序一致: LinkedHashSet，维护数组+双向链表
- 允许重复:List
- —组键值对:Map
- 键无序: HashMap [底层是:哈希表 jdk7:数组+链表,jdk8:数组+链表+红黑树]
- 键排序:TreeMap
- 健插入和取出顺序一致:LinkedHashMap
- 读取文件Properties
章节测试题
package Map;
import java.util.*;
public class Collection02 {
public static void main(String[] args) {
// (1)封装一个新闻类，包含标题和内容属性，提供get、set方法，
// 重写toString方法，打印对象时只打印标题;
// (2)只提供一个带参数的构造器，实例化对象时，只初始化标题;
// 并且实例化两个对象:
// 新闻一:
// 新冠确诊病例超千万，数百万印度教信徒赴恒河“圣浴”引民众担忧
// 新闻二:
// 男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生
// (3)将新闻对象添加到ArrayList集合中，并且进行倒序遍历;
// (4)在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前15个
// 然后在后边加“.…."
// (5)在控制台打印遍历出经过处理的新闻标题;
ArrayList list = new ArrayList();
list.add(new news("新冠确诊病例超千万，数百万印度教信徒赴恒河“圣浴”引民众担忧"));
list.add(new news("男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生"));
for (int i = list.size()-1; i >=0 ; i--) {
String newtitle=titlenew(list.get(i).toString());
((news)(list.get(i))).setTitle(newtitle);
System.out.println(list.get(i));
}
// 第二题：
// 1)使用HashMap类实例化一个Map类型的对象m，
// 键(String)和值(int)分别用于存储员工的姓名和工资，
// 存入数据如下: jack—650元; tom—1200元; smith—2900元;
// 2)将jack的工资更改为2600元
// 3)为所有员工工资加薪100元;
// 4)遍历集合中所有的员工
// 5)遍历集合中所有的工资
HashMap m = new HashMap();
m.put("jack",650);
m.put("tom",1200);
m.put("smith",2900);
m.replace("jack",2600);
// System.out.println((m.get("jack")).getClass());
Set keys = m.keySet();
for (Object o :keys) {
m.replace(o,(int)(m.get(o))+100);
System.out.println(m.get(o));
}
// 试分析HashSet和TreeSet分别如何实现去重的
// (1) HashSet的去重机制: hashCode() + equals(),
// 底层先通过存入对象,进行运算得到一个hash值，
// 通过hash值得到对应的索引，如果发现table索引所在的位置,
// 没有数据，就直接存放,如果有数据，就进行equals比较[遍历比较]，
// 如果比较后，不相同,就加入，否则就不加入.
// (2) TreeSet的去重机制:如果你传入了一个Comparator匿名对象，
// 就使用实现的compare去重，如果方法返回0,就认为是相同的元素/数据,
// 就不添加，如果你没有传入一个Comparator匿名对象,
// 则以你添加的对象实现的Compareable接口的compareTo去重.
// 以下代码输出什么
// 输出：
// [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
// [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]
// [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]
HashSet set = new HashSet();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");
set.add(p1);
set.add(p2);
p1.setName ("CC");
set.remove(p1);
System.out.println(set);
set.add(new Person(1001,"CC"));
System.out.println(set);
set.add(new Person(1001,"AA"));
System.out.println(set);
}
public static String titlenew(String title){
if (title.length()>15){
title=title.substring(1,15);
title+="......";
}else{
title+="......";
}
return title;
}
}
class news{
private String info;
private String title;
public news(String title) { this.title = title; }
public String getInfo() { return info; }
public void setInfo(String info) { this.info = info; }
public String getTitle() { return title; }
public void setTitle(String title) { this.title = title; }
@Override
public String toString() {
return title;
}
}
class Person{
private int id;
private 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 String toString() {
return "Person{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person person = (Person) o;
return getId() == person.getId() &&
Objects.equals(getName(), person.getName());
}
@Override
public int hashCode() {
return Objects.hash(getId(), getName());
}
}
试写出Vector和ArrayList的比较?
扫一扫
2394
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
