Java-集合框架-CSDN博客

本文链接：https://blog.csdn.net/mr_yao0/article/details/121111683

集合

集合和数组的区别：

数组长度固定而集合不固定
数组可以存放基本类型数据和引用类型数据，集合只能存储引用类型数据（可以用拆箱和装箱的方式把基础类型封装成引用类型数据）

Collection体系集合

Collection是该体系的跟接口，代表一组对象，成为“集合”。
List特点：有序、有下标、元素可重复
Set特点：无序、无下标、元素可不重复

Collection父接口

特点:代表一组任意类型的对象，无序、无下标、不能重复。
方法:

boolean add (0bject obj)  //添加一个对象。
boolean addAll(Collection c)  //将一个集合中的所有对象添加到此集合中。
void clear()   //清空此集合中的所有对象。
boolean contains (Object o)  //检查此集合中是否包含o对象
boolean equals(Object o)  //比较此集合是否与指定对象相等。
boolean isEmpty()  //判断此集合是否为空
boolean remove (0bject o)  //在此集合中移除o对象
int size()   //返回此集合中的元素个数。
Object[] toArray()  //将此集合转换成数组。

使用：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * Collection接口使用
 * 1添加元素
 * 2删除元素
 * 3遍历元素
 * 4判断
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建集合
        Collection collection = new ArrayList();
//      1添加元素
        collection.add("苹果");
        collection.add("香蕉");
        collection.add("橘子");
        collection.add("葡萄");
        collection.add("西瓜");
        System.out.println("元素个数："+collection.size());
        System.out.println(collection);
//      2删除元素
//        collection.remove("西瓜");
//        collection.clear();
        System.out.println("元素个数："+collection.size());
//      3遍历元素【重点】
            //使用增强for
        System.out.println("-------------------使用增强for-------------------");
        for (Object o : collection) {
            System.out.print(o+" ");
        }
        System.out.println();
            //使用迭代器（迭代器：专门用来遍历集合的一种方式）
            //hasNext();有没有下一个元素
            //next();获取下一个元素
            //remove();删除当前元素
        System.out.println("-------------------使用迭代器-------------------");
        Iterator it = collection.iterator();
        while (it.hasNext()){
            String s = (String)it.next();
            System.out.print(s+" ");
            it.remove();
        }
        System.out.println("\n当前元素个数："+collection.size());

//      4判断
        System.out.println(collection.contains("橘子"));
        System.out.println(collection.isEmpty());
    }
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * collection的使用：保存学生信息
 */
public class Demo02 {
    public static void main(String[] args) {
        //新建对象
        Collection collection = new ArrayList();
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);
        Student s3 = new Student("王五", 20);
        //添加数据，由于是arrayList所以可以重复添加
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        collection.add(s3);
        System.out.println(collection.size());
        System.out.println(collection.toString());
        //删除
//        collection.remove(s3);
        //collection.remove( new Student("王五",20));
        //清空
        //collection.clear();
        System.out.println("删除之后:"+collection.size()+","+collection.toString());
        //遍历
            //增强for
        System.out.println("----------------增强for----------------");
        for (Object o : collection) {
            Student student = (Student) o;
            System.out.println(student.toString());
        }
            //迭代器
        System.out.println("----------------迭代器----------------");
        Iterator it = collection.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
            it.remove();
        }
        System.out.println(collection.size());
        //判断
        System.out.println(collection.contains(s1));
        System.out.println(collection.isEmpty());
    }
}

List子接口

特点：有序、有下标、元素可重复
方法：

void add(int index,Object 0) //在index位置插入o
boolean addAll(int index,Collection c)  //在index位置插入一个集合c
Object get(int index) //返回集合中指定位置的元素
List SubList(int fromIndex,int toIndex)  //返回fromIndex到toIndex之间的集合元素

使用：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * List子接口的使用
 * 特点：有序、有下标、元素可重复
 */
