Java_List(ArrayList && LinkedList)

1集合(Collection)

概念：对象的容器，定义了对多个对象进行操作的常用的方法。可实现数组的功能。
集合和数组的区别：1数组长度固定，集合长度不固定；2数组可以存储基本类型和引用类型，集合只能引用类型。
位置：java.util.*

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

/**
 * Collection接口的使用（一）
 * 1.添加元素
 * 2.删除元素
 * 3.遍历元素
 * 4.判断
 */
public class Demo1{
    
    
    pubic static void main(String[] args){
    
    
        //创建集合
        Collection collection=new ArrayList();        
//      * 1.添加元素
        Collection.add("苹果");
        Collection.add("西瓜");
        Collection.add("榴莲");
        System.out.println("元素个数："+collection.size());
        System.out.println(collection);
//      * 2.删除元素
        collection.remove("榴莲");
        System.out.println("删除之后："+collection.size());
//      * 3.遍历元素
        //3.1 使用增强for 
        for(Object object : collection){
    
    
            System.out.println(object);
        }
        //3.2 使用迭代器（迭代器专门用来遍历集合的一种方式）
        //hasnext();判断是否有下一个元素
        //next();获取下一个元素
        //remove();删除当前元素
        Iterator iterator=collection.Itertor();
        while(iterator.hasnext()){
    
    
            String object=(String)iterator.next();
            System.out.println(s);
            //删除操作
            //collection.remove(s);引发错误：并发修改异常 ConcurrentModificationException
            iterator.remove();应使用迭代器的方法 
//      * 4.判断
        System.out.println(collection.contains("西瓜"));//true
        System.out.println(collection.isEmpty());//false
        }
    }
}

List

特点：有序、有下标、元素可以重复。
方法：
void add(int index,Object o) //在index位置插入对象o。
boolean addAll(index,Collection c) //将一个集合中的元素添加到此集合中的index位置。
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子接口的使用（一）
 * 特点：1.有序有下标 2.可以重复
 *
 * 1.添加元素
 * 2.删除元素
 * 3.遍历元素
 * 4.判断
 * 5.获取位置
 */
public class Test {
    
    
    public static void main(String[] args) {
    
    
        List list=new ArrayList<>();
        //1.添加元素
        list.add("tang");
        list.add("he");
        list.add(0,"yu");//插入操作
        System.out.println("元素个数："+list.size());
        System.out.println(list);
        //2.删除元素
        list.remove(0);
        //list.remove("yu");结果同上
        System.out.println("删除之后："+list.size());
        System.out.println(list);
        //3.遍历元素
        //3.1 使用for遍历
        for(int i=0;i<list.size();++i) {
    
    
            System.out.println(list.get(i));
        }
        //3.2 使用增强for
        for(Object object:list) {
    
    
            System.out.println(object);
        }
        //3.3 使用迭代器
        Iterator iterator=list.iterator();
        while (iterator.hasNext()) {
    
    
            System.out.println(iterator.next());
        }
        //3.4使用列表迭代器，listIterator可以双向遍历，添加、删除及修改元素。
        ListIterator listIterator=list.listIterator();
        //从前往后
        while (listIterator.hasNext()) {
    
    
            System.out.println(listIterator.next());
        }
        //从后往前（此时“遍历指针”已经指向末尾）
        while(listIterator.hasPrevious()) {
    
    
            System.out.println(listIterator.previous());
        }
        //4.判断
        System.out.println(list.isEmpty());
        System.out.println(list.contains("tang"));
        //5.获取位置
        System.out.println(list.indexOf("tang"));
    }
}

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

/**
 * List子接口的使用（二）
 * 1.添加元素
 * 2.删除元素
 * 3.遍历元素
 * 4.判断
 * 5.获取位置
 */
public class Test {
    
    
    public static void main(String[] args) {
    
    
        List list=new ArrayList();
        //1.添加数字数据（自动装箱）
        list.add(20);
        list.add(20);
        list.add(30);
        list.add(30);
        list.add(40);
        list.add(50);
        System.out.println("元素个数："+list.size());
        System.out.println(list);
        //2.删除元素
        list.remove(0);
        //list.remove(20);很明显数组越界错误，改成如下
        //list.remove(Object(20));
        //list.remove(new Integer(20));
        System.out.println("元素个数："+list.size());
        System.out.println(list);
        //3-5不再演示，与之前类似
        //6.补充方法subList，返回子集合，含头不含尾
        List list2=list.subList(1, 3);
        System.out.println(list2);
        System.out.println(list.indexOf(30));
        System.out.println(list.lastIndexOf(30));
    }
}

ArrayList

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

/**
 * ArrayList的使用
 * 存储结构：数组；
 * 特点：查找遍历速度快，增删慢。
 * 1.添加元素
 * 2.删除元素
 * 3.遍历元素
 * 4.判断
 * 5.查找
 */
