Java之集合(难点)_java判断集合内元素长度为4并输出-CSDN博客

本文链接：https://blog.csdn.net/m0_73709096/article/details/134197126

集合

理解和好处

数组
1.长度开始时必须指定，而且一旦指定，不能更改
2.保存的必须是同一类型的元素
3.使用数组进行增加元素的代码-麻烦
集合
1.可以动态保存任意多对象，使用比较方便
2.通过了一系列方便的操作对象的方法：add、romove、set、get等
3.使用集合添加、删除新元素的代码-简洁

集合的框架体系（背下来）

截屏2023-10-29 11.36.13.png
截屏2023-10-29 11.36.35.png

Collection方法

Collection接口实现类的特点

1.collection实现子类可以存放多个元素，每个元素可以说Object
2.有些Collection的实现类，有些可以存放重复的元素，有些不可以
3.有些Collection的实现类，有些是有序的(List)，有些不是有序的(Set)
4.Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的
Collection接口和常用方法
1.add：添加单个元素
2.remove：删除指定元素
3.contains：查找元素是否存在
4.size：获取元素个数
5.isEmpty：判断是否为空
6.clear：清空
7.addAll：添加多个元素
8.containsAll：查找多个元素是否都存在
9.removeAll：删除多个元素

ArrayList 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);//指定删除某个元素
System.out.println("list=" + list);
//contains:查找元素是否存在
System.out.println(list.contains("jack"));//T
//size:获取元素个数
System.out.println(list.size());//2
//isEmpty:判断是否为空
System.out.println(list.isEmpty());//F
//claer:清空
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));
//removeAll:删除多个元素
list.add("聊斋");
list.removeAll(list2);
System.out.println("list=" + list);//[聊斋]

Collection接口遍历元素方式

一、使用Iterator(迭代器)
基本介绍
1.Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
2.所以实现类Collection接口的集合类都有一个interator()方法，用以返回一个实现类Iterator接口的对象，即可以返回一个迭代器
3.Iterator的结构
截屏2023-10-31 11.16.29.png
4.Iterator仅用于遍历集合，Iterator本身并不存放对象

Iterator接口的方法
截屏2023-10-31 11.18.10.png
注意：在调用iterator.next()方法之前必须调用iterator.hasNext()

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionIterator {
	@SuppressWarnings("all")
		public static void main(String[] args) {

		Collection col = new ArrayList();

		col.add(new Book("三国演义","罗贯中",10.1));
		col.add(new Book("小李飞刀","古龙",5.1));
		col.add(new Book("红楼梦","曹雪芹",34.6));

		//System.out.println("col=" + col);
		//现在希望遍历集合
		//1.先得到col对应的迭代器
		Iterator iterator = col.iterator();
		//2.使用while循环遍历
		//        while(iterator.hasNext()){//判断是否还有数据
		//            //返回下一个元素，类型是Object
		//            Object obj = iterator.next();
		//            System.out.println("obj=" + obj);
		//
		//        }
		//快速生成while => itit
		while (iterator.hasNext()) {
			Object obj =  iterator.next();
			System.out.println("obj=" + obj);
		}
		//3.当退出while循环后，这时，iterator指向最后的元素
		//iterator.next();//NoSuchElementException
		//4.如果希望再次遍历，需要重置迭代器
		iterator = col.iterator();
		System.out.println("===第二次遍历===");
		while (iterator.hasNext()) {
			Object obj =  iterator.next();
			System.out.println("obj=" + obj);
		}
	}
}
class Book{
	private String name;
	private String author;
	private double price;