public class Demo03 {
    public static void main(String[] args) {

        //创建对象
        List list = new ArrayList();
        //添加元素
        System.out.println("-----------添加元素---------------");
        list.add("小米");
        list.add("小米");
        list.add("中兴");
        list.add("诺基亚");
        list.add(0,"苹果");
        list.add(0,"华为");
        System.out.println(list.size());
        System.out.println(list.toString());
        //删除
        System.out.println("-----------删除---------------");
        list.remove("苹果");
        list.remove(0);
        System.out.println(list.size());
        System.out.println(list.toString());
        //清空
        System.out.println("-----------清空---------------");
//        list.clear();
//        System.out.println(list.size());
//        System.out.println(list.toString());
        //遍历
            //for循环
        System.out.println("-----------for循环---------------");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println();
        System.out.println("元素的个数为："+list.size());
        //增强for
        System.out.println("-----------增强for---------------");
        for (Object o : list) {
            System.out.print(o+" ");
        }
        System.out.println();
            //迭代器
        System.out.println("-----------迭代器---------------");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next()+" ");
            //iterator.remove();
        }
        System.out.println();
        System.out.println("元素个数为："+list.size());

        //lisIterator（列表迭代器），强大之处：可以向任意方向迭代，在期间还可以添加、修改、删除元素。
        System.out.println("--------------lisIterator-------------------");
        System.out.println("顺序迭代");
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            System.out.print(listIterator.nextIndex()+" "+listIterator.next()+" ");
            //增、改、删
            //listIterator.add("1");
            //listIterator.set("1");
            //listIterator.remove();
        }
        //指针初始位置为第一位，无法向前遍历（hasPrevious），需要把指针移动到后面(hasNext)才可以向前遍历（hasPrevious）。
        System.out.println("\n逆序迭代：");
        while (listIterator.hasPrevious()){
            System.out.print(listIterator.previousIndex()+" "+listIterator.previous()+" ");
        }
        System.out.println();

        //判断
        System.out.println("--------------判断-------------------");
        System.out.println(list.contains("小米"));
        System.out.println(list.isEmpty());

        //获取位置
        System.out.println(list.indexOf("小米"));
    }
}

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

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

        //创建list对象
        List list = new ArrayList();
        //添加数字元素(collection无法添加基本类型，这里是自动装箱)
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        list.add(200);
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());
        //删除操作
        //list.remove(0);
        //list.remove((Object) 20);
        list.remove(new Integer(200 ));//和缓冲区没有任何关系，不要被误导，缓冲区为（-127-128）
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());

        //补充subList方法，返回子集合，含头不含尾
        List subList = list.subList(1, 3);
        System.out.println(subList.toString());

    }
}

List实现类

ArrayList【重点】
1. 数组结构实现，查询快，增删慢
2. JDL1.2版本，运行效率快，线程不安全。
Vector
1. 数组结构实现，查询快，增删慢
2. JDL1.0版本，运行效率慢，线程安全。
LinkedList
1. 链表结构实现，增删快，查询慢。

arrayList：

源码分析：
- 默认容量 DEFAULT_CAPACITY = 10;
- 存放元素的数组 elementData
- 实际的元素个数 size
  - tips：如果初始化ArrayList还没有添加任何元素，则容量为0。添加一个任意容量之后就是10
  - ```
  每次扩容为原来1.5倍（源码分析结果）
```
- add（）添加元素

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

/**
 * ArrayList类，特点：有序，有下标，可重复
 * 存储结构：数组==>查找遍历速度比较快，增删速度比较慢
 */
public class Demo05 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<Object> arrayList = new ArrayList<>();
        Student s1 = new Student("周润发", 18);
        Student s2 = new Student("梁朝伟", 18);
        Student s3 = new Student("周星驰", 22);
        Student s4 = new Student("古天乐", 120);
        //1添加元素
        System.out.println("------------------1添加元素-------------");
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        System.out.println("元素个数"+arrayList.size());
        System.out.println(arrayList.toString());
        //2删除元素
        System.out.println("------------------2删除元素-------------");
