Java集合框架

最新推荐文章于 2024-10-26 15:03:20 发布

Mme.Y

最新推荐文章于 2024-10-26 15:03:20 发布

阅读量762

点赞数

分类专栏：小白学Java 文章标签： java java

本文链接：https://blog.csdn.net/Xu__Y/article/details/121619989

版权

小白学Java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一. 集合类接口

Collection

最基本的集合接口，是各种集合结构的父接口，List和Set是继承自它的子接口。

List

是有序的，会精确的将元素插入到指定的位置（允许有相同元素）。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素。

ArrayList

List接口实现类，实现可变大小的数组，允许不同数据类型作为数据成员，可以随机访问

底层用数组实现
访问效率高，插入和删除效率低
没有同步方法，不是同步的，线程不安全

LinkedList

List接口实现类，允许null元素，通常在首部或者尾部操作，常被使用做堆栈（Stack）、队列（Queue）和双向队列（Deque）

底层用链表实现
插入删除效率高，访问效率低
没有同步方法，不是同步的，线程不安全

Vector

List接口实现类，类似于ArrayList，大小可变，存储类型必须是引用类型

底层用数组实现
是同步的，线程安全（Stack继承自Vector）

Set

不包含重复元素的Collection接口，只关心元素是否属于Set，不允许有相同元素，而不关心它的顺序

Map、Collection、Iterator关系

Iterator 适用于 Collection 所有子类

// Iterator 和 Collection的联系
Iterator iter = c.iterator() // c为某一集合类

Map 没有继承 Collection，由一系列键值对组成，键值对保持一一对应关系

Collection vs Collections

Collection

集合接口，对集合对象进行基本操作的通用接口方法
是各种集合结构的父接口，为各种具体的集合提供了最大化的统一操作方式
例如：Set、List

Collections

包装类，通过一些静态方法，完成集合类的一些操作功能的工具类
不能被实例化
例如：对集合进行的排序、二分查找的方法

集合类接口间对比总结

Vector	ArrayList	LinkedList
是同步的(Synchronized)，是线程安全的(thread-safe)	不是同步的，但性能很好（线程的同步必然要影响性能）	不是同步的，线程不安全
当Vector中的元素超过它的初始大小时，Vector会将它的容量翻倍	当ArrayList中的元素超过它的初始大小时，ArrayList只增加50%的大小
内部实现基于内部数组Object[]	内部实现基于内部数组Object[]	内部实现基于一组连接的Node结点
	随机访问元素时，可以通过索引直接定位，效率较高；插入、删除等操作需移动数组元素，效率较低；元素个数大于数组容量，需要扩容	随机访问元素时，必须从表头开始访问，效率较低；插入、删除操作不需移动Node结点，比ArrayList效率高；按需为元素分配内存空间

Hashtable（被淘汰）	HashMap	TreeMap
父类 Dictionary类（已被废弃）	父类 AbstractMap类	父类 AbstractMap类
数组+链表	数组+链表	红黑树
是线程安全的，它的每个方法中都加入了Synchronize方法	不是线程安全的，在多线程并发的环境下，可能会产生死锁等问题	不是线程安全的，不同步
Hashtable默认的初始大小为11，之后每次扩充，容量变为原来的2n+1	HashMap默认的初始化大小为16，之后每次扩充，容量变为原来的2倍
Hashtable使用对象的hashCode，进行除法运算得到元素位置	哈希表的大小固定为2的幂，通过位运算获取元素位置
数据无序	数据无序	二叉树排序，数据有序（自然排序、定制排序）
不允许null key和null value	允许null key和null value	除第一个键外非空

二. 集合遍历方法

Iterator接口

hasNext()：检索到有下一个对象返回ture，否则返回false。
next()：在hasNext方法为true时调用，返回一个Object类型的对象引用。若这个方法没有对象返回，则抛出一个NoSuchElementException异常。
remove()：在提供迭代器的集合对象中删除由next()方法指向的一个对象元素。若没有调用next()，或调用next()后连续两次调用 remove()，则会抛出 IllegaStateException 异常。不是所有提供此迭代器的集合对象都支持这个方法，如果不支持情况下调用了该方法，则会抛出 UnsupportedOperation 异常。

