在 Java 编程领域，集合框架是不可或缺的重要组成部分之一。无论是开发小型应用还是构建复杂系统，Java 集合框架都扮演着至关重要的角色。它为程序员提供了一套强大且灵活的工具，用于存储、操作和管理数据。本博客将接续上一篇文章，继续带领读者深入探索 Java 集合框架的方方面面，从基础概念到高级应用。
目录
5. Collection子接口2：Set
5.1 Set接口概述
-
Set接口是Collection的子接口，Set接口相较于Collection接口没有提供额外的方法
-
Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。
-
Set集合支持的遍历方式和Collection集合一样：foreach和Iterator。
-
Set的常用实现类有：HashSet、TreeSet、LinkedHashSet。
5.2 Set主要实现类：HashSet
5.2.1 HashSet概述
-
HashSet 是 Set 接口的主要实现类，大多数时候使用 Set 集合时都使用这个实现类。
-
HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存储、查找、删除性能。
-
HashSet 具有以下
特点：-
不能保证元素的排列顺序
-
HashSet 不是线程安全的
-
集合元素可以是 null
-
-
HashSet 集合
判断两个元素相等的标准：两个对象通过hashCode()方法得到的哈希值相等，并且两个对象的equals()方法返回值为true。 -
对于存放在Set容器中的对象，对应的类一定要重写hashCode()和equals(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。
-
HashSet集合中元素的无序性，不等同于随机性。这里的无序性与元素的添加位置有关。具体来说：我们在添加每一个元素到数组中时，具体的存储位置是由元素的hashCode()调用后返回的hash值决定的。导致在数组中每个元素不是依次紧密存放的，表现出一定的无序性。
5.2.2 HashSet中添加元素的过程：
-
第1步：当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法得到该对象的 hashCode值，然后根据 hashCode值，通过某个散列函数决定该对象在 HashSet 底层数组中的存储位置。
-
第2步：如果要在数组中存储的位置上没有元素，则直接添加成功。
-
第3步：如果要在数组中存储的位置上有元素，则继续比较：
-
如果两个元素的hashCode值不相等，则添加成功；
-
如果两个元素的hashCode()值相等，则会继续调用equals()方法：
-
如果equals()方法结果为false，则添加成功。
-
如果equals()方法结果为true，则添加失败。
-
第2步添加成功，元素会保存在底层数组中。
第3步两种添加成功的操作，由于该底层数组的位置已经有元素了，则会通过
链表的方式继续链接，存储。 -
示例：
import java.util.Objects;
public 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;
}
@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);
}
@Override
public String toString() {
return "MyDate{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
}import org.junit.Test;
import java.util.HashSet;
public class TestHashSet {
@Test
public void test01(){
HashSet set = new HashSet();
set.add("张三");
set.add("张三");
set.add("李四");
set.add("王五");
set.add("王五");
set.add("赵六");
System.out.println("set = " + set);//不允许重复，无序
}
@Test
public void test02(){
HashSet set = new HashSet();
set.add(new MyDate(2021,1,1));
set.add(new MyDate(2021,1,1));
set.add(new MyDate(2022,2,4));
set.add(new MyDate(2022,2,4));
System.out.println("set = " + set);//不允许重复，无序
}
}5.2.3 重写 hashCode() 方法的基本原则
-
在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。
-
当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode() 方法的返回值也应相等。
-
对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。
注意：如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。
5.2.4 重写equals()方法的基本原则
-
重写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。
-
推荐：开发中直接调用Eclipse/IDEA里的快捷键自动重写equals()和hashCode()方法即可。
-
为什么用Eclipse/IDEA复写hashCode方法，有31这个数字？
首先，选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）
其次，31只占用5bits,相乘造成数据溢出的概率较小。
再次，31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。（提高算法效率）
最后，31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！(减少冲突)
-
5.3 Set实现类之二：LinkedHashSet
-
LinkedHashSet 是 HashSet 的子类，不允许集合元素重复。
-
LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用
双向链表维护元素的次序，这使得元素看起来是以添加顺序保存的。 -
LinkedHashSet
插入性能略低于 HashSet，但在迭代访问Set 里的全部元素时有很好的性能。
示例：
import org.junit.Test;
import java.util.LinkedHashSet;
public class TestLinkedHashSet {
@Test
public void test01(){
LinkedHashSet set = new LinkedHashSet();
set.add("张三");
set.add("张三");
set.add("李四");
set.add("王五");
set.add("王五");
set.add("赵六");
System.out.println("set = " + set);//不允许重复，体现添加顺序
}
}5.4 Set实现类之三：TreeSet
5.4.1 TreeSet概述
-
TreeSet 是 SortedSet 接口的实现类，TreeSet 可以按照添加的元素的指定的属性的大小顺序进行遍历。
-
TreeSet底层使用
红黑树结构存储数据 -
新增的方法如下： (了解)
-
Comparator comparator()
-
Object first()
-
Object last()
-
Object lower(Object e)
-
Object higher(Object e)
-
SortedSet subSet(fromElement, toElement)
-
SortedSet headSet(toElement)
-
SortedSet tailSet(fromElement)
-
-
TreeSet特点：不允许重复、实现排序（自然排序或定制排序）
-
TreeSet 两种排序方法：
自然排序和定制排序。默认情况下，TreeSet 采用自然排序。-
自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列。-
如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。
-
实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。
-
-
定制排序：如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。-
利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
-
要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
-
-
-
因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是
同一个类的对象。 -
对于 TreeSet 集合而言，它判断
两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj) 或compare(Object o1,Object o2)方法比较返回值。返回值为0，则认为两个对象相等。
5.4.2 举例
import org.junit.Test;
import java.util.Iterator;
import java.util.TreeSet;
/**
* @author 尚硅谷-宋红康
* @create 14:22
*/
public class TreeSetTest {
/*
* 自然排序：针对String类的对象
* */
@Test
public void test1(){
TreeSet set = new TreeSet();
set.add("MM");
set.add("CC");
set.add("AA");
set.add("DD");
set.add("ZZ");
//set.add(123); //报ClassCastException的异常
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
/*
* 自然排序：针对User类的对象
* */
@Test
public void test2(){
TreeSet set = new TreeSet();
set.add(new User("Tom",12));
set.add(new User("Rose",23));
set.add(new User("Jerry",2));
set.add(new User("Eric",18));
set.add(new User("Tommy",44));
set.add(new User("Jim",23));
set.add(new User("Maria",18));
//set.add("Tom");
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println(set.contains(new User("Jack", 23))); //true
}
}其中，User类定义如下：
public class User implements Comparable{
String name;
int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
/*
举例：按照age从小到大的顺序排列，如果age相同，则按照name从大到小的顺序排列
* */
public int compareTo(Object o) {
if(this == o){
return 0;
}
if(o instanceof User){
User user = (User)o;
int value = this.age - user.age;
if(value != 0){
return value;
}
return -this.name.compareTo(user.name);
}
throw new RuntimeException("输入的类型不匹配");
}
}
6. Map接口
现实生活与开发中，我们常会看到这样的一类集合：用户ID与账户信息、学生姓名与考试成绩、IP地址与主机名等，这种一一对应的关系，就称作映射。Java提供了专门的集合框架用来存储这种映射关系的对象，即`java.util.Map`接口。
6.1 Map接口概述
-
Map与Collection并列存在。用于保存具有
映射关系的数据：key-value-
Collection集合称为单列集合，元素是孤立存在的（理解为单身）。 -
Map集合称为双列集合，元素是成对存在的(理解为夫妻)。
-
-
Map 中的 key 和 value 都可以是任何引用类型的数据。但常用String类作为Map的“键”。
-
Map接口的常用实现类：
HashMap、LinkedHashMap、TreeMap和`Properties。其中，HashMap是 Map 接口使用频率最高的实现类。
6.2 Map中key-value特点
这里主要以HashMap为例说明。HashMap中存储的key、value的特点如下：
-
Map 中的
key用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法 -
key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value，不同key对应的
value可以重复。value所在的类要重写equals()方法。 -
key和value构成一个entry。所有的entry彼此之间是
无序的、不可重复的。
6.3 Map接口的常用方法
-
添加、修改操作：
-
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
-
void putAll(Map m):将m中的所有key-value对存放到当前map中
-
-
删除操作：
-
Object remove(Object key)：移除指定key的key-value对，并返回value
-
void clear()：清空当前map中的所有数据
-
-
元素查询的操作：
-
Object get(Object key)：获取指定key对应的value
-
boolean containsKey(Object key)：是否包含指定的key
-
boolean containsValue(Object value)：是否包含指定的value
-
int size()：返回map中key-value对的个数
-
boolean isEmpty()：判断当前map是否为空
-
boolean equals(Object obj)：判断当前map和参数对象obj是否相等
-
-
元视图操作的方法：
-
Set keySet()：返回所有key构成的Set集合
-
Collection values()：返回所有value构成的Collection集合
-
Set entrySet()：返回所有key-value对构成的Set集合
-
示例1：
import java.util.HashMap;
public class TestMapMethod {
public static void main(String[] args) {
//创建 map对象
HashMap map = new HashMap();
//添加元素到集合
map.put("黄晓明", "杨颖");
map.put("李晨", "李小璐");
map.put("李晨", "范冰冰");
map.put("邓超", "孙俪");
System.out.println(map);
//删除指定的key-value
System.out.println(map.remove("黄晓明"));
System.out.println(map);
//查询指定key对应的value
System.out.println(map.get("邓超"));
System.out.println(map.get("黄晓明"));
}
}6.4 Map的主要实现类：HashMap
6.3.1 HashMap概述
-
HashMap是 Map 接口
使用频率最高的实现类。 -
HashMap是线程不安全的。允许添加 null 键和 null 值。
-
存储数据采用的哈希表结构，底层使用
一维数组+单向链表+红黑树进行key-value数据的存储。与HashSet一样，元素的存取顺序不能保证一致。 -
HashMap
判断两个key相等的标准是：两个 key 的hashCode值相等，通过 equals() 方法返回 true。 -
HashMap
判断两个value相等的标准是：两个 value 通过 equals() 方法返回 true。
6.3.2 练习
添加你喜欢的歌手以及你喜欢他唱过的歌曲
public class SingerTest1 {
public static void main(String[] args) {
//创建一个HashMap用于保存歌手和其歌曲集
HashMap singers = new HashMap();
//声明一组key,value
String singer1 = "周杰伦";
ArrayList songs1 = new ArrayList();
songs1.add("双节棍");
songs1.add("本草纲目");
songs1.add("夜曲");
songs1.add("稻香");
//添加到map中
singers.put(singer1,songs1);
//声明一组key,value
String singer2 = "陈奕迅";
List songs2 = Arrays.asList("浮夸", "十年", "红玫瑰", "好久不见", "孤勇者");
//添加到map中
singers.put(singer2,songs2);
//遍历map
Set entrySet = singers.entrySet();
for(Object obj : entrySet){
Map.Entry entry = (Map.Entry)obj;
String singer = (String) entry.getKey();
List songs = (List) entry.getValue();
System.out.println("歌手：" + singer);
System.out.println("歌曲有：" + songs);
}
}
}6.5 Map实现类之二：LinkedHashMap
-
LinkedHashMap 是 HashMap 的子类
-
存储数据采用的哈希表结构+链表结构，在HashMap存储结构的基础上，使用了一对
双向链表来记录添加元素的先后顺序，可以保证遍历元素时，与添加的顺序一致。 -
通过哈希表结构可以保证键的唯一、不重复，需要键所在类重写hashCode()方法、equals()方法。
public class TestLinkedHashMap {
public static void main(String[] args) {
LinkedHashMap map = new LinkedHashMap();
map.put("王五", 13000.0);
map.put("张三", 10000.0);
//key相同，新的value会覆盖原来的value
//因为String重写了hashCode和equals方法
map.put("张三", 12000.0);
map.put("李四", 14000.0);
//HashMap支持key和value为null值
String name = null;
Double salary = null;
map.put(name, salary);
Set entrySet = map.entrySet();
for (Object obj : entrySet) {
Map.Entry entry = (Map.Entry)obj;
System.out.println(entry);
}
}
}6.6 Map实现类之三：TreeMap
-
TreeMap存储 key-value 对时，需要根据 key-value 对进行排序。TreeMap 可以保证所有的 key-value 对处于
有序状态。 -
TreeSet底层使用
红黑树结构存储数据 -
TreeMap 的 Key 的排序：
-
自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException -
定制排序：创建 TreeMap 时，构造器传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口
-
-
TreeMap判断
两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。
public class TestTreeMap {
/*
* 自然排序举例
* */
@Test
public void test1(){
TreeMap map = new TreeMap();
map.put("CC",45);
map.put("MM",78);
map.put("DD",56);
map.put("GG",89);
map.put("JJ",99);
Set entrySet = map.entrySet();
for(Object entry : entrySet){
System.out.println(entry);
}
}
/*
* 定制排序
*
* */
@Test
public void test2(){
//按照User的姓名的从小到大的顺序排列
TreeMap map = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof User && o2 instanceof User){
User u1 = (User)o1;
User u2 = (User)o2;
return u1.name.compareTo(u2.name);
}
throw new RuntimeException("输入的类型不匹配");
}
});
map.put(new User("Tom",12),67);
map.put(new User("Rose",23),"87");
map.put(new User("Jerry",2),88);
map.put(new User("Eric",18),45);
map.put(new User("Tommy",44),77);
map.put(new User("Jim",23),88);
map.put(new User("Maria",18),34);
Set entrySet = map.entrySet();
for(Object entry : entrySet){
System.out.println(entry);
}
}
}
class User implements Comparable{
String name;
int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public User() {
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
/*
举例：按照age从小到大的顺序排列，如果age相同，则按照name从大到小的顺序排列
* */
@Override
public int compareTo(Object o) {
if(this == o){
return 0;
}
if(o instanceof User){
User user = (User)o;
int value = this.age - user.age;
if(value != 0){
return value;
}
return -this.name.compareTo(user.name);
}
throw new RuntimeException("输入的类型不匹配");
}
}6.7 Map实现类之四：Hashtable
-
Hashtable是Map接口的
古老实现类，JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。 -
Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构（数组+单向链表），查询速度快。
-
与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序
-
Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。
-
与HashMap不同，Hashtable 不允许使用 null 作为 key 或 value。
Hashtable和HashMap的区别
HashMap:底层是一个哈希表（jdk7:数组+链表;jdk8:数组+链表+红黑树）,是一个线程不安全的集合,执行效率高
Hashtable:底层也是一个哈希表（数组+链表）,是一个线程安全的集合,执行效率低
HashMap集合:可以存储null的键、null的值
Hashtable集合,不能存储null的键、null的值
Hashtable和Vector集合一样,在jdk1.2版本之后被更先进的集合(HashMap,ArrayList)取代了。所以HashMap是Map的主要实现类，Hashtable是Map的古老实现类。
Hashtable的子类Properties（配置文件）依然活跃在历史舞台
Properties集合是一个唯一和IO流相结合的集合
6.8 Map实现类之五：Properties
-
Properties 类是 Hashtable 的子类，该对象用于处理属性文件
-
由于属性文件里的 key、value 都是字符串类型，所以 Properties 中要求 key 和 value 都是字符串类型
-
存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法
public void test01() {
Properties properties = System.getProperties();
String fileEncoding = properties.getProperty("file.encoding");//当前源文件字符编码
System.out.println("fileEncoding = " + fileEncoding);
}
@Test
public void test02() {
Properties properties = new Properties();
properties.setProperty("user","songhk");
properties.setProperty("password","123456");
System.out.println(properties);
}
@Test
public void test03() throws IOException {
Properties pros = new Properties();
pros.load(new FileInputStream("jdbc.properties"));
String user = pros.getProperty("user");
System.out.println(user);
}7. Collections工具类
参考操作数组的工具类：Arrays，Collections 是一个操作 Set、List 和 Map 等集合的工具类。
7.1 常用方法
Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法（均为static方法）：
排序操作：
-
reverse(List)：反转 List 中元素的顺序
-
shuffle(List)：对 List 集合元素进行随机排序
-
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
-
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
-
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
查找
-
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
-
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
-
Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素
-
Object min(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最小元素
-
int binarySearch(List list,T key)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且必须是可比较大小的，即支持自然排序的。而且集合也事先必须是有序的，否则结果不确定。
-
int binarySearch(List list,T key,Comparator c)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且集合也事先必须是按照c比较器规则进行排序过的，否则结果不确定。
-
int frequency(Collection c，Object o)：返回指定集合中指定元素的出现次数
复制、替换
-
void copy(List dest,List src)：将src中的内容复制到dest中
-
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
-
提供了多个unmodifiableXxx()方法，该方法返回指定 Xxx的不可修改的视图。
添加
-
boolean addAll(Collection c,T... elements)将所有指定元素添加到指定 collection 中。
同步
-
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题：
7.2 示例
import org.junit.Test;
import java.text.Collator;
import java.util.*;
public class TestCollections {
@Test
public void test01(){
/*
public static <T> boolean addAll(Collection<? super T> c,T... elements)
将所有指定元素添加到指定 collection 中。Collection的集合的元素类型必须>=T类型
*/
Collection<Object> coll = new ArrayList<>();
Collections.addAll(coll, "hello","java");
Collections.addAll(coll, 1,2,3,4);
Collection<String> coll2 = new ArrayList<>();
Collections.addAll(coll2, "hello","java");
//Collections.addAll(coll2, 1,2,3,4);//String和Integer之间没有父子类关系
}
@Test
public void test02(){
/*
* public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
* 在coll集合中找出最大的元素，集合中的对象必须是T或T的子类对象，而且支持自然排序
*
* public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp)
* 在coll集合中找出最大的元素，集合中的对象必须是T或T的子类对象，按照比较器comp找出最大者
*
*/
List<Man> list = new ArrayList<>();
list.add(new Man("张三",23));
list.add(new Man("李四",24));
list.add(new Man("王五",25));
/*
* Man max = Collections.max(list);//要求Man实现Comparable接口，或者父类实现
* System.out.println(max);
*/
Man max = Collections.max(list, new Comparator<Man>() {
@Override
public int compare(Man o1, Man o2) {
return o2.getAge()-o2.getAge();
}
});
System.out.println(max);
}
@Test
public void test03(){
/*
* public static void reverse(List<?> list)
* 反转指定列表List中元素的顺序。
*/
List<String> list = new ArrayList<>();
Collections.addAll(list,"hello","java","world");
System.out.println(list);
Collections.reverse(list);
System.out.println(list);
}
@Test
public void test04(){
/*
* public static void shuffle(List<?> list)
* List 集合元素进行随机排序，类似洗牌，打乱顺序
*/
List<String> list = new ArrayList<>();
Collections.addAll(list,"hello","java","world");
Collections.shuffle(list);
System.out.println(list);
}
@Test
public void test05() {
/*
* public static <T extends Comparable<? super T>> void sort(List<T> list)
* 根据元素的自然顺序对指定 List 集合元素按升序排序
*
* public static <T> void sort(List<T> list,Comparator<? super T> c)
* 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
*/
List<Man> list = new ArrayList<>();
list.add(new Man("张三",23));
list.add(new Man("李四",24));
list.add(new Man("王五",25));
Collections.sort(list);
System.out.println(list);
Collections.sort(list, new Comparator<Man>() {
@Override
public int compare(Man o1, Man o2) {
return Collator.getInstance(Locale.CHINA).compare(o1.getName(),o2.getName());
}
});
System.out.println(list);
}
@Test
public void test06(){
/*
* public static void swap(List<?> list,int i,int j)
* 将指定 list 集合中的 i 处元素和 j 处元素进行交换
*/
List<String> list = new ArrayList<>();
Collections.addAll(list,"hello","java","world");
Collections.swap(list,0,2);
System.out.println(list);
}
@Test
public void test07(){
/*
* public static int frequency(Collection<?> c,Object o)
* 返回指定集合中指定元素的出现次数
*/
List<String> list = new ArrayList<>();
Collections.addAll(list,"hello","java","world","hello","hello");
int count = Collections.frequency(list, "hello");
System.out.println("count = " + count);
}
@Test
public void test08(){
/*
* public static <T> void copy(List<? super T> dest,List<? extends T> src)
* 将src中的内容复制到dest中
*/
List<Integer> list = new ArrayList<>();
for(int i=1; i<=5; i++){//1-5
list.add(i);
}
List<Integer> list2 = new ArrayList<>();
for(int i=11; i<=13; i++){//11-13
list2.add(i);
}
Collections.copy(list, list2);
System.out.println(list);
List<Integer> list3 = new ArrayList<>();
for(int i=11; i<=20; i++){//11-20
list3.add(i);
}
//java.lang.IndexOutOfBoundsException: Source does not fit in dest
//Collections.copy(list, list3);
//System.out.println(list);
}
@Test
public void test09(){
/*
* public static <T> boolean replaceAll(List<T> list，T oldVal，T newVal)
* 使用新值替换 List 对象的所有旧值
*/
List<String> list = new ArrayList<>();
Collections.addAll(list,"hello","java","world","hello","hello");
Collections.replaceAll(list, "hello","song");
System.out.println(list);
}
}
7.3 练习
模拟斗地主洗牌和发牌，牌没有排序
代码示例：
public class PokerTest {
public static void main(String[] args) {
String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
String[] color = {"方片","梅花","红桃","黑桃"};
ArrayList poker = new ArrayList();
//1. 生成54张扑克牌
for (String s1 : color) {
for (String s2 : num) {
poker.add(s1.concat(" " + s2));
}
}
poker.add("小王");
poker.add("大王");
//2. 洗牌
Collections.shuffle(poker);
//3. 发牌
ArrayList tomCards = new ArrayList();
ArrayList jerryCards = new ArrayList();
ArrayList meCards = new ArrayList();
ArrayList lastCards = new ArrayList();
for (int i = 0; i < poker.size(); i++) {
if(i >= poker.size() - 3){
lastCards.add(poker.get(i));
}else if(i % 3 == 0){
tomCards.add(poker.get(i));
}else if(i % 3 == 1){
jerryCards.add(poker.get(i));
}else {
meCards.add(poker.get(i));
}
}
//4. 看牌
System.out.println("Tom:\n" + tomCards);
System.out.println("Jerry:\n" + jerryCards);
System.out.println("me:\n" + meCards);
System.out.println("底牌:\n" + lastCards);
}
}
1704
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
