Java集合(个人学习笔记)

最新推荐文章于 2023-04-25 13:53:26 发布

Micek

最新推荐文章于 2023-04-25 13:53:26 发布

阅读量297

点赞数

分类专栏：学习笔记文章标签： java 开发语言经验分享

本文链接：https://blog.csdn.net/Gracener/article/details/121964521

版权

学习笔记专栏收录该内容

13 篇文章 1 订阅

订阅专栏

Java集合

数组和结合的区别

相同点

都是容器，可以存储多个数据

不同点

数组的长度是不可变的，集合的长度是可变的
数组可以存基本数据类型和引用类型；集合只能存引用数据类型，如果要存基本数据类型，需要存对应的包装类

集合类体系结构

在这里插入图片描述

Collection集合概述和使用

Collection集合概述

是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
JDK不提供此接口的任何直接实现，它提供更具体的子接口(如Set和List)实现

创建Collection集合的对象

多态的方式
具体的实现类ArrayList

Collection集合常用方法

Collection接口是List、Set和Queue接口的父接口，该接口里定义的方法既可用于操作Set集合，也可用于操作List和Queue集合。

方法名	说明
boolean add(Object o)	该方法用于向集合里添加一个元素。如果集合对象被添加操作改变了，则返回true
boolean addAll(Collection c)	该方法把集合c里的所有元素添加到指定集合里。如果集合对象被添加操作改变了，则返回true
void clear()	清除集合里的所有元素，将集合长度变为0
boolean contains(Object o)	返回集合里是否包含指定元素
boolean containsAll(Collection c)	返回集合里是否包含集合c里的所有元素
boolean isEmpty()	返回集合是否为空。当集合长度为0时返回true，否则返回false
Iterator iterator()	返回一个Iterator对象，用于遍历集合里的元素
boolean remove(Object o)	删除集合中的指定元素o，当集合中包含了一个或多个元素o时，该方法只删除第一个符合条件的元素，该方法将返回true
boolean removeAll(Collection c)	从集合中删除集合c里包含的所有元素(相当于用调用该方法的集合减集合c)，如果删除了一个或一个以上的元素，则该方法返回true
boolean retainAll(Collection c)	从集合中删除集合c里不包含的元素(相当于把调用该方法的集合变成该集合和集合c的交集)，如果该操作改变了调用该方法的集合，则该方法返回true
int size()	该方法返回集合里元素的个数
Object[] toArray()	该方法把集合转换成一个数组，所有的集合元素变成对应的数组元素

依次访问集合里每一个元素的两个方式

使用Lambda表达式遍历集合

Java8为Iterator接口新增了一个forEach(Consumer action)默认方法，该方法所需参数的类型是一个函数式接口，而Iterable接口是Collection接口的父接口，因此Collection集合也可直接调用该方法。

public class 测试 {
public static void main(String[] args) {
	Collection book = new HashSet<>();
	book.add("轻量级JavaEE企业应用实战");
	book.add("疯狂Java讲义");
	book.add("疯狂Android讲义");
	// 调用forEach()方法遍历集合
	book.forEach(Obj -> System.out.println("迭代集合元素:"+Obj));
	}
}


迭代集合元素:轻量级JavaEE企业应用实战
迭代集合元素:疯狂Android讲义
迭代集合元素:疯狂Java讲义

使用Java8增强的Iterator遍历集合元素

Iterator则主要用于遍历(即迭代访问)Collection集合中的元素，Iterator对象也被称为迭代器

boolean hasNext(): 如果被迭代的集合元素还没有被遍历完，则返回true
Object next(): 返回集合里的下一个元素
void remove(): 删除集合里上一次next方法返回的元素
void forEachRemaining(Consumer action)，这是Java8为Iterator新增的默认方法，该方法可以使用Lambda表达式来遍历集合元素

