java基础之集合

一．  集合的简介

1.   集合出现的原因

        Java是面向对象的语言，我们的程序中会出现各种各样的对象，为了方便管理这些对象，就出现了集合，集合是存储对象的容器，我们可以把对象放到集合中，然后利用集合的方法对这些对象进行操作。我们可以理解成集合就是管理对象的对象。

2.   集合的框架

        每一种集合都可以看做是一个容器，这个容器中按什么标准（数据结构）来存放对象是我们要明确的，不能一个集合中什么样的对象都能往里面放，这样不利于我们的管理与操作，因此我们有了多种集合，于是就形成了一个框架。其大体的框架如下： 

        Collection是一个接口，他是集合中向上抽取而来的最终表现，里面是集合中的公有内容，List和Set是Collection下的两个子接口，List体系下的集合的都是有序、可重复的，而Set体系下的集合的都是则是无序不可重复的。他们下面又出现了不同的子类。

3. 集合和数组的异同

        相同点：集合和数组都是容器，都可以用来存储对象。

        不同点：①集合中存储的是只能是对象，数组可存放对象也可存放基本数据类型。

                        ②集合的长度是可变的，数组的长度不可变

二．  Collection接口常见方法

1. 添加

        1>  add(Object obj)

        返回boolean型，添加一个对象，成功返回true，否则返回false。

        2>  addAll(Collection coll)

        返回boolean型，添加一个集合

2. 删除

        1>  remove(Object obj)

        无返回值，删除指定对象

        2>  clear()

        返回boolean型，清空集合，删除全部。

        3>  removeAll(Collection coll)

        返回boolean型，删除与指定集合coll中相同的元素

3.判断

返回类型为boolean型

        1>  contains(Object obj)

        判断集合中是否有此对象

        2>ntainsAll(Collection coll)

        判断集合中是否包含指定的集合coll中的所有元素。

4.获取

        1>  retainAll(Collection coll)

        返回boolean型，此方法是获取当前集合与指定集合中的相同元素，也就是取两个集合的交集。

        2>  size()

        返回int类型，获取此集合有多少元素。

        3>  iterator()

        返回一个Iterator对象，获取集合的迭代器。

        此方法需要重点掌握，我们要把集合中的元素取出来，java把取出的这个方式看做一个对象，这个对象有两个动作：判断和取出，这个取出方式定义在集合的内部，这样他就可以直接访问集合中的内部元素，所以取出方式就被定义成为了一个内部类，而每一种集合的数据结构都不相同，所以取出方式也不相同，但把他们的共性内容抽取出来之后就形成了一个Iterator接口。而iterator()方法则会把这个集合内部的取出对象返回给调用者。

        在每一个集合的内部取出类中都有两个重要方法，hasNext()和next();hasNext()用来判断是否还有对象可以迭代，也就是判断集合中是否还有元素可以取出，next()方法则是取出元素，注意如果集合中没有元素了，调用next()方法会报出无元素异常：NoSuchElementException。示例：

class Test1{public static void main(String[] args){//创建一个ArrayList()实例Collection coll = new ArrayList();coll.add(1);coll.add(2);coll.add(4);//获取此实例中的迭代器对象Iterator it =  coll.iterator();//hasNext()判断是否有元素可以迭代while(it.hasNext()){//获取元素System.out.print(it.next()+" ");//打印1 2 4 }}}

三．  List集合

1.   List集合的特点

List集合是有序的集合，并且元素可以重复，其原因就是List集合体系中有索引。

2.   List集合中的常见特有方法

（1）    增加

        1>add(int index,Object obj)

        在指定位置添加元素

        2>add(int index,Collection coll)

        在指定位置添加指定的集合

（2）    删除

        1>  remove(int index)

        返回被删除的元素，删除指定位置index上的元素

（3）    修改

        1>set(int index,Object obj)

        用指定元素替换指定位置上的元素

（4）    查找

        1>subList(int fromIndex,int toIndex)

        返回List集合，返回该集合中从fromIndex开始一直到toIndex-1这部分集合，包头不包尾。

