1.集合框架体系
集合主要分为两组:单列集合(collection),双列集合(map)
单列集合(collection接口)
双列集合(map接口)
2.Collection接口
(1).常见的方法
*/
public class arraylist_ {
public static void main(String[] args) {
//常用方法,用arrayList类演示
ArrayList<String> fruits = new ArrayList<>();
//1.add 添加单个元素
fruits.add("苹果");
fruits.add("香蕉");
fruits.add(1,"橘子");//在指定位置插入,香蕉后面
//2.remove删除指定元素,可以是内容,可以是下标,并返回该元素
fruits.remove("苹果");
fruits.remove(0);
//3.contains查找元素是否存在
fruits.contains("梨");
//4) size:获取元素个数
System.out.println(fruits.size());
//5)isEmpty:判断是否为空
System.out.println(fruits.isEmpty());
//6)clear:清空
fruits.clear();
//7)addAll:添加多个元素
ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
fruits.addAll(list);
fruits.addAll(2,list);//在3后面加入list里的所有元素
//8)containsAll:查找多个元素是否都存在
System.out.println(fruits.containsAll(list));//true
//9)removeAll: 删除多个元素
fruits.removeAll(list);
//10.get(index)获取指定位置的元素
System.out.println(fruits.get(1));
//11.indexOf()返回元素在集合首次出现的位置
System.out.println(fruits.indexOf("1"));
//12.LastindexOf()返回元素在集合最后次出现的位置
//13.set(index,object)将指定位置的元素替换为obj,可以是单个元素,可以是集合
System.out.println(fruits.set(1,"a"));
//14.subList(formIndex,toIndex)返回从开始索引到结束索引的子集合[)
}
}
(2).collection接口遍历元素的方法
1).使用iterator(迭代器)
- Iterator对象称为迭代器,主要用于遍历 Collection 集合中的元素。
- 所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器。
- Iterator 仅用于遍历集合,lterator 本身并不存放对象。
- 在调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用,且下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
- 如果希望再次遍历,需要重置迭代器iterator=list.iterator()
public class b {
public static void main(String[] args) {
ArrayList<String> fruits = new ArrayList<>();
// 添加元素
fruits.add("苹果");
fruits.add("香蕉");
fruits.add("橙子");
// 使用迭代器遍历集合,while(itertor)快捷键itit
//查看所有快捷键ctrl+g
Iterator<String> iterator = fruits.iterator();
while (iterator.hasNext()) {
String fruit = iterator.next();
System.out.println(fruit);
}
//第二次遍历,重置迭代器
iterator=fruits.iterator();
while (iterator.hasNext()) {
String frult2 = iterator.next();
System.out.println(frult2);
}
}
}
2).增强for
- 增强for是简化版的iterator
- 只能用于遍历集合和数组
public class c {
public static void main(String[] args) {
ArrayList<String> fruits = new ArrayList<>();
// 添加元素
fruits.add("苹果");
fruits.add("香蕉");
fruits.add("橙子");
// 使用增强的 for-each 循环遍历集合
//快捷键I
for (String fruit : fruits) {
System.out.println(fruit);
}
}
}
3).普通for循环
public class f {
public static void main(String[] args) {
ArrayList<Integer> fruits = new ArrayList<>();
// 添加元素
fruits.add(1);
fruits.add(2);
fruits.add(3);
// 使用增强的 for-each 循环遍历集合
//快捷键I
for (int i = 0; i < fruits.size(); i++) {
int j = fruits.get(i);
//如果添加的是String类型的,get()返回的是Integer
System.out.println(j);
}
System.out.println(fruits.get(1));
}
}
3.List
(1).ArrayList
1).注意事项:
- 可以放任何值,包括null
- ArrayList 基本等同于Vector,除了 ArrayList是线程不安全(执行效率高) 看源码在多线程情况下,不建议使用ArrayList
2).ArrsyList底层结构分析:
transient:表示该属性不会被序列化
(2).Vector
1).定义说明:
- Vector底层也是一个对象数组,protected Object[ ] elementData;
- Vector 是线程同步的,即线程安全,Vector类的操作方法带有synchronized
- 在开发中,需要线程同步安全时,考虑使用Vector
2).扩容机制
(3).LinkedList
1).定义说明
2). 底层结构
(4).ArrayList和LinkedList比较
4.Set
(1).常用方法
和list接口一样,Set也是Collection的子接口,因此,常用方法和Collection一样
注:虽然Set的顺序不是存放顺序,但是这个顺序是固定的。
(2).Set接口遍历方式
迭代器、增强for、不能使用普通for(索引的方式来获取)
public class HashSet {
public static void main(String[] args) {
Set set = (Set) new HashSet();
set.add("a");
set.add("b");
set.add("b");
set.add(null);
set.add(null);//不重复
//方式一:迭代iterator
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
//方式二:
for (Object o :set) {
System.out.println(o);
}
//不能使用普通for循环
}
}
(3).HashSet
1).定义说明:
1)HashSet实现了Set接口
2)HashSet实际上是HashMap。HashMap的底层是(数组+链表+红黑树).
3)可以存放null值,但是只能有一个null
4)HashSet不保证存放元素的顺序和取出顺序一致。
2).HashSet添加元素底层源码:
public class a {
public static void main(String[] args) {
Set hashSet =(Set) new HashSet();
System.out.println(hashSet.add(new Dog("小黑")));//t
System.out.println(hashSet.add(new Dog("小黑")));//t
System.out.println(hashSet.add(new String("小黑")));//t
System.out.println(hashSet.add(new String("小黑")));//F,添加不进去,看底层源码
}
}
class Dog{
private String name;
public Dog(String name) {
this.name = name;
}
}
分析:
equals()方法和hash()方法同时出现。快捷键选择
HashSet扩容机制:
(4).LinkedHashSet
定义说明:
1)LinkedHashSet 是 HashSet 的子类。
2)LinkedHashSet 底层是一个 LinkedHashMap,底层维护了一个 数组+双向链表
3) LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置,同时使用链表维护元素的次序,这使得元素看起来是以插入顺序保存的。
4)LinkedHashSet 不允许添重复元素
(5).treeset
treeset的底层就是treeMap
public class a {
public static void main(String[] args) {
//1.不做任何处理,创建TreeSet时,是无序的
//2.现在让它按照字符串大小排序
//3.使用TreeSet 提供的一个构造器,可以传入一个比较器(匿名内部类)
//并指定排序规则
TreeSet<Object> treeSet = new TreeSet<>(new Comparator<Object>() {
@Override
public int compare(Object o1, Object o2) {
//按照首字母大小
return ((String)o1).compareTo((String) o2);
//调用字符串的compareto方法,比较字符大小
//前-后,然后返回
//这种添加一个a,可以成功添加
//按照长度大小排序
//return ( (String)o2).length() - ( (String)o1).length();
//这个时候再添加一个长度为1的,添加失败,已经有一个长度为1的了
}
});
treeSet.add("aaaa");
treeSet.add("taa");
treeSet.add("ka");
treeSet.add("l");
treeSet.add("a");
System.out.println(treeSet);
//1.构造器把传入的比较器对象赋给了,TreeeSet的底层的reeMap的属性this.comparator
//2.在调用add方法时,底层会动态绑定到我们的匿名类对象compare
}
}
5.Map接口(双列)
(1).map接口的特点:
synchronized
//1.k-v 最后是 HashMapSNode node = newNode(hash,key,value,null)
//2.K-v 为了方便程序员的遍历,还会 创建 EntrySet 集合 ,该集合存放的元素的类型 Entry,而一个Entry对象就有k,v EntrySet<Entry<K,V>>,只是指向k和v。
(2).常用方法
1)put:添加,如果key一样,value不一样,会发生替换
2)remove:根据键删除映射关系
3) get: 根据键获取值
4)size:获取元素个数
5)isEmpty:判断个数是否为0
6)clear:清除
7)containsKey:查找键是否存在
(3).Map集合遍历的6种方法
public class a {
public static void main(String[] args) {
HashMap<Object, Object> map = new HashMap<>();
map.put("1","one");
map.put("2","two");
map.put("3","two");
map.put("4","two");
map.put("5","two");
//第一组:先取出key,通过Key取出对应的value
//keySet集合里面存放的是key
Set<Object> keyset = map.keySet();
//(1)增强for
for (Object o :keyset) {
System.out.println(map.get(o));
}
//(2)迭代器
Iterator iterator= keyset.iterator();
//这里是keyset.iterator不是map,数据在keyset里面
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
//第二组:把values集合取出来
// values集合(里面存放的是value值)
Collection<Object> values = map.values();
//使用3种方法取出value(增强for,iterator)
//(1).增强for
for (Object o :values) {
System.out.println(o);
}
//(2)iterator
Iterator<Object> iterator1 = values.iterator();
while (iterator1.hasNext()) {
Object next = iterator1.next();
System.out.println(next);
}
//第三组:通过entrySet来获取
Set<Map.Entry<Object, Object>> entries = map.entrySet();
//(1).增强for
for (Object o :entries) {
Map.Entry m=(Map.Entry) o;//先把它转换为Map.Entry
System.out.println(m.getKey()+""+m.getValue());
}
// (2).迭代器
Iterator<Map.Entry<Object, Object>> iterator2 = entries.iterator();
while (iterator2.hasNext()) {
Map.Entry<Object, Object> next = iterator2.next();
//向下转型
Map.Entry m=(Map.Entry) next;
//next的类型是HashMap$Node
System.out.println(next.getKey()+""+next.getValue());
}
}
}
(4).HashMap底层机制及源码剖析
table数组+链表+红黑数(长度大于64变树)
数组元素都是HashMap$Node(k-v)
(5).HashTable
基本介绍:
1)存放的元素是键值对: 即 K-V
2)hashtable的键和值都不能为null, 否则会抛出NullPointer
3)hashTable 使用方法基本上和HashMap一样
4)hashTable 是线程安全的(synchronized),hashMap 是线程不安全的
(6).Properties
基本介绍:
public class properties_ {
public static void main(String[] args) {
Properties properties = new Properties();
//1.添加,k,v不能为空
properties.put("a",1);
properties.put("a",2);//替换上面的
properties.put("b",1);
properties.put("c",3);
//properties.put("a",null);异常
System.out.println(properties);
//通过k获取值
System.out.println(properties.get("a"));//2
//2.删除
properties.remove("lic");
System.out.println(properties);
//3.修改
properties.put("c",4);
}
}
(7).treeMap
public class d {
public static void main(String[] args) {
//1.使用默认构造器Treemap是无序
//2.现在按照字符K大小排序
//3.构造器把传入的,compator接口的匿名内部类,传给TreeMap
//4.调用put
//4.1第一次添加,把k-v封装到Entry对象,放入root
//4.2第二次添加,遍历所有的key,给当前的k找个合适位置
//通过动态绑定,使用我们的匿名内部类来比较k(如果compater比较的是长度,再添加一个长度相等的,不能添加)
//如果按照字符添加“a”,添加成功
TreeMap<Object, Object> tp = new TreeMap<>(new Comparator<Object>() {//匿名内部类
@Override
public int compare(Object o1, Object o2) {
//return ((String)o1).compareTo((String) o2);
//按照长度排序
return ((String) o2).length()-((String) o1).length();
}
});
tp.put("qwq","1");
tp.put("tom","1");
tp.put("kisss","1");
tp.put("siml","1");
System.out.println(tp);
}
}
6.如何选择集合实现类
linkedhashmap:数组+双链表
7.collections工具类
public class a {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
//reverse(List): 反转 List 中元素的顺序
Collections.reverse(list);
System.out.println("元素反转"+list);
//shuffle(List):对 List 集合元素进行随机排序
//Collections.shuffle(list);
//System.out.println(list);
//sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序
//按照字符串顺序
Collections.sort(list);
//sort(List,Comparator): 根据指定的 Comparator 产生的顺序对 List 集合元素
//现在按照字符串长度大小排序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return ((String)o1).length()-((String)o2).length();
}
});
System.out.println("按长度排序"+list);
//swap(List,int, int): 将指定 List 集合中的 i 处元素和 j 处元素进行交换
Collections.swap(list,0,1);
System.out.println(list);
//Object max(Collection):根据元素的自然顺序,返回集合的最大元素
System.out.println(Collections.max(list));
//Object max(Collection,Comparator):根据Comparator给的顺序,返回集合的最大元素
//比如,返回长度最值的元素
Collections.max(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return ((String)o1).length()-((String)o2).length();
}
});
//Object min(Collection):根据元素的自然顺序,返回集合的最小元素
//Object min(Collection,Comparator):根据Comparator给的顺序,返回集合的最小元素
//和max一样
//int frequency(list, src):list是集合,src是要统计的字符串
System.out.println("a出现的次数"+Collections.frequency(list,"a"));
//void copy (list,src):将src的内容复制到list
//为了完成一个完整的拷贝,我们需要先给list赋值,大小和src一样
ArrayList<String> list1 = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
list1.add("");
}
Collections.copy(list1,list);
System.out.println(list1);
//boolean replaceAll(list,"a","b")把list集合里的a替换为b
Collections.replaceAll(list,"a","A");
}
}
8.练习
1.
(1).创建 3个 Dog {name,age} 对象,放入到 ArrayList 中,赋给 List 引用
(2).用选代器和增强for循环两种方式来遍历
(3).重写Dog 的toString方法,输出name和age
public class e1 {
public static void main(String[] args) {
List<Object> Dog = new ArrayList<>();
Dog.add(new Dog("小白",1));
Dog.add(new Dog("小黑",2));
Dog.add(new Dog("小红",3));
Iterator iterator = Dog.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
for (Object dog :Dog) {
System.out.println(dog);
}
}
}
class Dog{
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "姓名:"+this.name+" ,年龄:"+this.age;
}
}
2.
public class a {
public static void main(String[] args) {
ArrayList<Object> book = new ArrayList<>();
book.add(new Book("西游记", "吴承恩", 10));
book.add(new Book("水浒传", "施耐庵", 19));
book.add(new Book("红楼梦", "曹雪芹", 100));
book.add(new Book("三国演", "罗贯中", 80));
//book.add(new Book("西游记","吴承恩",10));
int[] array = new int[book.size()];
for (Object o : book) {
System.out.println(o);
}
BubbleSort(book);
for (Object o : book) {
System.out.println(o);
}
}
//静态方法
public static void BubbleSort(List list) {
// 外层循环控制冒泡排序的趟数
// size-1表示:最后一趟区间中只剩余1个元素,该趟冒泡可以省略
for (int i = 0; i < list.size() - 1; i++) {
// 具体冒泡的方式:用相邻的两个元素进行比较,前一个大于后一个元素时,交换着两个数据,依次直到数组的末尾
for (int j = 1; j < list.size() - i-1; j++) {
//取出book
Book book1=(Book)list.get(j);
Book book2=(Book)list.get(j+1);
if (book1.getPrice()>book2.getPrice()) {
list.set(j,book2);
list.set(j+1,book1);
}
}
}
}
}
class Book{
private String name;
private int price;
private String actor;
public Book(String name, String actor,int price) {
this.name = name;
this.price = price;
this.actor = actor;
}
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;
}
public String getActor() {
return actor;
}
public void setActor(String actor) {
this.actor = actor;
}
@Override
public String toString() {
return "名称"+name+"\t\t价格:"+price+"\t\t作者:"+actor;
}
}
3.
ublic class e3 {
public static void main(String[] args) {
HashSet<Object> set = new HashSet<>();
set.add(new Employee1("a",12));
set.add(new Employee1("b",19));
set.add(new Employee1("a",12));
System.out.println(set);
}
}
class Employee1 {
private String name;
private int age;
//如果name'和age相同,返回相同的
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee1 employee1 = (Employee1) o;
return age == employee1.age && Objects.equals(name, employee1.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public Employee1(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Employee1{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
4.
public class e1 {
public static void main(String[] args) {
Set set = (Set) new HashSet();
set.add(new Employee("1", 1000, new MyDate(2,2,2)) );
set.add(new Employee("1", 1000, new MyDate(2,2,2) ));
set.add(new Employee("2", 1000, new MyDate(2,2,2) ));
System.out.println(set.toString());
}
}
class Employee{
private String name;
private int sal;
private MyDate birthday;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return Objects.equals(name, employee.name) && Objects.equals(birthday, employee.birthday);
}
@Override
public int hashCode() {
return Objects.hash(name, birthday);
}
public Employee(String name, int sal, MyDate birthday) {
this.name = name;
this.sal = sal;
this.birthday = birthday;
}
public MyDate getBirthday() {
return birthday;
}
public void setBirthday(MyDate birthday) {
this.birthday = birthday;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", sal=" + sal +
", birthday=" + birthday +
'}';
}
}
class MyDate{
private int year;
private int month;
private int day;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MyDate myDate = (MyDate) o;
return year == myDate.year && month == myDate.month && day == myDate.day;
}
@Override
public int hashCode() {
return Objects.hash(year, month, 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 String toString() {
return "MyDate{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
}
5.
public class e4 {
public static void main(String[] args) {
LinkedHashSet<Object> set = new LinkedHashSet<>();
set.add(new Car("qwq",123));
set.add(new Car("qwq",123));
set.add(new Car("奔驰",12223));
System.out.println(set);
}
}
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 == null || getClass() != o.getClass()) return false;
Car car = (Car) o;
return Double.compare(price, car.price) == 0 && Objects.equals(name, car.name);
}
@Override
public int hashCode() {
return Objects.hash(name, price);
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
5.
键:员工id
值:工对象
使用HashMap添加3个员工对象,要求
并遍历显示工资>18000的员工(遍历方式最少两种)
员工类: 姓名、工资、员工id
public class e5 {
public static void main(String[] args) {
HashMap<Object, Object> map = new HashMap<>();
map.put("123456",new Emplyee("小明",12000,"123456"));
map.put("123457",new Emplyee("小来",19000,"123457"));
map.put("123458",new Emplyee("小张",1200,"123458"));
Set<Object> objects = map.keySet();
for (Object o :objects) {
//先获取value
Emplyee e=(Emplyee) map.get(o);//根据键获取值,再转为emp
if (e.getSal()>18000)
System.out.println(e);
}
//1.先获取entrySet
Set<Map.Entry<Object, Object>> entries = map.entrySet();
//2.创建enterset的迭代器
Iterator<Map.Entry<Object, Object>> iterator = entries.iterator();
while (iterator.hasNext()) {
//3.把迭代的内容转为Map.entry
Map.Entry<Object, Object> next = (Map.Entry) iterator.next();
//4.Map.entry通过getValue获取内容,再把内容转为Emplyee
Emplyee e1=(Emplyee) next.getValue();
if (e1.getSal()>18000)
System.out.println(e1);
}
}
}
class Emplyee{
private String name;
private int sal;
private String id;
public Emplyee(String name, int sal, String id) {
this.name = name;
this.sal = sal;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSal() {
return sal;
}
public void setSal(int sal) {
this.sal = sal;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@Override
public String toString() {
return "Emplyee{" +
"name='" + name + '\'' +
", sal=" + sal +
", id='" + id + '\'' +
'}';
}
}
6.
按要求实现:
(1)封装一个新闻类,包含标题和内容属性,提供get、set方法,重写toString方法,打印对象
时只打印标题;
(2) 只提供一个带参数的构造器,实例化对象时,只初始化标题; 并且实例化两个对象:
新闻一: 新冠确诊病例超千万,数百万印度教信徒赴恒河“圣浴”引民众担忧
新闻二:男子突然想起2个月前钓的鱼还在网兜里,捞起一看赶紧放生
(3)将新闻对象添加到ArrayList集合中,并且进行倒序遍历;
(4)在遍历集合过程中,对新闻标题进行处理,超过15字的只保留前15个,然后在后边加
(5) 在控制台打印遍历出经过处理的新闻标题
public class e1 {
public static void main(String[] args) {
ArrayList list=new ArrayList<>();
list.add(new News("新闻一:新冠确诊qwqwq,并且实例化两个对象qwqwqq"));
list.add(new News("新闻二:突然想起来2个月前的鱼还在与哇嘎里aaaaaa"));
Collections.reverse(list);
for (Object o :list) {
News n=(News) o;
System.out.println(processTitle(n.getTitle()));
}
}
public static String processTitle(String title) {
if (title==null){
return "";
}
if(title.length()>15){
return title.substring(0,15)+"...";//(0,15]
}else {
return title;
}
}
}
class News{
private String title;
private String content;
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 +
'}';
}
public News(String title) {
this.title = title;
}
}
7.
按要求完成下列任务
1)使用HashMap类实例化一个Map类型的对象m,键 (String) 和值 (int)分别用于存储员
工的姓名和工资,存入数据如下:jack-650元; tom-1200元; smith-2900元;
2)将iack的工资更改为2600元,为所有员工工资加薪100元;
3)遍历集合中所有的员工
4)遍历集合中所有的工资
public class e3 {
public static void main(String[] args) {
HashMap<Object, Object> map = new HashMap<>();
map.put("jack",650);
map.put("tom",1200);
map.put("smith",2900);
map.replace("jack",2600);
//薪资加100
Set keyset=map.keySet();
for (Object o :keyset) {
map.put(o,(Integer)map.get(o)+100);
}
System.out.println(map);
//遍历
Set<Map.Entry<Object, Object>> entries = map.entrySet();
Iterator<Map.Entry<Object, Object>> iterator = entries.iterator();
while (iterator.hasNext()) {
Map.Entry<Object, Object> next = iterator.next();
System.out.println(next.getKey()+"="+next.getValue());
}
//遍历工资
Collection<Object> values = map.values();
for (Object o :values) {
System.out.println(o);
}
}
}
8.
试分析HashSet和TreeSet分别如何实现去重的?
(1)HashSet的去重机制:
- hashCode()+ equals(),底层先通过存入对象,进行运算得到一个hash值,
- 通过hash值得到对应的索引,
- 如果发现table索引所在的位置,没有数据,就直接存放
- 如果有数据,就进行equals比较[遍历比较],
- 如果比较后,不相同,就加入,否则就不加入.
(2) TreeSet的去重机制:
- 如果你传入了一个Comparator匿名对象,就使用实现的compare去重。
- 如果方法返回0,就认为是相同的元素/数据,就不添加。
- 如果你没有传入一个Comparator匿名对象,则以你添加的对象实现的Compareable接口的compareTo去重。(字符串的compaterto方法比较的是内容)