public class 测试 {
	public static void main(String[] args) {
		Collection books = new HashSet<>();
		books.add("轻量级JavaEE企业应用实战");
		books.add("疯狂Java讲义");
		books.add("疯狂Android讲义");
		// 获取books集合对应的迭代器
		Iterator iterator = books.iterator();
		while (iterator.hasNext()) {
			// iterator.next()方法返回的数据类型是Object类型，因此需要强转类型转换
			String book = (String) iterator.next();
			System.out.println(book);
			if (book.equals("疯狂Java讲义")) {
				// 从集合中删除上一次next()方法返回的元素
				iterator.remove();
			}
			// 对book变量赋值，不会改变集合元素本身
			book = "测试字符串";

		}
		System.out.println(books);
	}
}

轻量级JavaEE企业应用实战
疯狂Android讲义
疯狂Java讲义
[轻量级JavaEE企业应用实战, 疯狂Android讲义]

当使用Iterator迭代访问Collection集合元素时，Collection集合里的元素不能被改变，只有通过Iterator的remove()方法删除上一次next()方法返回的集合元素才可以；否则将会引发java.util.ConcurrentModificationException异常

List集合的概述和特点

List集合的概述

有序集合，这里的有序指的是存取顺序
用户可以精确控制列表中每个元素的插入位置，用户可以通过整数索引访问元素，并搜索列表中的元素
与Set集合不同，列表通常允许重复的元素

List集合的特点

存取有序
可以重复
有索引

List集合特有的方法

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get (int index)	返回指定索引处的元素

List集合的实现类

ArrayList集合

底层是数据结构实现，查询快，增删慢

LinkedList集合

底层是链表结构实现，查询慢，增删快

LinkedList集合的特有功能

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

Set集合

它类似于一个罐子，程序可以依次把多个对象“丢进”Set集合，而Set集合通常不能记住元素的添加顺序。

Set集合不允许包含相同的元素，如果试图把两个相同的元素加入同一个Set集合中，则添加操作失败，add()方法返回false，且新元素不会被加入

HashSet类

哈希值：

哈希值简介

是JDk根据对象的地址或者字符串或者数字算出来的int类型的数值
如何获取哈希值

Object类中的public int hashCode():返回对象的哈希码值
哈希值的特点
1. 同一对象多次调用hashCode()方法返回的哈希值是相同的
2. 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

HashSet类的特点：

不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。
HashSet不是同步的，如果多个线程同时访问一个HashSet，假设有两个或者两个以上线程同时修改了HashSet集合时，则必须通过代码来保证其同步。
集合元素值可以是null

在这里插入图片描述

如果需要把某个类的对象保存到HashSet集合中，重写这个类的equals()方法和hashCode()方法时，应该尽量保证两个对象通过equals()方法比较返回true时，它们的hashCode()方法返回值也相等。

请添加图片描述

HashSet中每个能存储元素的“槽位”通常被称为"桶"，如果有多个元素的hashCode值相同，但他们通过equals()方法比较返回false，就需要在一个"桶"里放多个元素，这样会导致性能下降。

在这里插入图片描述

重写hashCode()方法的基本原则

在程序运行过程中，同一个对象多次调用hashCode()方法应该返回相同的值
当两个对象通过equals()方法比较返回true时，这两个对象的hashCode()方法应返回相等的值
对象中用作equals()方法比较标准的实例变量，都应该用于计算hashCode值

在这里插入图片描述

LinkedHashSet类

LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。也就是说，当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。

TreeSet类

TreeSet集合概述和特点

不可以存储重复元素
没有索引
可以将元素按照规则进行排序
1. TreeSet(): 根据其元素的自然排序进行排序
2. TreeSet(Comparator comparator): 根据指定的比较器进行排序

在这里插入图片描述

TreeSet并不是根据元素的插入顺序进行排序的，而是根据元素实际值的大小来进行排序的。

与HashSet集合采用hash算法来决定元素的存储位置不同，TreeSet采用红黑树的数据结构来存储集合元素。TreeSet支持两种排序方法：自然排序和定制排序

自然排序

TreeSet会调用集合元素的compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序排序，这种方式就是自然排序。

在这里插入图片描述

还有一点需要指出：大部分类在实现compareTo(Object obj) 方法时，都需要将被比较对象obj强制类型转换成相同类型，因为只有相同类的两个实例才会比较大小。当试图把一个对象添加到TreeSet集合时，TreeSet会调用该对象的compareTo(Object obj)与集合中的其他元素进行比较----这就要求集合中的其他元素与该元素是同一类的实例。也就是说，向TreeSet中添加的应该是同一个类的对象，否则也会引发ClassCastException异常。