        2>lastIndexOf(Object obj)

        返回int，获得该集合列表中指定元素obj最后一次出现的位置。

        3>indexOf(Objectobj)

        返回int，获得该集合列表中指定元素obj第一次出现的位置。

        4>get(int index)

        返回对象，获得指定位置上的元素，我们可以利用此方法来取出List集合中的元素。

（5）List集合中特有的迭代器

        ListIterator()

        返回ListIterator迭代器，这个迭代器是List集合中特有的，可以从我们指定的位置来获取迭代元素。而且这个迭代器还可以对元素有多种操作。

        当我们使用iterator取出集合中的元素时，我们是不可以利用集合的方法对取出的元素进行增删操作的，如果操作会抛出一个对对象进行并发修改的异常：ConcurrentModificationException。例：

public class Test1 {public static void main(String[] args) {//创建一个ArrayList()实例List coll = new ArrayList();coll.add(1);coll.add(2);coll.add(4);//利用iterator方法获取此实例中的迭代器Iterator it =  coll.iterator();//hasNext()判断是否有元素可以迭代while(it.hasNext()){//如果迭代的元素为1，那么删除这个元素if(it.next().equals(1))//利用集合的方法增加元素,这时会抛出异常coll.add(10);}System.out.println(coll);}}

        此示例会抛出异常，因为我们在迭代时，如果利用集合的方法对集合进行增删操作，那么迭代器就会郁闷，你要是增删了，集合的长度就变了，迭代器的世界观就崩溃了，也就是说在迭代的时候是迭代器在操作集合中的元素，不允许通过集合的方法并发修改。那么怎么办，在迭代时集合的方法不能够去操作元素，那么迭代器可以么，Iterator的确给我们提供了一个删除的方法，但是人们觉得不够，由此就出现了一个新的迭代器：ListIterator，这个迭代器不仅可以判断、取出、删除，还可以添加、修改等等。例：

class ListIter{public static void main(String[] args) {// 创建一个ArrayList()实例List coll = new ArrayList();coll.add("小宏");coll.add("小绿");coll.add("小蓝");//利用listIterator方法获取此实例中的迭代器ListIterator it =  coll.listIterator();//hasNext()判断是否有元素可以迭代while(it.hasNext()){Object obj = it.next();//如果迭代的元素为“小宏”，那么删除这个元素if("小宏".equals(obj))//利用集合的方法删除0位置上的元素it.remove();//如果迭代的元素为“小绿”，那么添加一个元素“小花”if("小绿".equals(obj))it.add("小花");//如果迭代元素为“小蓝”，那么把小蓝替换成“小黑”if("小蓝".equals(obj))it.set("小黑");}System.out.println(coll);//打印内容为：[小绿, 小花, 小黑]}}

另外ListIterator迭代器还提供了previous和hasParevious()方法。

hasParevious()是逆向遍历集合，和hasNext()相反。

previous()是返回上一个元素，与next()相反。

3.   List集合中常用子类

（1）    ArrayList

        1>ArrayList存储对象使用的数据机构：数组

        2>特点：利用ArrayList管理对象的特点是查询修改快，增加、删除慢。

（2）    LinkedList

        1>LinkedList使用的数据结构：链表数据结构，就是后一个元素记住前一个元素，形成一个链表。

        2>  特点：查询修改慢，增加删除快，因为链表数据结构中各个对象在堆内存中不是使用的同一片空间。

        3>  LinkedList的特有方法

                a>  addFirst(Object obj)

                无返回值，添加指定元素到集合开头

                b>  addLast(Object obj)

                无返回值，添加指定元素到集合结尾

                c>  removeFirst()

                删除并返回此集合第一个元素，不光删还取，如果集合为空会报出无此元素异常：NoSuchElementException

                d>  removeLast()

                删除并返回此集合最后一个元素，如果集合为空会报出无此元素异常：NoSuchElementException

                e>  getFirst()

                返回集合中第一个元素，如果集合为空会报出无此元素异常：NoSuchElementException