	public Book(String name, String author, double price) {
		this.name = name;
		this.author = author;
		this.price = price;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getAuthor() {
		return author;
	}

	public void setAuthor(String author) {
		this.author = author;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	@Override
		public String toString() {
		return "Book{" +
			"name='" + name + '\'' +
			", author='" + author + '\'' +
			", price=" + price +
			'}';
	}
}

二、增强for循环

import java.util.ArrayList;
import java.util.Collection;

public class CollectionFor {
    @SuppressWarnings("all")
    public static void main(String[] args) {
        Collection col = new ArrayList();

        col.add(new Book("三国演义","罗贯中",10.1));
        col.add(new Book("小李飞刀","古龙",5.1));
        col.add(new Book("红楼梦","曹雪芹",34.6));

        //1.使用增强for循环,在Collection集合
        //2.增强for，底层仍然是迭代器
        //3.增强for可以理解成简化版本的 迭代器遍历
        //4.快捷方式 I
        for(Object book : col){
            System.out.println("book=" + book);
        }
        //增强for 也可以直接在数组使用
        int[] nums = {1,8,10,90};
        for(int i : nums){
            System.out.println("i=" + i);
        }
    }
}

测试题
截屏2023-10-30 17.25.21.png

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;

public class CollectionExercise {
    @SuppressWarnings("all")
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Dog("小黑",3));
        list.add(new Dog("大黄",100));
        list.add(new Dog("大壮",8));

        //先使用for增强
        for (Object dog : list) {
            System.out.println("dog=" + dog);
        }

        //使用迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object dog =  iterator.next();
            System.out.println("dog=" + 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 "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

List接口和常用方法

List接口基本介绍
List接口是Collection接口的子接口
1.List集合类中元素有序(即添加顺序和取出顺序一致)，且可重复
2.List集合中的每个元素都有其对应的顺序索引，即支持索引
3.List容器中的元素都对于一个整数型的序号记载其在容器中的位置，可以根据讯号存取容器中的元素
4.JDK 中List接口的实现类有ArrayList、Vector、LinledList等

       //1.List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        list.add("hsp");
        list.add("tom");
        System.out.println("list=" + list);
        //2.List集合中的每个元素都有其对于的顺序索引，即支持索引
        //  索引是从0开始
        System.out.println(list.get(3));
    }
}

List接口的常用方法
List集合里添加了一些根据索引来操作集合元素的方法
1.add 在index位置插入ele元素
2.addAll 从index位置开始将eles中的所有元素添加进来
3.get 获取指定index位置的元素
4.indexOf 返回obj在集合中首次出现的位置
5.lastIndexOf 返回obj在集合中末次出现的位置
6.remove 移除指定index位置的元素，并返回此元素
7.set 设置指定index位置的元素为ele，相当与替换
8.subList 返回从fromIndex到toIndex位置的子集合

List list = new ArrayList();
//1.void add(int index,Object ele):在index位置插入ele元素
list.add("张三丰");
list.add("贾宝玉");
//在index=1的位置插入一个对象
list.add(1,"韩顺平");
System.out.println("list=" + list);
List list2 = new ArrayList();
list2.add("jack");
list2.add("tom");
//2.boolean addAll(int index,Collection eles):从index位置开始将eles中的所有元素添加进来
list.addAll(1,list2);
System.out.println("list=" + list);
//3.Object get(int index);获取指定index位置的元素
//4.int indexOf(Object obj):返回obj在集合中首次出现的位置
System.out.println(list.indexOf("tom"));
//5.int lastIndexOf(Object obj):返回obj在集合中末次出现的位置
list.add("hsp");
System.out.println("list=" + list);
System.out.println(list.lastIndexOf("hsp"));
//6.Object remove(int index):移除指定index位置的元素，并返回此元素
list.remove(0);
System.out.println(list);
//7.Object set(int index,Object ele):设置指定index位置的元素为ele，相当与替换
list.set(1,"玛丽");
System.out.println("list=" + list);
//8.List subList(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的子集合
List returnlist = list.subList(0,2); //左闭右开
System.out.println("returnlist=" + returnlist);

List的三种遍历方式

//List 接口的实现子类 Vector LinkedList
//List list = new Vector();
//List list = new LinkedList();
//替换List list = new ArrayList();代码也能运行
List list = new ArrayList();
list.add("jack");
list.add("tom");
list.add("鱼香肉丝");
list.add("北京烤鸭");

//遍历
//1.迭代器
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
	Object obj =  iterator.next();
	System.out.println("obj=" + obj);
}
System.out.println("===增强for===");
for (Object o : list) {
	System.out.println("o=" + o);
}
System.out.println("===普通for===");
for (int i = 0; i < list.size(); i++) {
	System.out.println("对象=" + list.get(i));
}