总结：如果希望TreeSet能正常运作，TreeSet只能添加同一种类型的对象

对于TreeSet集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj)方法比较是否返回0—如果通过compareTo(Object obj) 方法比较返回0，TreeSet则会认为它们相等；否则就认为它们不相等。

由此应该注意一个问题：当需要把对象放入TreeSet中，重写该对象对应类的equals()方法时，应保证该方法与compareTo(Object obj)方法有一致的结果，其规则是：如果两个对象通过equals()方法比较返回true时，两个对象通过compareTo(Object obj) 方法比较应返回0。如果两个对象通过compareTo(Object obj)方法比较返回0时，但它们通过equals()方法比较返回false将会很麻烦，因为两个对象通过compareTo(Object obj)方法比较相等，TreeSet不会让第二个元素添加进去，这将会与Set集合的规则产生冲突

定制排序

TreeSet的自然排序是根据集合元素的大小，TreeSet将它们以升序排列。如果需要实现定制排序，例如以降序排列，则可以通过Comparator接口的帮助。该接口包含一个int compare(T o1, T o2) 方法，该方法用于比较o1和o2的大小：如果该方法返回正整数，则表明o1大于o2，如果该方法返回0时，则表示o1等于o2.如果该方法返回负整数，则表明o1小于o2.

！！！注意：TreeSet判断两个集合元素相等的标准是：通过Comparator(或Lambda表达式)比较两个元素返回了0，这样TreeSet不会把第二个元素添加到集合中。

EnumSet类

这是一个专为枚举类设计的集合类，EnumSet中的所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式或隐式地指定。EnumSet的集合元素也是有序的，EnumSet以枚举值在Enum类内的定义顺序来决定集合元素的顺序。

EnumSet在内部以位向量的形式存储，这种存储形式紧凑、高效。因此EnumSet对象占用内存很小，而且运行效率很好。
EnumSet集合不允许加入null元素，如果试图插入null元素，EnumSet将抛出NullPointerException异常。如果只是想判断EnumSet是否包含null元素或者尝试删除null元素都不会抛出异常，只是删除操作将返回false，因为没有任何null元素被删除。

如何使用EnumSet来保存枚举类的多个枚举值：

import java.util.EnumSet;

enum Season
{
    SPRING,SUMMER,FALL,WINTER;

}
public class EnumSetTest
{
    public static void main(String[] args)
    {
        //创建一个EnumSet集合，集合元素就是Season枚举类的全部枚举值
        EnumSet  es1 =EnumSet.allOf(Season.class);

        System.out.println(es1);//输出[SPRING,SUMMER,FALL,WINTER]
        //创建一个EnumSet空集合，指定集合元素是Season类的枚举值
        EnumSet es2 = EnumSet.noneOf(Season.class);
        System.out.println(es2);//输出[]
        //手动添加两个元素
        es2.add(Season.WINTER);
        es2.add(Season.FALL);
        System.out.println(es2);//输出[WINTER,FALL]
        //以指定枚举值创建EnumSet集合
        EnumSet  es3 = EnumSet.of(Season.WINTER,Season.FALL);
        System.out.println(es3);//输出[WINTER,FALL]
    }
}

注意！！当试图复制一个Collection集合里的元素来创建EnumSet集合时，必须保证Collection集合里的所有元素都是同一个枚举类的枚举值。

各Set实现类的性能分析

HashSet和TreeSet是Set的两个典型实现

到底该选择HashSet还是TreeSet呢？

HashSet的性能总是比TreeSet好(特别是最常用的添加、查询元素等操作)，因为TreeSet需要额外的红黑树算法来维护集合元素的次序。

什么时候选择TreeSet？

只有当需要一个保持排序的Set时，才应该使用TreeSet，否则都应该使用HashSet。
LinkedHashSet

对于普通的插入、删除操作，LinkedHashSet比HashSet要略微慢一点，这是由维护链表所带来的额外开销造成的，但由于有了链表，遍历LinkedHashSet会更快。

EnumSet

它是所有Set实现类中性能最好的，但它只能保存同一个枚举类的枚举值作为集合元素。