                f>  getLast()

                返回集合中最后一个元素，如果集合为空会报出无此元素异常：NoSuchElementException

        在JDK1.6版本后出现了替代方法

                a>  offerFistr(Object obj)

                返回boolean型，添加指定元素到集合开头

                b>  offerLast(Object obj)

                返回boolean型，添加指定元素到集合的结尾

                c>  peekFirst()

                返回此集合中第一个元素，获取不删除，如果集合中无元素，返回null

                d>  peekLast()

                返回此集合中最后一个元素，获取不删除，如果集合中无元素，返回null

                e>  pollFirst()

                获取并移除第一个元素，如果此集合为空那么返回null

                f>  pollLast()

                获取并删除此集合最后一个元素，如果集合为空那么返回null

（3）    Vector

        1>Vector使用的数据结构：数组

        Vector和ArrayList的数据结构一样，而且Vector的出现比ArrayList要早，也就是说ArrayList替代了Vector，我们来看一看他们之间的区别。

                a>  ArrayList是线程非同步的，而Vector是线程同步的，类同StringBuffer和StringBuilder的关系，在使用集合时我们一般不使用Vector，因为无论是查询还是增删Vector都很慢，也就是Vector也是不常用类。

                b>  ArrayList和Vector都是可变长度，初始长度都为10。不同点是当ArrayList中存满之后，会new一个新的ArrayList，长度增加50%，变为15，然后把原来的元素复制到新的集合中，而Vector存满之后会100%延长，长度变为20。

        2>Vector当中的特有方法：枚举

枚举和迭代器的实现是一样的，但是枚举的名称过长，为了简化书写，就利用迭代器替代了枚举。

public class VectorDemo {public static void main(String[] args) {// 创建一个Vector()实例Vector v = new Vector();v.add("小宏");v.add("小绿");v.add("小蓝");//利用Vector的elements方法获取枚举实例Enumeration e = v.elements();//hasMoreElements()判断是否有元素可以迭代while(e.hasMoreElements()){//利用枚举实例的nextElement()方法获取元素System.out.println(e.nextElement());}}}/*打印： * 小宏小绿小蓝 * */

4.   List集合判断元素是否相同的细节

        在List集合中当我们调用contains(Object obj)和remove(Object obj)这两个方法时，其底层调用的是对象的equals(Object obj)方法，所以如果我们要判断此集合中是否含有某对象，或者要删除某对象时一定要复写对象的equals方法，否则他比较的是对象的地址值，而不是我们想要比较的内容。

四．  Set集合

1. Set集合体系的特点

        Set集合与List不同点在于他没有索引，所以这个体系中元素是无序的而且不可重复，注意这个无序是指取出顺序和存入顺序不保证一致。Set集合的功能与Collection接口提供的功能一致。其常见子类有两个：TreeSet和HashSet。在Set集合中我们重点讲一讲他是怎样保证元素的唯一性。

2.   HashSet类

（1）    HashSet集合的数据结构

        HashSet集合的数据结构是哈希表，也就是说我们往HashSet中存放对象时是按照对象的哈希值进行存储的，所以我们往外取得顺序是按照哈希值排列后的顺序，这也是为什么我们的存入顺序和取出顺序可能不同的原因所在。

        HashSet中具体是怎么样来存储数据的？我们知道Object类中有一个hashCode()方法是所有的类都会继承的方法，此方法会计算出对象的哈希值，而HashSet底层用来存放数据的结构还是数组，但是此集合会将元素的哈希值与数组长度取模，这个模值就是此元素要放在数组中的位置（下标），这样做的好处在于元素存放的位置是通过计算得出的，如果我们要查询这个元素的位置，只需要通过这个算法来计算就可以得到他的位置，不需要遍历整个数组。这样极大的提高了效率。

        当我们自定义一个类时，一般都会复写hashCode()方法，让他按我们想要的内容来计算哈希值，注意点是一旦我们复写了hashCode()方法，那么我们用来参与计算哈希值的内容就不要更改了，如果更改，我们就在HashSet集合中找不到这个对象了。

（2）    HashSet中保证数据唯一的做法