ArrayList

注意事项
1.ArrayList可以加入null，并且可以多个
2.ArrayList是用数组来实现数据存储的
3.ArrayList基本等同于Vector，处理ArrayList是线程不安全(执行效率高)在多线程情况下，不建议使用ArrayList
扩容机制
1.ArrayList中维护了一个Object类型的数组elementData
transient Object[] elementData;//transient 瞬间，短暂的，表示该属性不会被序列化
2.当创建ArrayList对象时，如果使用无参构造器，则初始elemrntData容量为0，第1次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍
3.如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData的1.5倍

Vector

基本介绍
1.Vector类的定义说明
截屏2023-10-31 09.12.42.png
2.Vector底层也是一个对象数组 protected Object[] elementData;
3.Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized
4.开发中，需要线程同步安全时，考虑使用Vector
Vector底层结构和ArrayList的比较
截屏2023-10-31 09.09.31.png

LinkedList

底层结构
1.LinkedList底层实现了双向链表和双端队列特点
2.可以添加任意元素(元素可以重复)，包括null
3.线程不安全，没有实现同步
底层操作机制
1.LinkedList底层维护了一个双向链表
2.LinkedList中维护了两个属性first和last分别执行首结点和尾结点
3.每个结点(Node对象)，里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个结点，最终实现双向链表
4.所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高截屏2023-10-31 09.45.22.png

ArrayList和LinkedList比较

截屏2023-10-31 09.59.52.png
1.如果改查比较多，选择ArrayList
2.如果增删比较多，选择LinkedList
3.一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选择ArrayList
4.在一个项目中，根据业务灵活选择，有可能一个模块使用ArrayList，另一个模块是LinkedList

Set接口和常用方法

基本介绍

1.无序(添加和取出的顺序不一致)，
2.不允许重复元素，所以最大包含一个null
3.JDK API中Set接口的实现类有：HashSet、TreeSet等

常用方法

和List接口语言，Set接口也是Collection的子接口，因此常用方法和Collection接口语言

遍历方式

同Collection的遍历方式语言，因为Set接口是Collection接口的子接口
1.可以使用迭代器
2.增强for
3.不能通过索引获取(没有get方法，不能用普通for循环)

 //1.以Set 接口的实现类 HashSet 来讲解Set 接口的方法
        //2.set 接口的实现类的对象(Set接口对象)，不能存放重复的元素，可以添加一个null
        //3.set 接口对象存放数据是无序(即添加的顺序和取出的顺序不一致)
        //4.注意：取出的顺序虽然不是添加的顺序，但是它是固定的
        Set set = new HashSet();
        set.add("john");
        set.add("lucy");
        set.add("john");
        set.add("jack");
        set.add("hsp");
        set.add("mary");
        set.add(null);
        set.add(null);//再次添加null
        System.out.println("set=" + set);

        //遍历
        //方法1:使用迭代器
        System.out.println("====使用迭代器====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println("obj=" + obj);
        }
        //2.方法2:增强for
        System.out.println("====增强for====");
        for (Object o : set) {
            System.out.println("o=" + o);
        }
        //set接口对象，不能通过索引获取(没有get方法，不能用普通for循环)
    }

HashSet

HashSet底层机制说明
HashSet底层是HashMap，HashMap底层是(数组+链表+红黑树)
截屏2023-10-31 10.58.23.png
截屏2023-10-31 11.19.54.png
练习题
截屏2023-10-31 19.36.28.png

重写equals()和hashCode()的方式
command+N -> Generate equals() and hashCode()打开下图
截屏2023-10-31 19.26.59.png 截屏2023-10-31 19.27.27.png
设置完后出现的代码

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return age == employee.age && Objects.equals(name, employee.name);
}

@Override
public int hashCode() {
	return Objects.hash(name, age);
}

题目完整代码

public class HashSetExercise {
	@SuppressWarnings("all")
	public static void main(String[] args) {
		HashSet hashSet = new HashSet();
		hashSet.add(new Employee("milan",18));//ok
		hashSet.add(new Employee("smith",28));//ok
		hashSet.add(new Employee("milan",18));//no
		System.out.println("hashSet" + hashSet);
	}
}
//创建Employee
class Employee{
	private String name;
	private int age;