必须指出的是，Set的三个实现类HashSet、TreeSet和EnumSet都是线程不安全的，如果有多个线程同时访问一个Set集合，而且有超过一个线程修改了该Set集合，则必须手动保证该Set集合的同步性。通常可以通过Collection工具类的synchronizedSortedSet方法来"包装"该Set集合。这个操作最好在创建时进行，以防止对Set集合的意外非同步访问。

分析并发编程之Set集合的线程安全

Set的三个子类分别是：HaseSet、TreeSet、LinkedHashSet.这三个都是线程不安全的。那么这三个子类的底层是什么？

HashSet的底层是HashMap
TreeSet的底层是TreeMap
LinkedHashSet的底层是LinkedHashMap

Set添加的时候只有一个参数怎么做到的？

因为Set的三个子类底层都是Map。Map是以key-value键值对出现的，我们也知道Set添加方法是set.add(“xxx”)。参数只有一个，不是键值对，那么底层Map是怎么存储的呢？

add方法的源码:

public boolean add(E e)
{
    return map.put(e,PRESENT) == null;
}

PRESENT又是什么呢？

private static final Object PRESEMT = new Object();

只不过Value被写死了，是一个private static final Object对象。

Set为什么不能存放重复值，而list就可以了呢？

从上面add的源码中，我们可以看出，add的数据是作为map的key来存放的。在Map中，Key是不能重复的。所以，set里面的数据不能有重复的。

Set集合怎么实现线程安全？

方案一：
和list一样，使用Colletcions这个工具类syn方法类创建个线程安全的set.

Set<String> synSet = Collections.synchronizedSet(new HashSet<>());

方案二：
使用JUC包里面的CopyOnWriteArraySet

Set<String> copySet = new CopyOnWriteArraySet<>();

List集合

List集合代表一个元素有序、可重复的集合，集合中每个元素都有对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。

List接口和ListIterator接口

List集合增加了一些根据索引来操作集合元素的方法

方法名	说明
void add(int index,Object element)	将元素element插入到List集合的index处
boolean addAll(int index,Collection c)	将集合c所包含的所有元素都插入到List集合的index处
Object get(int index)	返回集合index索引处的元素
int indexOf(Object o)	返回对象o在List集合中第一次出现的位置索引
int lastIndexOf(Object o)	返回对象o在List集合中最后一次出现的位置索引
Object remove(int index)	删除并返回index索引处的元素
Object set(int index,Object element)	将index索引处的元素替换成element对象，返回被替换的旧元素
List subList(int fromIndex,int toIndex)	返回从索引fromIndex(包含)到索引toIndex(不包含)处所有集合元素组成的子集合
void replaceAll(UnaryOperator operator)	根据operator指定的计算规则重新设置List集合的所有元素
void sort(Comparator c)	根据Comparator参数对List集合的元素排序

List判断两个对象相等的标准是什么呢？List判断两个对象相等只要通过equals()方法比较返回true即可

import java.util.ArrayList;
import java.util.List;

public class ListTest {
	public static void main(String[] args) {
		List books = new ArrayList();
		// 向books集合添加三个元素
		books.add(new String("轻量级Java EE企业应用实战"));
		books.add(new String("疯狂Java讲义"));
		books.add(new String("疯狂Android讲义"));
		System.out.println(books);

		// 删除集合中的A对象，将导致第一个元素被删除
		books.remove(new A());
		System.out.println(books);
		// 删除集合中的A对象，再次删除集合中的第一个元素
		books.remove(new A());
		System.out.println(books);
	}
}

class A {
	public boolean equals(Object obj) {
		return true;

	}
}


[轻量级Java EE企业应用实战, 疯狂Java讲义, 疯狂Android讲义]
[疯狂Java讲义, 疯狂Android讲义]
[疯狂Android讲义]

从结果可以看出，执行删除A对象时，List将会调用该A对象的equals()方法依次与集合元素进行比较，如果该equals()方法以某个集合元素作为参数时返回true，List将会删除该元素—A类重写了equals()方法，该方法总是返回true。所以每次从List集合中删除A对象时，总是删除List集合中的第一个元素。

ArrayList和Vector实现类