// c为某一集合类
// for循环
for(Iterator it = c.iterator(); it.hasNext();){
    MyObject o  = (MyObject)it.next();
    ...
}
// while循环
Iterator it = c.iterator(); 
while(it.hasNext()){
   MyObject o  = (MyObject)it.next();
   ...
}
// JDK 5 for each语句
for(MyObject o : c){
    ...
}

ListIterator接口

不仅可以实现向后遍历，还可以实现向前遍历

hasNext() / hasPrevious()：检索到有下一个对象 / 上一个对象返回ture，否则返回false
next() / previous()：在 hasNext / hasPrevious 方法为true时调用，返回一个Object类型的对象引用。若这个方法没有对象返回，则抛出一个NoSuchElementException异常。

Integer tem;
try{
	LinkedList<Integer>  lst = new LinkedList<Integer>();
	for (int i=0 ;i<10 ;i++ ){
		lst.add(new Integer(i));
	}
	ListIterator<Integer> ite = lst.listIterator(10);
	// 向前遍历
	while(ite.hasPrevious()){
		tem =ite.previous();
		System.out.print(tem.intValue()+" "); // 9 8 7 6 5 4 3 2 1 0 
	}
}catch(Exception e){
	System.out.println("error");
}

三. 常用集合类常用方法

ArrayList

import java.util.*;
public class Test {
    public static void main(String[] args){
        ArrayList<Integer> array = new ArrayList<Integer>();
        // 添加元素
        array.add(1);
        array.add(2);
        array.add(3);
        // 查找指定元素的位置
        System.out.println(array.indexOf(2)); // 1
        System.out.print("array1:");
        // 遍历元素
        for (int i : array) {
            System.out.print(i + " "); // array1:1 2 3 
        }
        System.out.println();
        // 移除指定位置元素
        array.remove(1);
        System.out.print("array2:");
        for(int i=0;i<array.size();i++) {
            // 获取指定位置的元素
            System.out.print(array.get(i)+" "); // array2:1 3 
        }
    }
}

LinkedList

import java.util.*;
public class Test {
    public static void main(String[] args){
        Integer tem;
        LinkedList<Integer> lst = new LinkedList<Integer>();
        // 添加元素
        for (int i=0; i<10 ; i++ ){
            lst.addFirst(new Integer(i));
        }
        for (int i=0; i<10; i++ ){
            // 查找第一个元素
            int n=lst.peek();
            // 移除最后一个元素
           	tem = lst.removeLast();
            System.out.print(i+1+" First:"+n+" ");
            System.out.println("Last:"+tem.intValue());
        }
    }
}
/*
	1 First:9 Last:0
	2 First:9 Last:1
	3 First:9 Last:2
	4 First:9 Last:3
	5 First:9 Last:4
	6 First:9 Last:5
	7 First:9 Last:6
	8 First:9 Last:7
	9 First:9 Last:8
	10 First:9 Last:9
*/

Vector

import java.util.*;
public class Test {
    public static void main(String[] args){
        Vector<Integer> ve=new Vector<Integer>();
        // 添加元素
        ve.addElement(2);
        ve.addElement(1);
        ve.addElement(3);
        // 移除指定位置的元素
        ve.removeElementAt(1);
        // 查找元素的位置
        System.out.println(ve.indexOf(3));
        for(int i=0;i<ve.size();i++){
            // 获取元素
            System.out.print(ve.get(i)+" ");
        }
    }
}

ArrayDeque

import java.util.*;
public class Test {
    public static void main(String[] args){
        ArrayDeque<Integer> ad=new ArrayDeque<Integer>();
        // 添加元素，push()
        ad.addFirst(4);
        ad.addLast(1);
        ad.offerFirst(2);
        ad.offerLast(3);
        // 获取第一个元素
        System.out.println(ad.getFirst()+" "+ad.peekFirst()); // 2 2
        System.out.println(ad);// [2, 4, 1, 3]
        // 移除第一个元素，pop()和最后一个元素
        ad.removeFirst();
        ad.pollLast();
        System.out.println(ad); // [4, 1]
    }
}

HashSet

import java.util.*;
public class Test {
    public static void main(String[] args){
        HashSet<Integer> hs=new HashSet<Integer>();
        // 添加元素，不重复添加
        hs.add(1);
        hs.add(5);
        hs.add(1);
        hs.add(3);
        // 遍历元素
        Iterator it=hs.iterator();
        while(it.hasNext()){
            System.out.print(it.next()+" "); // 1 3 5
        }
    }
}