ArrayList底层是一个Object数组，对所有的底层操作就是基于数组实现的。且ArrayList是不同步的，性能上比Vector好一点，在多线程环境中需要自己管理线程同步问题。

构造方法：

ArrayList()// 构造一个初始容量为 10 的空列表（每次递增容量为原来的1.5倍）ArrayList(Collection c)// 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的ArrayList(int initialCapacity)//构造一个具有指定初始容量的空列表

常用方法：（除去List中的方法）

void ensureCapacity(int minCapacity)//如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。void removeRange(int fromIndex, int toIndex)//移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。

List中方法：链接(List)

ArrayLsit底层代码：

​ transient Object[] elementData;

​ transeent 表示瞬息的，短暂的，表示该属性不会被序列号

遍历方式：

Iterator迭代器遍历，for增强。

去重方式：

package com.cn.test;import java.util.ArrayList;import java.util.HashSet;import java.util.List;public class MyTest3 { //新建List去重    public static void main(String[] args) {       ArrayList  list=new ArrayList();        list.add(1);        list.add(2);        list.add(1);        list.add(2);        list.add(3);        list.add(5);        list.add(5);        HashSet  hashSet=new HashSet(list);        ArrayList arrayList=new ArrayList(hashSet);                for (Object o : arrayList) {            System.out.println(o);        }    }    }

LinkedHashSet linkedHashSet=new LinkedHashSet(list);ArrayList arrayList=new ArrayList(linkedHashSet);

删除特定不同元素：

package com.cn.test;import java.util.ArrayList;public class MyTest3 { //新建List去重    public static void main(String[] args) {        ArrayList  list=new ArrayList();        list.add(1);        list.add(2);        list.add(1);        list.add(2);        list.add(3);        list.add(5);        list.add(5);        for (int i = 0; i < list.size(); i++) {            if (list.get(i)==5)            {                list.remove(i);                i--;            }        }        for (Object o : list) {            System.out.println(o);        }    }}

结果：

Iterator sListIterator = list.iterator();  while(sListIterator.hasNext()){      String e = sListIterator.next();      if(e.equals("3")){      sListIterator.remove();      }  }

排序:

package com.cn.test;import java.util.ArrayList;import java.util.Collections;import java.util.Iterator;public class MyTest3 { //新建List去重    public static void main(String[] args) {        ArrayList  list=new ArrayList();        list.add("apple");        list.add("banana");        list.add("orange");        list.add("watermelon");        System.out.println("正序:");        Collections.sort(list);//字母正序        Iterator iterator= list.iterator();        while (iterator.hasNext()) {            String next =  iterator.next();            System.out.println(next);        }        System.out.println("逆序:");        Collections.sort(list,Collections.reverseOrder());//字母逆序        Iterator iterator2= list.iterator();        while (iterator2.hasNext()) {            Object next =  iterator2.next();            System.out.println(next);        }    }}

合并ArrayList并去重:

使用remainAll(参数):保留参数和this调用的交集到调用this之中

removeAll(参数):移除this和参数的交集

addAll():添加参数内容到this里

package com.cn.test;import java.lang.reflect.Array;import java.util.ArrayList;public class MyTest3 { //新建List去重    public static void main(String[] args) {        ArrayList  list=new ArrayList();        ArrayList  list2=new ArrayList();        list.add("apple");        list.add("banana");        list.add("orange");        list.add("watermelon");        list2.add("apple");        list2.add("peach");        ArrayList temp=new ArrayList(list);        temp.retainAll(list2);//仅仅保留list和list2的交集到temp        list.removeAll(temp);//去重        ArrayList sumList=new ArrayList();        sumList.addAll(list);        sumList.addAll(list2);        for (Object o:sumList) {            System.out.println(o);        }    }}

结果:

LinkedList类是双向列表,列表中的每个节点都包含了前一个和后一个元素的引用,基于链表实现的.因此访问数据的效率不如ArrayList.LinkedList是双向链表每个结点包含前后结点的位置信息.头结点中不存放数据.

构造方法:

LinedList<类型> list=new LinkedList<类型>();

创建一个空链表

LinkedList<类型> list = new LinkedList(Collection c); 使用一个集合创建一个新的linkedList。

常用方法:

add(E e): 将指定元素添加到此列表的结尾。

add(int index, E element)：在此列表中指定的位置插入指定的元素。

addAll(Collection c)：添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。

addAll(int index, Collection c)：将指定 collection 中的所有元素从指定位置开始插入此列表。

AddFirst(E e): 将指定元素插入此列表的开头。

addLast(E e): 将指定元素添加到此列表的结尾。

clear()： 从此列表中移除所有元素。

poll() :检索并删除此链表的一个头部

pollFirst() :检索并删除此列表的第一个元素,如果为空则返回null

pollLast() :检索并删除此列表的最后一个元素,为空返回null

peek() :检索不删除此列表的头部

peekFirst() :检索不删除此列表的第一个元素,如果此列表为空则返回null

peekLast() :检索但不删除此列表的最后一个元素,如果此列表为空则返回null

remove()：获取并移除此列表的头（第一个元素）。

remove(int index)：移除此列表中指定位置处的元素。

remove(Objec o)：从此列表中移除首次出现的指定元素（如果存在）。

removeFirst()：移除并返回此列表的第一个元素。

removeFirstOccurrence(Object o)：从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。

removeLast()：移除并返回此列表的最后一个元素。

removeLastOccurrence(Object o)：从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。

get(int index)：返回此列表中指定位置处的元素。

getFirst()：返回此列表的第一个元素。

getLast()：返回此列表的最后一个元素。

indexOf(Object o)：返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

lastIndexOf(Object o)：返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

遍历方式:

普通for循环+get(index)方法(不推荐)

使用增强for循环(推荐)

使用Iterator迭代器(推荐)

前面三种的使用和List中一样,可以参考List中的遍历方式

package com.cn.test;import java.util.LinkedList;public class MyTest3 { //新建List去重    public static void main(String[] args) {        LinkedList list=new LinkedList();        list.add("apple");        list.add("banana");        list.add("orange");        list.add("watermelon");        String next=null;        while((next=list.pollFirst())!=null){            System.out.println(next);        }    }}

使用pollLast()遍历,和上一个基本相同

用removeFirst()遍历

用removeLast()遍历

排序:

使用java.util.Collections.sort,和List中的排序类似需要自己写比较器类然后调用.

具体可以参考List文章中的使用方法

set集合也是单列集合,但是不能存放重复的元素,即使是null.且里面元素的存放顺序是无序的

常用方法:

boolean add(Object o)：该方法用于向集合里添加一个元素,返回值为操作是否成功.

boolean addAll(Collection c)：该方法把集合c里的所有元素添加到指定集合里。返回值为操作是否成功.

void clear()：清除集合里的所有元素，将集合长度变为0。

boolean contains(Object o)：返回集合里是否包含指定元素。

boolean containsAll(Collection c)：返回集合里是否包含集合c里的所有元素。

boolean isEmpty()：返回集合是否为空。当集合长度为0时返回true，否则返回false。

Iterator iterator()：返回一个Iterator对象，用于遍历集合里的元素。

boolean remove(Object obj)：删除集合中的指定元素obj，当集合中包含了一个或多个元素obj时，这些元素将被删除，该方法将返回true。

boolean removeAll(Collection c)：将集合中删除集合c里包含的所有元素（相当于用调用该方法的集合减集合c），如果删除了一个或一个以上的元素，则该方法返回true。

boolean retainAll(Collection c)：将集合中删除集合c里不包含的元素（相当于把调用该方法的集合变成该集合的集合c的交集），如果该操作改变了调用该方法的集合，则该方法返回true。

int size()：该方法返回集合里元素的个数。

Object[] toArray()：该方法把集合转换成一个数组，所有的集合元素变成对应的数组元素。

遍历方式:

排序方式:

package com.cn.test;import java.util.*;public class MyTest3 { //新建List去重    public static void main(String[] args) {        Set  set=new HashSet();        set.add(123);        set.add(234);        set.add(444);        set.add(156);        ArrayList list=new ArrayList(set);        Collections.sort(list,Collections.reverseOrder());        System.out.println(list);    }}

Hashset实现了Set接口,其背后是一个哈希表,实际是一个HashMap实例(存储在HashMap中:实际上，我们在HashSet中插入的值充当映射对象的键，java使用常量变量来表示它的值。因此，在键值对中，所有值都是相同的。HashMap中的键才是我们在HashSet中的存储值).

在HashSet中插入的对象不能保证其插入顺序,因为其根据哈希函数散列分布的.

HashSet还实现了Serializable和Cloneable接口,因此其可被序列化

负载因子:是指当前容量的大小乘于负载因子等于容量增长的极限值.例如:如果当前容量为16,负载因子为0.75,当存入数据量达到12时就是自动增加容量的大小.

在存储Object之前，HashSet会使用hashCode()和equals()方法检查是否存在现有的条目。如果两个列表具有相同顺序的相同元素，则认为它们是相等的。当你在两个列表上调用hashCode()方法时，它们都将给出相同的散列，因为它们是相等的。

HashSet不仅存储唯一的对象，而且还存储唯一的对象集合，如ArrayList， LinkedList， Vector等(其中的元素值和顺序均一致的算作为相同的集合).

构造函数:

HashSet hs=new HashSet();

HashSet hs = new HashSet(int initialCapacity);//指定初始空间大小的

HashSet hs = new HashSet(int initialCapacity, float loadFactor);//指定初始大小和负载因子

HashSet hs = new HashSet(Collection C); //指定集合内容放入HashSet之中

遍历方式:

无序不可重复,但是根据元素的大小顺序自动排序.实现自定义类型的排序需要进行定义.

TreeSet集合底层实际上是一个TreeMap，而TreeMap集合底层是一个二叉树，也将TreeSet集合中的元素称为可排序组合

基于TreeMap实现的SortedSet , 基本数据类型的排序后按升序排列元素 ,非线程安全

构造方法:

TreeSet ts=new TreeSet();//构建一个空的set

TreeSet ts=new TreeSet(Collection col); //构建一个包含Collection集合的TreeSet,按照自然顺序进行排序

TreeSet ts=new TreeSet(Comparator com); //构建一个指定排序方式的TreeSet

TreeSet ts=new TreeSet(); //构建一个指定有序set具有相同映射关系和相同排序的TreeSet

常用方法:

E ceiling(E e)  // 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。 E lower(E e)   //返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。    E higher(E e)  // 返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。         Comparator comparator()   //返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。 NavigableSet descendingSet()   //返回此 set 中所包含元素的逆序视图。 E first()   //返回此 set 中当前第一个（最低）元素。 E last()   //返回此 set 中当前最后一个（最高）元素。 E floor(E e)  // 返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。 SortedSet headSet(E toElement)   //返回此 set 的部分视图，其元素严格小于 toElement。 NavigableSet headSet(E toElement, boolean inclusive)  // 返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。 Iterator iterator()  // 返回在此 set 中的元素上按升序进行迭代的迭代器。 Iterator descendingIterator()   //返回在此 set 元素上按降序进行迭代的迭代器。   E pollFirst()   //获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。  E pollLast()   //获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。 NavigableSet subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)   //返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。 SortedSet subSet(E fromElement, E toElement)   //返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。 SortedSet tailSet(E fromElement)   //返回此 set 的部分视图，其元素大于等于 fromElement。 NavigableSet tailSet(E fromElement, boolean inclusive)  // 返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。 

TreeSet保存自定义类型,需要传入比较器或者实体类实现Comaprable的CompareTo()方法,不然会报java.lang.ClassCastException异常.

在TreeSet中实现自定义类型的排序有两种方法:

//自定义类,通过age比较排序package com.cn.pojo;public class Person implements Comparable{    String name;    int age;    public Person() {    }    public Person(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 "Person{" +                "name="" + name + "\"" +                ", age=" + age +                "}";    }    @Override    public int compareTo(Person o) {        return this.age-o.age; //传递比较结果正/负/零        //this值减参数值为升序,反之为降序    }}

调用测试:

package com.cn.test;import com.cn.pojo.Person;import java.util.Iterator;import java.util.TreeSet;public class Test5 {    public static void main(String[] args) {        Person p1=new Person("张三",22);        Person p2=new Person("张4",21);        Person p3=new Person("张5",25);        Person p4=new Person("张6",24);        TreeSet  ts=new TreeSet();        ts.add(p1);        ts.add(p2);        ts.add(p3);        ts.add(p4);        Iterator iterator= ts.iterator();        while (iterator.hasNext()) {            Person next =  iterator.next();            System.out.println(next);        }    }}

运行结果:

实体类依旧使用我们上面的Person类.

比较器:

package com.cn.compare;import com.cn.pojo.Person;import java.util.Comparator;public class P_Compare implements Comparator {    @Override    public  int compare(Person o1, Person o2) {        return o2.getAge()-o1.getAge();        //第一个参数减第二个为升序,反之为降序    }}

调用测试:

package com.cn.test;import com.cn.compare.P_Compare;import com.cn.pojo.Person;import java.util.Iterator;import java.util.TreeSet;public class Test5 {    public static void main(String[] args) {        Person p1=new Person("张三",22);        Person p2=new Person("张4",21);        Person p3=new Person("张5",25);        Person p4=new Person("张6",24);        TreeSet  ts=new TreeSet(new P_Compare());        ts.add(p1);        ts.add(p2);        ts.add(p3);        ts.add(p4);        Iterator iterator= ts.iterator();        while (iterator.hasNext()) {            Person next =  iterator.next();            System.out.println(next);        }    }}

运行结果:

关键词：

责任编辑：Rex_25