ArrayList和Vector类都是基于数组实现的List类，所以ArrayList和Vector类封装了一个动态的、允许再分配的Object[] 数组。ArrayList或Vector对象使用initialCapacity参数来设置该数组的长度，当向ArrayList或Vector中添加元素超出了该数组的长度时，它们的initialCapacity会自动增加。

但如果向ArrayList或Vector集合中添加大量元素时，可使用ensureCapacity(int minCapacity) 方法一次性地增加initialCapacity。这可以减少重分配的次数，从而提高性能。

如果创建空的 ArrayList或Vector集合时不指定initialCapacity参数，则Object[] 数组的长度默认为10

ArrayList和Vector还提供了如下两种方法来重新分配object[] 数组

方法名	说明
void ensureCapacity(int minCapacity)	将ArrayList或Vector集合的object[] 数组长度增加大于或等于minCapacity值。
void trimToSize()	调整ArrayList或Vector集合的Object[] 数组长度为当前元素的个数。调用该方法可减少ArrayList或Vector集合对象占用的存储空间

ArrayList和Vector的显著区别：

ArrayList是线程不安全的，当多个线程访问同一个ArrayList集合时，如果有超过一个线程修改了ArrayList集合，则程序必须手动保证该集合的同步性；
Vector集合则是线程安全的，无须程序保证该集合的同步性。所以Vector比ArrayList的性能要低。
实际上，即使需要保证List集合的线程安全，也同样不推荐使用Vector实现类。Collection工具类可以将一个ArrayList变成线程安全的。

固定长度的List

有一个操作数组的工具类：Arrays。该工具类提供了asList(Object… a)方法，该方法可以把一个数组或指定个数的对象换成一个List集合

这个List集合既不是ArrayList实现类的实例，也不是Vector实现类的实例，而是Arrays的内部类ArrayList的实例。

Arrays.ArrayList是一个固定长度的List集合，程序只能遍历访问该集合里的元素，不可增加、删除该集合里的元素。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListTest {
	public static void main(String[] args) {
		
		List fixedList = Arrays.asList("疯狂Java讲义","轻量级Java EE企业应用实战");
		
		// 获取fixedList的实现类，将输出class java.util.Arrays$ArrayList
		System.out.println(fixedList.getClass());
		
		// 使用方法引用遍历集合元素
		fixedList.forEach(System.out::println);
		
		// 试图增加、删除元素都会引发UnsupportedOperationException异常
		fixedList.add("疯狂Android讲义");
		fixedList.remove("疯狂Java讲义");
	}

}


class java.util.Arrays$ArrayList
疯狂Java讲义
轻量级Java EE企业应用实战
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.add(AbstractList.java:148)
	at java.util.AbstractList.add(AbstractList.java:108)
	at com.wangshidai.ListTest.main(ListTest.java:19)

LinkedList实现类

LinkedList是List接口的实现类----这意味着它是一个List集合，可以根据索引来随机访问集合中的元素。

以及可以被当成"栈"来使用，也可以当成队列使用

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Set;

public class ListTest {
	public static void main(String[] args) {

		LinkedList books = new LinkedList();

		// 将字符串元素加入队列的尾部
		books.offer("疯狂Java讲义");
		// 将一个字符串元素加入栈的顶部
		books.push("轻量级JavaEE企业应用实战");
		// 将字符串元素添加到队列的头部(相当于栈的顶部)
		books.offerFirst("疯狂Android讲义");

		for (int i = 0; i < books.size(); i++) {
			System.out.println("遍历中:" + books.get(i));
		}

		// 访问并不删除栈顶的元素
		System.out.println("访问并不删除栈顶的元素:" + books.peekFirst());
		// 访问并不删除队列的最后一个元素
		System.out.println("访问并不删除队列的最后一个元素:" + books.peekLast());
		// 将栈顶的元素弹出"栈"
		System.out.println("将栈顶的元素弹出\"栈\":" + books.pop());
		// 下面输出将看到队列中第一个元素被删除
		System.out.println("下面输出将看到队列中第一个元素被删除:" + books);
		// 访问并删除队列的最后一个元素
		System.out.println("访问并删除队列的最后一个元素:" + books.pollLast());
		System.out.println(books);
	}

}