        我们往HashSet集合中存放对象，如果一个对象和HashSet中的某一个对象的哈希值相同，那么会再去判断这两个对象是否是同一个对象，如果不是同一个对象则会同一个哈希值地址上顺延，也就是一个哈希值可能会对应多个对象。

        判断对象哈希值是否相同的方式是调用对象的HashCode()方法，判断对象是否相同是调用对象的equals()方法来判断。所以我们往HashCode中存放对象时，存放的对象一般都需要复写HashCode()和equals()方法，这两个方法是保证HashSet集合唯一性的原因。在HashSet中contains(Object o)和remove(Object o)都需要调用这两个方法来判断对象。例：

//自定义类Studentclass Student{private String name;private int age;Student(String name,int age){this.name = name;this.age = age;}//复写hashCode()方法public int hashCode() {//验证是否调用hashCode()方法System.out.println(this+"...hashCode方法运行");//为了保证哈希值重复的概率减小，我们让年龄乘33return name.hashCode()+age*33;}//复写equals方法public boolean equals(Object obj) {//验证是否调用equals方法System.out.println(this+"...equals..."+obj);//如果Obj不是Student类型的if(!(obj instanceof Student))return false;//如果传入对象和当前对象地址相同代表是同一个对象if (this == obj)return true;//向下转型,判断姓名和年龄来区分是否是同一对象Student s = (Student) obj;if(name.equals(s.name)&&age == s.age)return true;return false;}//复写toString()方法是为了显示方便public String toString() {return  name + ":" + age ;}}class SetDemo {public static void main(String[] args) {// 新建一个HashSet集合实例HashSet hs = new HashSet();hs.add(new Student("小宏",22));hs.add(new Student("小绿",21));hs.add(new Student("小宏",21));hs.add(new Student("小绿",21));System.out.println(hs);}}/*打印： * 小宏:22...hashCode方法运行小绿:21...hashCode方法运行小宏:21...hashCode方法运行小绿:21...hashCode方法运行小绿:21...equals...小绿:21[小绿:21, 小宏:21, x, 小宏:22] * */

（3）    LinkedHashSet类

        HashSet类是无序且不可重复的，在此之上，java又给我们提供了一个类LinkedHashSet，这个类不仅可以保证元素的唯一性而且他还是有序的。他的原理就是哈希表和链表的双重使用，哈希表保证了唯一，而链表提供了顺序。

3.   TreeSet类

（1）    TreeSet集合特点

        TreeSet的数据结构是二叉树，存入的数据会按自然顺序（例如字母表）排序，我们说的无序是指取出的顺序与存入的顺序不一致，而TreeSet集合时按照自然顺序进行排序的。

（2）   TreeSet集合添加元素

         当我们往TreeSet中添加多个自定义类对象时会报出类型转换异常：ClassCastException，因为TreeSet中的排序为自然排序，我们的对象必须具备可比较性。而怎么获得比较性呢，有两种方式。第一种为：实现Comparable接口，并复写这个接口中的compareTo(Object obj)方法，当compareTo方法返回0时，代表两个对象相同，所以我们要在自定义的compareTo方法中将我们想要区分的内容进行比较，相同返回0，不同则按需求返回正数或者负数。例：

//自定义类Person实现Compareble接口class Person implements Comparable{private String name;private int age;Person(String name,int age){this.name = name;this.age = age;}//复写compareTo方法public int compareTo(Object obj){//如果传入对象不是Person类型的，报错if(!(obj instanceof Person))throw new ClassCastException();//转型Person  p = (Person)obj;//自定义比较内容int num = p.age - this.age;//如果年龄相同，那么判断他们的名字是否相同return num==0?p.name.compareTo(this.name):num;}}