	public Employee(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;
	}

	@Override
	public String toString() {
		return "Employee{" +
		"name='" + name + '\'' +
		", age=" + age +
		'}';
	}

	public void setAge(int age) {
		this.age = age;
	}
	//如果name和age值相同，则返回相同的hash值


	@Override
	public boolean equals(Object o) {
		if (this == o) return true;
		if (o == null || getClass() != o.getClass()) return false;
		Employee employee = (Employee) o;
		return age == employee.age && Objects.equals(name, employee.name);
	}

	@Override
	public int hashCode() {
		return Objects.hash(name, age);
	}
}

LinkedHashSet

基本介绍
1.LinkedHashSet是HashSet子类
2.LinkedHashSet底层是一个LinkedHashMap，底层维护了一个数组+双向链表
3.LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序(图)，这使元素看起来是以插入顺序保存的
4.LinkedHashSet不允许添加重复元素

底层机制
截屏2023-10-31 19.53.35.png

TreeSet

//1.当我们使用无参构造器，创建TreeSet时，仍然时无序的
//2.希望添加的元素，按照字符串大小来排序
//3.使用TreeSet提供的构造器，可以传入一个比较器(匿名内部类)
//并指定排序规则
//TreeSet treeSet = new TreeSet();
TreeSet treeSet = new TreeSet(new Comparator() {
	@Override
	public int compare(Object o1, Object o2) {
		//下面 调用String的CompareTo方法进行字符串大小比较
		return ((String)o1).compareTo((String) o2);
	}
});
//添加数据
treeSet.add("jack");
treeSet.add("tom");
treeSet.add("sp");
treeSet.add("a");
System.out.println("treeSet" + treeSet);

Map接口和常用方法

Map接口实现类的特点

注意：这里讲的是JDK8的Map接口特点
1.Map与Collection并列存在，用于保存具有映射关系的数据：Key-Vaule
2.Map中的 key 和 value 可以是任何引用中的数据，会封装到HashMap¥Node 对象中
3.Map中的 key 不允许重复，原因和HashSet原因一样，前面分析过源码
4.Map中的 value 可以重复
5.Map 的 key 可以为 null， value 也可以为bull，注意key为null，只能有一个，value为null，可以多个
6.常用String类作为Map的key
7.key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value

//Map 接口实现类的特点
//1.Map与Collection并列存在。用于保存具有映射关系的数据：Key-Value(双列元素)
//2.Map中的 key 和 value 可以是任何引用中的数据，会封装到HashMap¥Node 对象中
//3.Map中的 key 不允许重复，原因和HashSet原因一样，前面分析过源码
//4.Map中的 value 可以重复
//5.Map 的 key 可以为 null， value 也可以为bull，注意key为null，只能有一个，value为null，可以多个
//6.常用String类作为Map的key
//7.key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
Map map = new HashMap();
map.put("no1","韩顺平");//k-v
map.put("no2","张无忌");//k-v
map.put("no1","张三丰");//当有相同的k，就等价与替换
map.put("no3","张三丰");//k-v
map.put(null,null);
map.put(null,"abc");//等价替换
map.put("no4",null);
map.put("no5",null);
map.put(1,"赵敏");
map.put(new Object(),"金毛狮王");
//通过get方法，传入key，会返回对应的value
System.out.println(map.get("no2"));
System.out.println("map=" + map);

�8.Map存放数据的key-value示意图，一堆k-v是放在Node中的，有因为Node实现了Entry接口，有些书上也说：一堆k-v就是一个Entry
截屏2023-11-01 19.55.01.png

Map接口常用方法

1.put：添加
2.remove：根据键删除映射关系
3.get：根据键获取值
4.size：获取元素个数
5.isEmpty：判断个数是否为0
6.clear：清除
7.containsKey：查找键是否存在

