Java Collection工具类
目录
Collections工具类
一、Collections工具类介绍
- Collections是一个操作 Set、 List和 Map 等集合的工具类
- Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作
二、Collections常用方法
1.排序操作
package com.hspedu.collections_;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* @author DL5O
* @version 1.0
*/
@SuppressWarnings("all")
public class Collections_ {
public static void main(String[] args) {
List list = new ArrayList();
list.add("tom");
list.add("smith");
list.add("king");
list.add("dalong");
// reverse(List)：反转 List 中元素的顺序
Collections.reverse(list);
System.out.println("list=" + list);
// shuffle(List)：对 List 集合元素进行随机排序
/*for (int i = 0; i < 5; i++) {
Collections.shuffle(list);
System.out.println("list=" + list);
}*/
//sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
Collections.sort(list);
System.out.println("自然排序后=" + list);
//希望按照字符串的长度大小来排序
//sort(List,Comparator)：
Collections.sort(list, new Comparator() {
@Override
public int compare(Object o1, Object 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);
}
}
2. 查找、替换
package com.hspedu.collections_;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* @author DL5O
* @version 1.0
*/
@SuppressWarnings("all")
public class Collections_ {
public static void main(String[] args) {
List list = new ArrayList();
list.add("tom");
list.add("smith");
list.add("king");
list.add("dalong");
// reverse(List)：反转 List 中元素的顺序
Collections.reverse(list);
System.out.println("list=" + list);
// shuffle(List)：对 List 集合元素进行随机排序
/*for (int i = 0; i < 5; i++) {
Collections.shuffle(list);
System.out.println("list=" + list);
}*/
//sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
Collections.sort(list);
System.out.println("自然排序后=" + list);
//希望按照字符串的长度大小来排序
//sort(List,Comparator)：
Collections.sort(list, new Comparator() {
@Override
public int compare(Object o1, Object 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)：
//我们要返回字符串长度最大的
Object max = Collections.max(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).length() - ((String)o2).length();
}
});
System.out.println("按照长度排序最大的元素:" + max);
//Object min(Collection)
//Object min(Collection，Comparator)
//上面的两个方法，参考 max 即
System.out.println("自然排序最小：" + Collections.min(list));
Object min = Collections.min(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).length() - ((String)o2).length();
}
});
System.out.println("按照长度排序最小的元素:" + min);
list.add("dalong");
//int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
System.out.println("dalong的出现次数="+Collections.frequency(list,"dalong"));//2
//void copy(List dest,List src); 将src中的内容复制到dest中
ArrayList dest = new ArrayList();
//为了完成一个完整的拷贝，我们需要先给dest，赋一些值
for (int i = 0; i < list.size() ; i++) {
dest.add("");
}
//拷贝
Collections.copy(dest,list);
//如果不进行任何处理，那么会抛出一个索引越界异常，因为原来数组的长度为0
System.out.println("dest="+dest);
//boolean replaceAll(List list，Object oldVal，Object newVal)：
// 使用新值替换 List 对象的所有旧值
//如果 list 中，有 tom 就替换成 汤姆
Collections.replaceAll(list,"dalong","大龙");
System.out.println("list替换后=" + list);
}
}
三、作业
Homework01
package com.hspedu.homework;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
/**
* @author DL5O
* @version 1.0
*/
public class Homework01 {
public static void main(String[] args) {
News news1 = new News("新闻一");
news1.setContent("新冠确证病例超千万，数百万印度教信徒赴恒河\"圣浴\"引起民众担忧");
News news2 = new News("新闻二");
news2.setContent("男子突然想起两个月前钓的鱼还在网兜，捞起一看赶紧放生");
ArrayList list = new ArrayList();
list.add(news1);
list.add(news2);
Collections.reverse(list);//第一种倒序遍历
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
News news = (News)iterator.next();
//进行一个向下转型，对news实例相关属性进行操作
String oldContent = news.getContent();
String temp = "...";
if( oldContent.length() >= 15){
//方式一:
String newContent = oldContent.substring(0,15) + temp;
news.setContent(newContent);
}
System.out.println(news);
}
/* //第二种倒序遍历
for (int i = list.size() - 1; i >=0 ; i--) {
System.out.println(list.get(i));
}*/
}
}
class News{
private String title;
private String content;
public News(String title) {
this.title = title;
}
@Override
public String toString() {
return title + ':' + 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;
}
}
Homework02
package com.hspedu.homework;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
/**
* @author DL5O
* @version 1.0
*/
@SuppressWarnings("all")
public class Homework02 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
//add 添加元素
Car car1 = new Car("奥拓",12000);
Car car2 = new Car("奥迪",220000);
Car car3 = new Car("宝马",400000);
Car car4 = new Car("宾利",5000000);
list.add(car1);
list.add(car2);
list.add(car3);
list.add(car4);
System.out.println("====list====");
output(list);
//remove 删除元素，这里删除奥拓car1
list.remove(car1);
System.out.println("====删除后====");
output(list);
//contains 查找某个元素是否存在，这里找car1
System.out.println("car1 奥拓是否存在:" + list.contains(car1));//false
//size 获取集合元素个数
System.out.println("list.size()=" + list.size());
//isEmpty 判空
System.out.println("list.isEmpty()=" + list.isEmpty());
//clear 清空
ArrayList newList = new ArrayList();
for (int i = 0; i < list.size() ; i++) {
newList.add(null);
}
Collections.copy(newList,list);
System.out.println("====newList====");
output(newList);
System.out.println("====清空====");
newList.clear();
System.out.println(newList);//[]
//addAll 添加多个元素
newList.add(new Car("法拉利",6000000));
newList.add(new Car("保时捷",7000000));
list.addAll(newList);
System.out.println("====添加后====");
output(list);
//containAll 查找多个元素是否存在
System.out.println("list中的元素是否包含newList中的元素:" + list.containsAll(newList));
//true
list.removeAll(newList);
System.out.println("====删除后====");
output(list);
}
public static void output(ArrayList list){
//增强for循环
/* for (Object car : list) {
System.out.println(car);
}*/
//迭代器
Iterator iterator = list.iterator();
while(iterator.hasNext()){
Object car = iterator.next();
System.out.println(car);
}
}
}
@SuppressWarnings("all")
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
package com.hspedu.homework;
import java.util.*;
/**
* @author DL5O
* @version 1.0
*/
@SuppressWarnings("all")
public class Homework03 {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("jack",650);
map.put("tom",1200);
map.put("smith",2900);
map.replace("jack",2600);//第一种方式
map.put("jack",2600);
Collection values = map.values();
Set keySet = map.keySet();
Iterator iterator = keySet.iterator();
Iterator iterator1 = values.iterator();
while (iterator.hasNext() && iterator1.hasNext()) {
String key = (String)iterator.next();
int value = ((Integer)iterator1.next()).intValue() + 100;
map.replace(key,value);
}
//第一种方法，使用 map.keySe()，获得员工的名字key，然后通过key来获取对应的value
System.out.println("====员工姓名====");
Set keySet1 = map.keySet();
for (Object o :keySet1) {
// System.out.println(o + "-" + map.get(o));
System.out.println("姓名:" + o);
}
//第二种方法 使用map.value 得到员工的工资
System.out.println("====员工工资====");
Collection values1 = map.values();
for (Object o : values1) {
System.out.println("工资:" + o);
}
//遍历所有的员工及其对应的工资
//第三种方式 使用entrySet 方法 进行遍历
System.out.println("====员工的详细信息====");
Set entrySet = map.entrySet();
//1.增强for
for (Object entry : entrySet) {
Map.Entry m = (Map.Entry)entry; //需要进行一个向下转型，
System.out.println(m.getKey() + "-" + m.getValue());
// 使用Map.Entry接口里面的方法，得到key和value
}
//2.使用迭代器
/* Iterator iterator2 = entrySet.iterator();
while (iterator2.hasNext()) {
Map.Entry info= (Map.Entry) iterator2.next();
System.out.println(info.getKey() + "-" + info.getValue());
}*/
}
}
4.试分析HashSet和TreeSet分别如何实现去重
HashSet的去重机制
答：HashCode() + equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值再得到对应索引，如果table表中该索引处，没有数据，就直接存放，如果有数据，就进行equals比较，如果比较后，不相同就加入，否则就不加入
TreeSet去重机制
答：如果传入了一个Comparator匿名内部类，就使用实现的compare去重，如果返回返回0，就认为是相同的元素/数据，就不添加，如果没有传入Comparator匿名对象，则你添加对的对象实现的Compareable接口的compareTo去重
5.代码分析题
会报一个类型异常,因为这里的构造器没有传入一个Comparator接口的匿名内部类
Comparator<? super K> cpr = comparator;
所以在底层，他会把key强转为Comparable接口，让后调用compareTo方法，但是Person又没有继承Comparable，故这里就会抛出一个CastClassException异常
Comparable<? super K> k = (Comparable<? super K>) key;
6.下面代码输出什么
7.试写出Vector和ArrayList的区别
| 底层机构 | 版本 | 线程(同步效率) | 扩容机制 | |
|---|---|---|---|---|
| ArrayList | 可变长数组（Object类型） | jdk 1.5 | 高，但是线程不安全 | 1.第一次扩容10，之后每次扩容按当前数组容量1.5倍进行扩容 2.如果指定了一个具体的初始容量，那么每次当前容量都按1.5倍进行扩容 |
| Vector | 可变长数组（Object类型） | jdk 1.0 | 较低，但是线程安全 | 1.默认是10，每次扩容2倍 2.如果传入给构造器一个具体的容量，那么每次就扩容该容量的2背 |