         第二种排序方式：定义比较器，让集合自身具备比较性，这种方式的出现时因为当元素自身不具备比较性或者他比较的方式不是我们所需要的时，我们让集合自身具有比较性，具体做法是首先定义一个类实现Comparator接口，然后复写compare方法，在方法中自定义我们要比较的内容。在我们初始化TreeSet时，把这个自定义类对象作为参数传递进去。

         首先自定义类实现Comparator接口，复写compare方法：

class Mycompare implements Comparator{//覆盖Compara方法public int compare(Object obj1,Object obj2){//return 比较的结果。}}

         然后将自定义类的对象作为参数初始化TreeSet集合：

         ThreeSet ts= new TreeSet(new Mycompare());

当这两种比较方式同时存在时，排序是按第二种方式进行的。

（3）    二叉树数据结构  

         当我们往一个集合添加元素时，每次使用add方法都会调用compareTo方法都会与集合中的已有元素比较来判断新加元素应该存放的位置，这样的效率十分慢，所以就有了二叉树的划分。

      二叉树就是将第一个存入元素作为中点，大于此元素放在右边，小于此元素放在左边，依次类推，这样每次存进来新的元素时，比较的次数就减少了。

当存入的元素多了之后，就不再是从第一个元素开始分界，而是取一个折中值，这种数据结构就是二叉树。

五.  泛型

1.泛型简介

      泛型是jdk1.5之后出现的新特性，用于解决安全问题，是一个安全机制。

      在泛型出现之前，我们要接收一个Object对象进来，要想知道这个对象具体是什么类型的，我们得先做一个健壮性判断（instanceOf）如果是，再进行强制转换，而泛型出现后，我们可以让指定类型的对象传入进来，只要你传入的对象不是我想要的类型，那么就会报错。

所以泛型的好处有两点：

      （1）    将运行时的错误转移到编译时期，大多都是类型转换异常。

      （2）    省略了强制转换的动作

2.泛型的格式

      通过 <类型名称>来定义类型

      例：ArrayList<Integer>al = new ArrayList<Integer>();

3.   泛型的使用场景

      当要操作的数据类型不确定时，就需要用到泛型，这时候我们只需要需要的数据类型传入<>中，就可以防止其他其他数据类型浑水摸鱼进来，也就是说我们要设一道关隘阻止非我们需要的数据类型传递进来。

      而且泛型大多用在集合框架中，只要看到<>，就要定义泛型，表示该容器在定义时就要明确装什么类型的元素，这样有利于我们后期的操作。

4.   自定义对象使用泛型

      （1）    当我们自定一个类，这个类具体要接收什么样的数据类型不确定，但是要确保传进来的是同一个数据类型，这时候我们可以使用泛型来达到效果。

      格式：class 类名<类型名称>

      在早期时，利用Object来完成扩展，但是需要强转，而且问题会在运行时才暴露，现在使用泛型来做，解决了这些弊端。

      （2）    泛型类中接收的数据类型对于整个类都有效，为了让不同的方法操作不同的类型，我们可以把泛型加载方法上，这样每个方法都可以操作不同类型的数据了。

      例：public <Integer>void show(Integer num)

      注意：<>必须写在修饰符后，返回类型前。

      （3）    静态方法使用泛型

      当我们在类上加泛型后，类中的静态方法是无法访问类中的泛型的，因为定义在类上的泛型是通过对象来明确的，静态方法是不可以访问对象的，这时如果静态方法访问不确定类型可以将泛型添加在静态方法上。

例：public static<E>void show(E t)

5.   泛型的限定

      （1）    我们先来说一说泛型中“？”的作用，？可以理解成通配符，也可以理解成占位符，代表任意类型。而泛型的限定有两种：

      第一种：限定上限

      <？extends E>代表可以接收E类型及E类型的子类型

      限定上限多用于对一个集合进行存储操作，我们必须要保证存入的元素是一个限定类的子类，这样我们取出的时候才能保证用这个上限类来接收其子类型。

      第二种：限定下限

      <? super E>代表可以接收E类型及E类型的父类型。

      使用下限的情况是当我们要对一个集合中的元素进行取出操作时，限定下限就可以保障取出元素的内容

