java笔记--java集合框架

1、Collection接口

Collection接口是一个重要的操作接口，它规定了集合的基本操作规范，该接口有两个子接口Set和List

Collection继承自Iterator接口，其定义如下：

public interface Collection<E>extends Iterable<E>；其中定义的主要的方法如下：

（1）boolean add（E e）-->增加一个元素

（2）boolean addAll(Collection<? extends E> c) -->增加一组数据

（3）void clear（）-->移除此Collection中的所有元素

（4）boolean remove（Object o）-->删除指定的元素

（5）boolean removeAll（Collection<? extends E> c）-->删除Collection指定的一组元素

（6）int size（）-->返回集合元素的个数

（7）boolean isEmpty（）-->判断结合是否为空

（8）boolean contains(Object o) -->判断集合是否包含某元素

（9）Object[] toArray()-->返回此集合所有元素的数组

（10）......

那么现在开发基本很少使用Collection完成功能，基本上使用其子接口List和Set。

2、List接口

List接口继承子Collection接口，在Collection的基础上扩展了一些方法，List接口最大的

特点是里面的内容允许重复。增加的方法：

(1)void add(int index,E element) -->在指定的位置添加元素

(2)boolean addAll(int index,Collection<? extends E> c)

(3)E get(int index)

(4)E remove(int index)

(5)E set(int index E element)

(6)List<E> sunList(int fromindex,int toindex)

2.1 ArrayList

ArrayList类是List接口最常用的一个子类，定义如下：

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

例子：

import java.util.*;

class ArrayListDemo {

public static void main(String[] args) {

List<String> myList = new ArrayList<String>();//实例化ArrayList

myList.add("hello");//增加元素

myList.add("帅哥");

myList.add(2, "OKOK");//在指定的位置增加元素

System.out.println(myList);

myList.remove(1);//根据索引来删除一个元素

myList.remove("帅哥");//根据对象删去帅哥对象

System.out.println(myList);

System.out.println(myList.get(0));

System.out.println(myList.size());

System.out.println(myList.subList(0, 1));

}

}

2.2 Vector

Vector类是一个元老级的操作类，它也实现了List接口，Vector一般来说使用较少，与ArrayList相比，Vector

是线程安全的，而ArrayList是非线程安全的。它的使用基本上与ArrayList类似。

2.3 LinkedList

LinkedList类是基于链式线性表实现的，其特点是适合于在链表中间需要频繁进行插入和删除操作。但是其缺点是随机访问速度较慢。

查找一个元素需要从头开始一个一个的找，速度较慢。

3、Set接口

Set接口也是Collection的子接口，最大的特点是没有重复元素。在Set接口中有以下的两个子类的常用的：

（1）HashSet：散列存放

（2）TreeSet：有序存放

Set接口本身继承了Collection却没有扩充Collection接口。

（1）散列存放：不重复，无序

例子：

class HashSetDemo {

public static void main(String[] args) {

Set<String> mySet = new HashSet<String>();

mySet.add("hello");

mySet.add("java");

mySet.add("hello"); //编译可以通过，会覆盖前一个“hello”

mySet.add("world");

System.out.println(mySet);

}

}

（2）有序存放：TreeSet（没有重复对象、内部根据cmparaTo()方法自动进行排序）

例子：

class TreeSetDemo {

public static void main(String[] args) {

Set<String> mySet = new TreeSet<String>();

mySet.add("A");

mySet.add("D");

mySet.add("G");

mySet.add("B");

mySet.add("C");

mySet.add("F");

mySet.add("E");

System.out.println(mySet);

}

}

输出：[A, B, C, D, E, F, G]

4、使用迭代器遍历集合元素

迭代器Iterator和ListIterator是接口，不能实例化，不同的集合提供了可以遍历自身元素的迭代器实现。

Iterator迭代器包含的方法有：

（1）hasNext()：如果迭代器指向位置后面还有元素，则返回 true，否则返回false

（2）next()：返回集合中Iterator指向位置后面的元素

（3）remove()：删除集合中Iterator指向位置后面的元素

ListIterator迭代器包含的方法有：

（1）add(E e): 将指定的元素插入列表，插入位置为迭代器当前位置之前

（2）hasNext()：以正向遍历列表时，如果列表迭代器后面还有元素，则返回 true，否则返回false

（3）hasPrevious():如果以逆向遍历列表，列表迭代器前面还有元素，则返回 true，否则返回false

（4）next()：返回列表中ListIterator指向位置后面的元素

（5）nextIndex():返回列表中ListIterator所需位置后面元素的索引

（6）previous():返回列表中ListIterator指向位置前面的元素

（7）previousIndex()：返回列表中ListIterator所需位置前面元素的索引

（8）remove():从列表中删除next()或previous()返回的最后一个元素（有点拗口，意思就是对迭代器使用hasNext()方法时，删除ListIterator指向位置后面的元素；当对迭代器使用hasPrevious()方法时，删除ListIterator指向位置前面的元素）