public class MapMethod {
	@SuppressWarnings("all")
	public static void main(String[] args) {

		//演示map接口的常用方法
		Map map = new HashMap();
		map.put("赵怀真",new Book("",100));
		map.put("赵怀真","云缨");//替换
		map.put("关羽","刘备");//ok
		map.put("张飞","刘备");//ok
		map.put("诸葛亮",null);//ok
		map.put(null,"王昭君");//ok
		map.put("兰陵王","小乔");//ok
		System.out.println("map=" + map);

		//remove:根据键删除映射关系
		map.remove(null);
		System.out.println("map=" + map);
		//get:根据键获取值
		Object val = map.get("兰陵王");
		System.out.println("val=" + val);
		//size:获取元素个数
		System.out.println("key-v=" + map.size());
		//isEmpty:判断艺术是否为0
		System.out.println(map.isEmpty());
		//clear:清除k-v
		//map.clear();
		//System.out.println("map=" + map);
		//containsKey:查找键是否存在
		System.out.println("结果=" + map.containsKey("赵怀真"));
	}
}
class Book{
	private  String name;
	private int num;

	public Book(String name, int num) {
		this.name = name;
		this.num = num;
	}
}

Map接口遍历方式

1.containsKey：查找键是否存在
2.keySet：获取所有的键
3.entrySet：获取所有关系k-v
4.values：获取所有的值

Map map = new HashMap();
map.put("赵怀真",new Book("",100));
map.put("赵怀真","云缨");
map.put("关羽","刘备");
map.put("张飞","刘备");
map.put("诸葛亮",null);
map.put(null,"王昭君");
map.put("兰陵王","小乔");

//第一组 先取出 所有的Key ， 通过Key 取出对应的Value
System.out.println("===第一种方式===");
Set keyset = map.keySet();
//(1) 增强for
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();
//子类可以使用所有的Collection使用的遍历方法
//(1) 增强for
System.out.println("===取出所有的value 增强for===");
for (Object value : values) {
	System.out.println(value);
}
//(2)迭代器
System.out.println("===取出所有的value 迭代器===");
Iterator iterator1 = values.iterator();
while (iterator1.hasNext()) {
	Object value =  iterator1.next();
	System.out.println(value);
}