遍历中:疯狂Android讲义
遍历中:轻量级JavaEE企业应用实战
遍历中:疯狂Java讲义
访问并不删除栈顶的元素:疯狂Android讲义
访问并不删除队列的最后一个元素:疯狂Java讲义
将栈顶的元素弹出"栈":疯狂Android讲义
下面输出将看到队列中第一个元素被删除:[轻量级JavaEE企业应用实战, 疯狂Java讲义]
访问并删除队列的最后一个元素:疯狂Java讲义
[轻量级JavaEE企业应用实战]

上面的代码示范了LinkedList作为List集合、双端队列、栈的用法。

LinkedList与ArrayList的实现机制完全不同，ArrayList内部以数组的形式来保存集合中的元素，因此随机访问集合元素时有较好的性能；而LinkedList内部以链表的形式来保存集合中的元素，因此随机访问集合元素时性能较差，但在插入、删除元素时性能比较出色(只需改变指针所指的地址即可)

各种线性表的性能分析

一般来说，由于数组以一块连续内存区来保存所有的数组元素，所以数组在随机访问时性能最好，所有的内部以数组作为底层实现的集合在随机访问时性能都比较好；而内部以链表作为底层实现的集合在执行插入、删除操作时有较好的性能。但总体来说，ArrayList的性能比LinkedList的性能要好，因此大部分时候都应该考虑使用ArrayList。

关于使用List集合有以下建议

如果需要遍历List集合元素，对于ArrayList、Vector集合，应该使用随机访问方法(get)来遍历集合元素，这样性能更好；对于LinkedList集合，则应该采用迭代器(Iterator)来遍历集合元素。
如果需要经常执行插入、删除操作来改变包含大量数据的List集合的大小，可考虑使用LinkedList集合。使用ArrayList、Vector集合可能需要经常重新分配内部数组的大小，效果可能比较差。
如果有多个线程需要同时访问List集合中的元素，开发者可考虑使用Collection将集合包装成线程安全的集合

Map集合

Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value，key和value都可以是任何引用类型的数据。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较总是返回false。

操作集合的工具类:Collection

Java提供了一个操作Set、List和Map等集合的工具类:Collection，该工具类里提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了将集合对象设置为不可变、对集合对象实现同步控制等。

排序操作

方法名	说明
void reverse(List list)	反转指定List集合中元素的顺序
void shuffle(List list)	对List集合元素进行随机排序(shuffle方法模拟了"洗牌"动作)
void sort(List list)	根据元素的自然顺序对指定List集合的元素按升序进行排序
void sort(List list, Comparator c)	根据指定Comparator产生的顺序对List集合元素进行排序
void swap(List list, int i ,int j)	将指定List集合中的i处元素和j处元素进行交换
void rotate(List list,int distance)	当distance为正数时，将list集合的后distance个元素"整体"移到前面；当distance为负数时，将list集合的前distance个元素"整体"移到后面。该方法不会改变集合的长度

查找、替换操作

方法名	说明
int binarySearch(List list,Object key)	使用二分搜索法搜索指定的List集合，以获得指定对象在List集合中的索引，如果要使该方法可以正常工作，则必须保证List中的元素已经处于有序状态
Object max(Collection coll)	根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection coll,Comparator comp)	根据Comparator指定的顺序，返回给定集合中的最大元素
Object min(Collection coll)	根据元素的自然顺序，返回给定集合中的最小元素
Object min(Collection coll,Comparator comp)	根据Comparator指定的顺序，返回给定集合中的最小元素
void fill(List list,Object obj)	使用指定元素obj替换指定List集合中的所有元素
int frequency(Collection c,Object o)	返回指定集合中指定元素的出现次数
int indexOfSubList(List source,List target)	返回子List对象在父List对象中第一次出现的位置索引；如果父List中没有出现这样的子List，则返回-1
int lastIndexOfSubList(List source,List target)	返回子List对象在父List对象中最后一次出现的位置索引；如果父List中没有出现这样的子List，则返回-1
boolean replaceAll(List list,Object oldVal,Object newVal)	使用一个新值newVal 替换List对象的所有旧值oldVal