（9）set(E e)：从列表中将next()或previous()返回的最后一个元素返回的最后一个元素更改为指定元素e

两者的区别：

（1）使用范围不同，Iterator可以应用于所有的集合，Set、List和Map和这些集合的子类型。而ListIterator只能用于List及其子类型。

（2）ListIterator有add方法，可以向List中添加对象，而Iterator不能。

（3）ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator不可以。

（4）ListIterator可以定位当前索引的位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。

（5）都可实现删除操作，但是ListIterator可以实现对象的修改，set()方法可以实现。Iterator仅能遍历，不能修改。

ListIterator例子：

class ListIteratorTest

{

public static void main(String[] args)

{

List<String> staff = new LinkedList<>();

staff.add("zhuwei");

staff.add("xuezhangbin");

staff.add("taozhiwei");

ListIterator<String> iter = staff.listIterator();

String first = iter.next();

iter.remove();

System.out.println("first:"+first);

iter.add("xiaobai");

System.out.println("travel1: ");

for(String str : staff)

System.out.println(str+" ");

iter = staff.listIterator();

System.out.println("travel2: ");

while(iter.hasNext())

{

System.out.println(iter.next());

}

}

}

Iterator的例子：

class IteratorDemo

{

public static void main(String[] args)

{

List<String> myList = new ArrayList<String>();

myList.add("hello");

myList.add("lenuy");

myList.add("haha");

myList.add("hehe");

Iterator it = myList.iterator();

while(it.hasNext())

{

System.out.println(it.next());

}

}

}

5、Map接口

Map接口保存一对值（key—value），Map中的key是不能重复的。

Map接口有三个常用子类：

HashMap、HashTable、TreeMap

Map接口中的方法有：

（1）boolean containsKey(Object key)此映射是否包含指定键的映射

（2）boolean containsValue(Object value)此映射是否包含指定值的映射

（3）V get(Object key)返回指定键所映射的值

（4）put(K key,V value)向此Map实例增加内容

（5）V remove(Object key)从映射中移除其映射关系的键，返回与 key 关联的值；如果没有 key 的映射关系，则返回 null。

（6）int size()求映射的程度

（7）boolean isEmpty()判断映射是否为空

（8）Set<K> keySet()返回此映射中包含的键的 Set 集合

（9）Collection<V> values()返回此映射中包含的值的 Collection 集合

5.1 HashMap类

HashMap是无序的。Map中的key是不能重复的，如果重复了，则属于覆盖，即保留了后来增加的内容。Map最大的特点是查找操作，如果查找到了则返回Value，否则返回null值。

例子：

class HashMapDemo

{

public static void main(String[] args)

{

Map<String,Integer> myMap = new HashMap<String,Integer>();

myMap.put("A", 1);

myMap.put("B", 2);

myMap.put("C", 3);

myMap.put("C", 3);

System.out.println(myMap);

System.out.println(myMap.get("A"));

System.out.println(myMap.get("D"));

}

}

输出：

{A=1, B=2, C=3}

1

null

5.2 HashTable类

Hashtable属于线程安全的。其操作和Map几乎一样。

5.3 TreeMap类

TreeMap类按键（key）进行了排序，如果key的类型的任意对象类型，要TreeMap能够自动进行排序的话，则此类必须实现Comparable的comparaTo()方法。

看以下例子：

class TreeMapDemo

{

public static void main(String[] args)

{

Map<String,Integer> myMap = new TreeMap<String,Integer>();

myMap.put("D", 1);

myMap.put("B", 2);

myMap.put("C", 3);

myMap.put("C", 3);

myMap.put("A", 4);

System.out.println(myMap);

Set<String> set = myMap.keySet();

Iterator it = set.iterator();

while(it.hasNext()){

String str = (String) it.next();

System.out.println(str+" --> "+myMap.get(str));

}

}

}

输出：

{A=4, B=2, C=3, D=1}

A --> 4

B --> 2

C --> 3

D --> 1

6、java集合框架小结

（1）类集合设置的主要目的是实现动态的对象数组操作。

（2）List接口允许值的重复。其子类有：ArraryList（最采用）、Vector（旧的类）、LinkedList（允许null值，实现了Queue接口）

（3）Set接口：不允许对象重复，依靠equal()和hashCode（）【注意：java中默认hashCode的根据对象的地址计算得来的】方法来检查区分是否为同一对象。

HashSet：无序的

TreeSet：能够按照对象的comparaTo()方法进行排序。

（4）Map接口：存放一对值，key不能重复。不能放空值，Map并没有继承Collection接口

HashMap：无序的

Hashtable：无序的而且同步的，线程安全的，旧的类（不允许关键字或值为null

TreeMap,:能够按照key自动来排序，按照Key对象的comparaTo()方法。

（5）注意Collections和Collection的区别。Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。 Collection是个java.util下的接口，它是各种集合结构的父接口。