java学习之集合（二）-CSDN博客

本文链接：https://blog.csdn.net/walker_sis/article/details/123140095

List实现类

ArrayList(重点)；数组列表集合：

数据结构实现，查询快，增删慢；
JDk1.2版本，运行效率快，线程不安全；

ArrayList源码分析：

默认容量：DEFAULT_CAPACITY = 10；
如果没有向数组中任何添加元素时，容量为0;t添加任意一个元素之后，数组容量是10；每次扩容大小是原来的1.5倍。
存放数组元素的数组：elementData
实际的元素个数： size;

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

Vector类：

数据结构实现，查询快，增删慢；
JDK1.1版本，运行效率慢，线程安全。

LinkList

链表结构实现，增删快，查询慢。

不同结构的实现方式：

ArrayList:

存储结构是数组
开辟的是连续的空间
查询快，增删慢

LinkedList:

存储结构式双向链表
开辟的离散的空间
查询慢，增删快；

ArrayList方法的使用：

package hai.bok.jh.coll.Dem02;

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

public class Test01 {
    /**
     *  ArrayList 的使用
     *
     *
     * @author hwy
     */
    public static void main(String[] args) {
        //1.创建集合
        ArrayList arrayList=new ArrayList();

        //2.添加元素
        Student s1=new Student("刘德华",20);
        Student s2=new Student("郭富城",22);
        Student s3=new Student("梁朝伟",18);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
//        arrayList.add(s3);
        System.out.println("arrayList = " + arrayList.size());
        System.out.println( arrayList.toString() );


        //3.删除元素
        arrayList.remove(new Student("刘德华",20));
        System.out.println("arrayList = " + arrayList.size());
        System.out.println("删除之后= " + arrayList.size());
        //4.遍历元素（重点）
        //4.1使用迭代器
        System.out.println("-----------4.1使用迭代器-----------");
        Iterator it = arrayList.iterator();
        while(it.hasNext()){
            Student s=(Student) it.next();
            System.out.println(s.toString());
        }
        //4.2使用列表迭代器
        ListIterator lit=arrayList.listIterator();
        System.out.println("-----------4.2使用列表迭代器------------");
        while(lit.hasNext()){
            Student s=(Student) lit.next();
            System.out.println(s.toString());
        }
        System.out.println("-----------4.2使用列表迭代器逆序------------");
        while(lit.hasPrevious()){
            Student s=(Student)lit.previous();
            System.out.println(s.toString());
        }
        //5.判断
        //这里是true，因为重写了equals方法，比较不再是地址，而是内容。
        System.out.println("arrayList = " + arrayList.contains(new Student("梁朝伟",18)));

        //6.查找
        System.out.println(arrayList.indexOf(s2));

    }
}

Vector 方法的使用

package hai.bok.jh.coll.dem03;

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

public class Test01 {
    /**
     * 演示Vector集合的使用，
     * 存储结构：数组
     * @author wlh
     */
    public static void main(String[] args) {
        //创建集合
        Vector vector=new Vector();
        //1.添加元素
        vector.add("芒果");
        vector.add("草莓");
        vector.add("西瓜");
        System.out.println("元素个数："+vector.size());

        //2.删除
/*        vector.remove(0);
        vector.remove("西瓜");
        System.out.println("元素个数："+vector.size());
        vector.clear();*/

        //3.遍历
        //使用枚举器
        Enumeration en = vector.elements();
        while(en.hasMoreElements()){
            String obj=(String) en.nextElement();
            System.out.println("obj = " + obj);
        }
        //4.判断（为空，是否包含某一元素，）
        System.out.println(vector.contains("西瓜"));
        System.out.println(vector.isEmpty());
        //Vector的其他的一些方法
        //firstElement LastElenment ElementAt()
        System.out.println(vector.firstElement());
        System.out.println(vector.lastElement());
        System.out.println(vector.elementAt(2));


    }
}

LinkedList的方法

Student类

package com.coll.dem01;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类

package com.coll.dem01;

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

public class Test01 {
    /**
     *LinkedList集合的使用
     * 存储结构：双向链表
     * @auther:wlh
     */
    public static void main(String[] args) {
        LinkedList linkedList=new LinkedList<>();
        //1.添加元素
        Student s1=new Student("刘德华",20);
        Student s2=new Student("郭富城",22);
        Student s3=new Student("梁朝伟",18);
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        linkedList.add(s2);
        System.out.println("元素个数为：" + linkedList.size());
        System.out.println(linkedList.toString());

        //2.删除
/*        linkedList.remove(s1);
        System.out.println("删除之后："+linkedList.toString());
        linkedList.clear();*/

        //3.遍历
        //3.1使用for遍历。
        System.out.println("---------------使用for-------------");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        //3.2使用增强for
        System.out.println("---------------使用增强for-------------");
        for (Object object:linkedList) {
            Student s=(Student)object;
            System.out.println(s.toString());
        }
        //3.3使用迭代器
        System.out.println("---------------迭代器-------------");
        Iterator it=linkedList.iterator();
        while(it.hasNext()){
           Student s=(Student)it.next();
            System.out.println(s);
        }
        //3.4使用LinkedIterator迭代器
        System.out.println("--------------使用ListIterator迭代器-------------");

        ListIterator lit=linkedList.listIterator();
        while(lit.hasNext()){
            Student s=(Student)lit.next();
            System.out.println(s);
        }
        //4.判断
        System.out.println(linkedList.contains(s2));
        System.out.println(linkedList.isEmpty());
        //5.获取(元素的下标的位置)
        System.out.println(linkedList.indexOf(s3));
    }


}