      （2）泛型的限定为我们提供了接收一族类型的方式，以前我们使用泛型时不知道具体接收类型，但是真正接收的时候是必须指定一种类型的，限定则可以让我们接收一个继承体系中的各种类型。

六.   Map集合

1.   Map集合的框架体系

Map集合体系可以看做与Collection集合体系并列的集合，这个体系中的集合并不实现Collection接口，他的体系大体框架如下：

2.Map集合的特点

      Map集合中一次要添加的元素为一对，这两个元素存在映射关系，我们把一个称之为键Key，一个称之为值Value，也叫键值对。一个Map集合中键是唯一的，而一个键只能映射一个值，也就是Map集合必须要保证键的唯一性，因为我们是通过键来寻找值的，但是值的唯一性并不保障并且一个值可以被多个键映射。

3.Map集合的常见方法

（1）添加

      1>put(K key,V value)

      将指定的值与键相关联，返回以前与这个键相关联的值，如果没有返回null。注意value的值可以是null。

      2>putAll(Map<? extends K,?extends V>)

      将一个Map集合中的键值对复制到此Map集合中来，无返回值。

（2）删除

      1>clear()

      清空此Map集合，无返回值。

      2>remove(Object key)

      删除此集合中的键值对映射关系，返回此key键之前的值，没有返回null。

（3）判断

      1>  containsKey(Object obj)

      如果该键包含指定的映射关系返回true。

      2>  containsValue(Object value)

      如果此集合中将一个或多个键映射到指定的value值则返回true。

      3>  isEmpty()

      如果此集合中不包含键值对则返回true。

（4）获取

      1>get(Objectkey)

      返回指定键key可以映射的值，如果不包含映射关系则返回null。

      2>size()

      返回键值对的关系数

      3>values()

      返回此映射包含的值的Collection视图

      4>  keyset()

      返回此映射中包含的键的Set视图，可理解成返回包含所有键的一个Set集合，我们可以通过迭代这个Set集合拿到键，然后通过键拿到值。例：

class Test1 {public static void main(String[] args) {//初始化一个HashMap集合HashMap<Integer, String> hm = new HashMap<Integer, String>();//添加键值对hm.put(1, "小宏");hm.put(2, "小绿");//利用keySet()获取Map集合中的键,Set<Integer> s = hm.keySet();//迭代出键值for(Iterator<Integer> it = s.iterator();it.hasNext();){Integer i = it.next();System.out.println(i+":"+hm.get(i));}}}/* * 打印： * 1:小宏2:小绿 * */

      5>  entrySet()

      返回此映射中包含的映射关系的Set视图：Set<Map.Entry<K,V>>,也可以理解成返回一个包含映射关系的Set集合，就是这个Set集合里面装的是键值对：Map.Entry<K,V>；我们在Set集合中迭代出这个键值对，然后通过getKey()和getValue()来获取键和值。例：

public class MapDemo {public static void main(String[] args) {//初始化一个HashMap集合HashMap<Integer, String> hm = new HashMap<Integer, String>();//添加键值对hm.put(1, "小宏");hm.put(2, "小绿");//利用entrySet()获取Map集合中的键值对Set<Map.Entry<Integer,String>> s = hm.entrySet();//迭代出键值for(Iterator<Map.Entry<Integer,String>> it = s.iterator();it.hasNext();){Map.Entry<Integer,String> map = it.next();Integer key = map.getKey();//获取键String value = map.getValue();//获取值System.out.println(key+"..."+value);}/* * 打印： * 1...小宏2...小绿 * */}}

4.   Map集合的常见子类

（1）    HashTable

      1>  数据结构是哈希表数据结构

      2>  不可以存入null键或者null值

      3>  用作键的对象一般都会复写hashCode方法和equals方法

      4>  线程同步

（2）    HashMap

      1>  数据结构是哈希表

      2>  可以存入null值或者null键

      3>  用作键的对象一般都要复写hashCode和equals方法

      4>  线程不同步

（3）    TreeMap

      1>  数据结构是二叉树