public class Test {
    
    
    public static void main(String[] args) {
    
    
        ArrayList arrayList=new ArrayList<>();
        //1.添加元素
        Student s1=new Student("唐", 21);
        Student s2=new Student("何", 22);
        Student s3=new Student("余", 21);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println("元素个数："+arrayList.size());
        System.out.println(arrayList);
        //2.删除元素
        arrayList.remove(s1);
        //arrayList.remove(new Student("唐", 21));
        //注：这样可以删除吗（不可以）？显然这是两个不同的对象。
        //假如两个对象属性相同便认为其是同一对象，那么如何修改代码？
        //3.遍历元素
        //3.1使用迭代器
        Iterator iterator=arrayList.iterator();
        while(iterator.hasNext()) {
    
    
            System.out.println(iterator.next());
        }
        //3.2使用列表迭代器
        ListIterator listIterator=arrayList.listIterator();
        //从前往后遍历
        while(listIterator.hasNext()) {
    
    
            System.out.println(listIterator.next());
        }
        //从后往前遍历
        while(listIterator.hasPrevious()) {
    
    
            System.out.println(listIterator.previous());
        }
        //4.判断
        System.out.println(arrayList.isEmpty());
        //System.out.println(arrayList.contains(new Student("何", 22)));
        //注：与上文相同的问题。
        //5.查找
        System.out.println(arrayList.indexOf(s1));
    }
}

抛出的问题：假如两个对象属性相同便认为其是同一对象，那么如何修改代码？
Object里的equals(this==obj)用地址和当前对象比较，如果想实现代码中的问题，可以在学生类中重写equals方法

@Override
public boolean equals(Object obj) {
    
    
	//1.是否为同一对象
	if (this==obj) {
    
    
		return true;
	}
	//2.判断是否为空
	if (obj==null) {
    
    
		return false;
	}
	//3.判断是否是Student类型
	if (obj instanceof Student) {
    
    
		Student student=(Student) obj;
		//4.比较属性
		if(this.name.equals(student.getName())&&this.age==student.age) {
    
    
			return true;
		}
	}
	//不满足，返回false
	return false;
}

ArrayList源码分析

默认容量大小：private static final int DEFAULT_CAPACITY = 10;
注意：如果没有向集合中添加任何元素时，容量是0；添加一个元素之后容量为10.
存放元素的数组：transient Object[] elementData;
实际元素个数：private int size;
创建对象时调用的无参构造函数：

ArrayList就讲解得差不多了，当数组长度为10的时候你们可以试着过一下源码，查一下每次的增量是多少（答案是每次扩容为原来的1.5倍）。

Vector

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

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

/**
 * Vector的演示使用
 *
 *1.添加数据
 *2.删除数据
 *3.遍历
 *4.判断
 */
public class Test {
    
    
    public static void main(String[] args) {
    
    
        Vector vector=new Vector<>();
        //1.添加数据
        vector.add("tang");
        vector.add("he");
        vector.add("yu");
        System.out.println("元素个数："+vector.size());
        //2.删除数据
        /*
         * vector.remove(0); vector.remove("tang");
         */
        //3.遍历
        //使用枚举器
        Enumeration enumeration=vector.elements();
        while (enumeration.hasMoreElements()) {
    
    
            String s = (String) enumeration.nextElement();
            System.out.println(s);
        }
        //4.判断
        System.out.println(vector.isEmpty());
        System.out.println(vector.contains("he"));
        //5. Vector其他方法
        //firstElement()  lastElement()  ElementAt();
    }
}

LinkedList

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

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

/**
 * LinkedList的用法
 * 存储结构：双向链表
 * 1.添加元素
 * 2.删除元素
 * 3.遍历
 * 4.判断
 */
public class Test {
    
    
    public static void main(String[] args) {
    
    
        LinkedList linkedList=new LinkedList<>();
        Student s1=new Student("唐", 21);
        Student s2=new Student("何", 22);
        Student s3=new Student("余", 21);
        //1.添加元素
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        linkedList.add(s3);
        System.out.println("元素个数："+linkedList.size());
        System.out.println(linkedList);
        //2.删除元素
        /*
         * linkedList.remove(new Student("唐", 21));
         * System.out.println(linkedList.toString());
         */
        //3.遍历
        //3.1 使用for
        for(int i=0;i<linkedList.size();++i) {
    
    
            System.out.println(linkedList.get(i));
        }
        //3.2 使用增强for
        for(Object object:linkedList) {
    
    
            Student student=(Student) object;
            System.out.println(student.toString());
        }
        //3.3 使用迭代器
        Iterator iterator =linkedList.iterator();
        while (iterator.hasNext()) {
    
    
            Student student = (Student) iterator.next();
            System.out.println(student.toString());
        }
        //3.4 使用列表迭代器（略）
        //4. 判断
        System.out.println(linkedList.contains(s1));
        System.out.println(linkedList.isEmpty());
        System.out.println(linkedList.indexOf(s3));
    }
}

LinkedList源码分析

LinkedList首先有三个属性：
链表大小：transient int size = 0;
（指向）第一个结点/头结点：transient Node first;
（指向）最后一个结点/尾结点：transient Node last;
关于Node类型我们再进入到类里看看：

扫描二维码关注公众号，回复： 12496713 查看本文章

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;
    }
}

ArrayList和LinkedList区别