//第三组：通过EntrySet 来获取 k-v
Set entrySet = map.entrySet();
//(1) 增强for
System.out.println("----使用EntrySet的for增强(第三种)----");
for (Object entry : entrySet) {
	//将entry 转成 Map.Entry
	Map.Entry m = (Map.Entry) entry;
	System.out.println(m.getKey() + "-" + m.getValue());
}
//(2)迭代器
System.out.println("----使用EntrySet 的 迭代器----");
Iterator iterator2 = entrySet.iterator();
while (iterator2.hasNext()) {
	Object entry = iterator2.next();
	//System.out.println(next.getClass());//HashMap$Node -实现-》Map.Entry(getKey,getValue)
	//向下转型 Map.Entry
	Map.Entry m = (Map.Entry) entry;
	System.out.println(m.getKey() + "-" + m.getValue());

HashMap

HashMap小结
截屏2023-11-02 10.29.32.png
HashMap底层机制和源码剖析
截屏2023-11-02 10.31.40.png 截屏2023-11-02 10.33.03.png

Hashtable

基本介绍
1.存放的元素上键值对:即k-v
2.Hashtable的键和值都不能null，否则会抛出NullPointerException
3.Hashtable使用方法基本上和HashMap一样
4.Hashtable是线程安全的(synchronized),HashMap
是线程不安全的

Properties

1.Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据
2.他的使用特点和Hashtable类似
3.Properties还可以用于从xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改
4.说明：工作后，xxx.properties文件通常作为配置文件

TreeMap

//使用默认的构造器，创建TreeMap，斯无序也没有排序
//要求 按照传入的k(String) 的大小进行排序
TreeMap treeMap = new TreeMap(new Comparator() {
	@Override
	public int compare(Object o1, Object o2) {
		//按照传入的k(String) 的大小进行排序
		//return ((String) o1).compareTo((String) o2);
		//按照传入的 k(String)的大小进行排序
		return ((String) o1).length()-((String) o2).length();
	}
});
//TreeMap treeMap = new TreeMap();
treeMap.put("jack","杰克");
treeMap.put("tom","汤姆");
treeMap.put("kristina","克瑞斯提诺");
treeMap.put("smith","斯密斯");

System.out.println("treeMap=" + treeMap);

总结-开发中如何选择集合实现类

在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下：
1.先判断存储到类型(一组对象[单列]或一组键值对[双列])
(1)一组对象[单列]：Collection接口
允许重复：List
增删多：LinkList(底层维护了一个双向链表)
改查多：ArrayList(底层维护Object类型的可变数组)
不允许重复：set
无序：HashSet(底层是HashMap,维护了一个哈希表即(数组+链表+红黑树))
排序：TreeSet
插入和取出顺序一致：LinkedList，维护数组+双向链表
(2)一组键值对：Map
键无序：HashMap(底层是：哈希表 jdk7：数组+链表，jdk8:数组+链表+红黑树)
键排序：TreeMap
键插入和取出顺序一致：LinkedHashMap
读取文件 Properties

Collections工具类

介绍
1.Collections说一个操作Set、List和Map等集合的工具类
2.Collections中提供了一系列静态的方法对集合进行排序、查询和修改等操作

排序操作(均为static方法)
1.reverse(List)：反转List中元素的顺序
2.shuffle(List)：对List集合元素进行随机排序
3.sort(List)：根据元素的自然顺序对指定List集合元素按升序排序
4.sort(List,Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序
5.swap(List,int,int)：将指定List集合中的i处元素和j处元素进行交换

//创建ArrayList集合，进行测试
List list = new ArrayList();
list.add("tom");
list.add("smith");
list.add("king");
list.add("milan");
System.out.println(list);
//1.reverse(List)：反转List中元素的顺序
Collections.reverse(list);
System.out.println("list=" + list);
//2.shuffle(List)：对List集合元素进行随机排序
System.out.println("===五次随机排序===");
for (int i=0;i<5;i++){
	Collections.shuffle(list);
	System.out.println("list" + list);
}

//3.sort(List)：根据元素的自然顺序对指定List集合元素按升序排序
Collections.sort(list);
System.out.println("===自然排序后===");
System.out.println("list=" + list);
//4.sort(List,Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序
//按照字符串的长度大小排序
Collections.sort(list, new Comparator() {
	@Override
	public int compare(Object o1,Object o2){
		return ((String) o1).length()-((String) o2).length();
	}
});
System.out.println("字符串长度大小排序=" + list);
//5.swap(List,int,int)：将指定List集合中的i处元素和j处元素进行交换
Collections.swap(list,0,1);
System.out.println("交换后的情况");
System.out.println("list=" + list);

查找、替换
1.Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
2.Object max(Collectio,Comparator)：根据Comparator指定的顺序，返回给定集合中的最大元素
3.Object min(Collection)
4.Object min(Collection,Comparator)
5.int frequency(Collection,Object)：返回指定集合中指定元素的出现次数
6.void copy(List dest,List src)：将src中的内容复制到dest中
7.boolean replaceAll(List list,Object oldVal,Object newVal)：使用新值替换List对象的所有旧值

//1.Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
System.out.println("自然顺序的最大元素=" + Collections.max(list));
//2.Object max(Collectio,Comparator)：根据Comparator指定的顺序，返回给定集合中的最大元素
Collections.max(list, new Comparator() {
	@Override
	public int compare(Object o1, Object o2) {
		return ((String) o1).length()-((String) o2).length();
	}
});
//3.Object min(Collection)
//4.Object min(Collection,Comparator)
//5.int frequency(Collection,Object)：返回指定集合中指定元素的出现次数
System.out.println("tom出现的次数=" + Collections.frequency(list,"tom"));
//6.void copy(List dest,List src)：将src中的内容复制到dest中
ArrayList dest = new ArrayList();
//为了完成一个完整拷贝，我们需要先给dest赋值，大小和list.size()一样
for (int i = 0; i < list.size(); i++) {
	dest.add("");
}
Collections.copy(dest,list);
System.out.println("dest=" + dest);
//7.boolean replaceAll(List list,Object oldVal,Object newVal)：使用新值替换List对象的所有旧值
//如果list中，有tom 就替换成 汤姆
Collections.replaceAll(list,"tom","汤姆");
System.out.println("list替换后=" + list);
}