      2>  可以存入null值或者null键

      3>  用作键的对象要具有可比较性。

      4>  线程不同步

（4）    LinkedHashMap

       数据结构是哈希表和链表综合，类同于LinkedHashSet，既可以具备唯一性又不改变存入的顺序。

七． 工具类

1.工具类简介

       java中为我们提供的了一些工具类，我们可以利用工具类来操作特定的对象，为我们编写程序提高效率。工具类中一般没有构造函数，只有静态方法，我们可以通过类名直接调用即可。介绍一下两个常用工具类Collections和Arrays。

2.Collections

Collections工具类是专门用于操作集合的工具类。我们来说一下他的常见方法。

（1）sort(List<T> List)

      无返回值，作用是对一个List集合进行排序，List集合的顺序是存入顺序，我们希望他可以按我们想要的顺序进行排序，那么就可以使用该方法。注意点是这个List集合中的元素必须是具备比较性的，也就是他们得实现Comparable接口，并复写ComparaTo方法。

（2）sort(List<T> list,Comparator<? supera T> c)

      无返回值，也是对一个List集合进行排序，此方法中List集合中的元素可以不具备比较性，因为我们在使用该方法时要往里面传一个比较器,排序是按此比较器来比较的。如果比较器为null，那么会按照集合中元素的比较方式进行排序，这时就要确保元素具有比较性了。

（3）binarySearch(List<? extends Comparable<? super T>>list, T key) 

      返回int，按照二分查找法在List集合中查找指定元素key的下标值。这个List集合一定是有顺序的，如果没有顺序则不存在能二分查找的前提。

（4）binaySerch(List<? extends T>list,T key,Comparator<? super T> c)

      返回int，根据指定比较器c产生的顺序按照二分查找法在List集合查找指定元素的下标。

（5）max(Collection<? extends T> coll)

       按元素自身的比较特性进行排序得到此集合中的最大值。

（6）max(Collection<? extends T>coll,Comparator<? super T>comp)

      按照指定比较器的排列顺序返回此集合中的最大值。

（7）fill(List<? super T>list,T obj)

      无返回值，使用指定元素obj替换列表中的所有元素。

（8）replaceAll(List<T>list, T oldVal,T newVal)

      返回boolean型，使用一个新的元素newVal替换掉集合中指定的元素oldVal

（9）reverse(List<?> list)

      无返回值，这个方法会把集合中的元素顺序反转。

（10）reverseOrder()

      返回一个比较器Comparator，这个比较器逆转了集合原有的自然顺序。

（11）返回线程安全的集合，下列方法会返回其对应的带有同步的集合。

      synchronizedList(List<T> list)

      synchronizedMap(Map<K,V> m)

      synchronizedSet(Set<T> s)

3.Arrays

（1）Arrays是用于操作数组的工具类，这个类中有一个方法是和集合紧密相关的就是asList(T…t)，把一个数组变成List集合。

      好处：我们可以利用集合的思想与某些方法来操作数组，例如可以利用集合的contains方法来判断数组中是否还有某个元素。

      注意点：①不可以使用集合的增删操作，因为数组的长度是固定的，如果使用增删操作，会报出不支持此操作异常：UnsupportedOperationException。

                      ②如果数组的元素都是对象，例如String类型的数组，那么变成集合的时候，数组中的元素就直接转成集合中的元素，如果数组是基本类型数组，那么这个数组就作为集合中的一个元素存在。

（2）集合变数组

将一个集合变成数组，是Collection接口中的方法，

      ①  toArray()

      将一个集合变成一个Object类型的数组返回

      ②  toArray(T[] t)

      返回一个T类型的数组，例：

      String[] str = al.toArray(newString[al.size()])；

      当指定类型的数组长度小于集合的size时，该方法内部会创建一个新的数组，长度为集合的长度。

      当指定类型的数组长度大于集合的长度，那么就直接使用这个指定数组，不去new一个新的数组了，其他位置默认为null。

      所以这个指定类型的数组长度应该与数组的长度相等