//        arrayList.remove(0);
        //arrayList.remove(s1);
        arrayList.remove(new Student("梁朝伟",18));
        System.out.println(arrayList.size());
        System.out.println(arrayList.toString());


        //3遍历元素【重点】
        //3.1使用迭代器
        System.out.println("------------------3遍历元素【重点】==>迭代器-------------");
        Iterator<Object> iterator = arrayList.iterator();
        while (iterator.hasNext()) System.out.print(iterator.next()+" ");
        System.out.println();

        System.out.println("------------------3遍历元素【重点】==>list迭代器-------------");
        ListIterator<Object> listIterator = arrayList.listIterator();
        while (listIterator.hasNext()) System.out.print(listIterator.next()+" ");
        System.out.println();

        System.out.println("------------------3遍历元素【重点】==>list迭代器逆序-------------");
        while (listIterator.hasPrevious()) System.out.print(listIterator.previousIndex()+" "+listIterator.previous());
        System.out.println();

        //4判断
        System.out.println("------------------判断-------------");
        System.out.println(arrayList.contains(s1));
        System.out.println(arrayList.contains(new Student("周润发",18)));
        System.out.println(arrayList.isEmpty());

        //5查找
        System.out.println("------------------查找-------------");
        System.out.println(arrayList.indexOf(s1));
        System.out.println(arrayList.indexOf(new Student("古天乐",120)));

    }
}

vector

内容：

import java.util.Enumeration;
import java.util.Vector;

/**
 * Vector集合的使用
 * 存储方式：数组  查询快，增删慢
 */
public class Demo01 {
    public static void main(String[] args) {

        //创建对象
        Vector vector = new Vector();
        //添加元素
        vector.add("土豆");
        vector.add("马铃薯");
        vector.add("洋芋");

        //删除
//        vector.remove(1);
//        vector.remove("土豆");
//        vector.clear();

        //遍历
        //使用枚举器遍历
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()){
            String o = (String) elements.nextElement();
            System.out.print(o+" ");
        }
        System.out.println();

        //判断
        System.out.println(vector.contains("土豆"));
        System.out.println(vector.isEmpty());
        System.out.println(vector.firstElement());
        System.out.println(vector.lastElement());
        System.out.println(vector.get(0));
        System.out.println(vector.elementAt(1));
        System.out.println(vector.getClass());

    }
}

LinkedList

内容：

import com.exception.aggregate.chapter1.Student;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

/**
 * LinkedList的使用
 * 存储结构：双向链表  增删快，查询慢
 */
public class Demo02 {
    public static void main(String[] args) {

        //创建LinkedList对象
        LinkedList<Object> linkedList = new LinkedList<>();
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 20);
        Student s3 = new Student("王五", 30);

        //添加
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        System.out.println(linkedList.size());
        System.out.println(linkedList.toString());
        //删除
//        linkedList.remove(s1);
//        //此方法可以用是因为Student重写了equals方法。
//        linkedList.remove(new Student("张三",18));
//        System.out.println(linkedList.size());

        //遍历
        //for遍历
        System.out.println("—————————————————————————for遍历———————————————————————————————");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.print(linkedList.get(i)+" ");
        }
        System.out.println();

        System.out.println("—————————————————————————增强for遍历———————————————————————————————");
        for (Object o : linkedList) {
            Student s = (Student)o;
            System.out.print(s.toString() + " ");
        }
        System.out.println();

        System.out.println("—————————————————————————迭代器———————————————————————————————");
        Iterator<Object> iterator = linkedList.iterator();
        while (iterator.hasNext()){
            Student next = (Student) iterator.next();
            System.out.print(next+"\t");
        }
        System.out.println();

        System.out.println("—————————————————————————列表迭代器———————————————————————————————");
        ListIterator<Object> listIterator = linkedList.listIterator();
        while (listIterator.hasNext()){
            Student next = (Student) listIterator.next();
            System.out.print(next+"\t");
        }
        System.out.println();

        //判断
        System.out.println("—————————————————————————判断———————————————————————————————");
        System.out.println(linkedList.contains(s1));
        System.out.println(linkedList.contains(new Student("张三",18)));
        System.out.println(linkedList.isEmpty());

        //获取元素下标
        System.out.println(linkedList.indexOf(s1));

    }
}

源码分析：

    transient int size = 0;//集合的大小

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;//链表的头节点

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;//链表的尾节点

//源码
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

//源码
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }