Java 集合(List与LinkedList)接口详解

List接口

List接口的定义
List interface List extends Collection
通过观察List接口的定义发现其继承得是Collection接口
List、Set、Queue接口继承的都是Collection接口
Collection接口常用方法

1. public boolean add(E e);  //添加元素到集合
2. public boolean addAll(Collection<? extends E> c); //存放一个集合
3. public boolean contains(Object o);  //查找集合中的元素
4. public boolean isEmpty();  //判断一个集合是否为空
5. public boolean remove(Object 0);//删除一个集合中的元素
6. public int size();//返回集合的长度

List接口中的方法
List接口拓展了Collection接口中的方法

1. public E get(int index); //根据索引取得元素
2. public E set(int index,E element);//替换元素，index为要替换元素下标 element为要替换元素
3. public ListIterator<E> listIterator() List //List自己的迭代器

List 接口的特点是：可重读的，有序的

使用List list本身是一个接口，如果想要使用一个接口则可以使用该接口的实现类完成
重点实现类：ArrayList LinkedList Vector

package java8_7.Collection.List;

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

public class ArrayListDemo {
    public static void main(String[] args) {
        List<Integer> list =new ArrayList<>();
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(4);

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

运行结果为

4
5
6
4

可见，ArrayList 的特点是可重复的，有序的，顺序就是储存添加时候的数据
通过一个add 添加到集合，通过get(index)取出集合中的元素 下标的位置从0开始

其他的一些方法

 package java8_7.Collection.List;

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

public class ListDemo2_function {
    public static void main(String[] args) {
        List<Integer> array = new ArrayList<>();
        System.out.println("array是否为空："+array.isEmpty());
        array.add(4);
        array.add(5);
        array.add(5);
        System.out.println(array.remove(1));
        array.add(1);
        System.out.println(array.isEmpty());
        System.out.println(array);
    }
}

执行结果为

array链表是否为空：true
5
false
[4, 5, 1]

可见ArrayList是一个对象数组，每次增加的时候，会给数组扩容，数组长度是不能改变的，每次扩容数组内容拷贝工作，但是一个ArrayList如果频繁添加内容，效率不高。但是查询的时候由于底层是数组，所以查询效率很高。
并期添加数组都是从链表后方加，不会添加到链表中间位子

public class Person {
    private String name;
    private int age;
    public Person(String name ,int age){
        this.name=name;
        this.age=age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "name:"+name+"age"+age;
    }

    @Override
    public boolean equals(Object obj) {    // 传进来要比较的内容
        // TODO Auto-generated method stub

        Person per=null;   
        if(obj instanceof Person) {

            per=(Person)obj;  // Object 向下转型 为 Person类型
        }
        // this 当前的对象 Person  和 传进来的Person比较
        if(this==per) {  //内存地址 一样肯定是同样对象 

            return true;
        }

        if(this.age==per.age&&this.name.equals(per.name)) {

            return true;
        }

        return false;
    }
}

重写Object中的equals方法 判断两个对象是否相同的语句为per=(Person)obj
若相同再比较this==per this里面有两个属性，即name age
写一个测试类

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

public class TestPerson {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("和尚",20));
        list.add(new Person("jacky",30));
        list.add(new Person("Sanny",40));
        System.out.println(list.remove(new Person("Sanny",40)));
        System.out.println(list.contains(new Person("和尚",20)));
        for (Person per:list
             ) {
            System.*out*.println(per);
        }

    }
}

结果：

true
true
name:和尚,age20
name:jacky,age30

通过代码，发现自定义类的时候，必须覆写equals()方法才能完成集合中对对象查找和删除，主要是在于进行对象删除的时候，集合中会判断传入的元素和集合本身是否是内容相同的元素，只有相同才会删除或者查找

---

LinkedList接口

这个子类是基于链表的体现 指针节点的形式 指针-节点->>
LinkedList也是可重复的有序的，顺序是储存顺序
以下为LinkedList类的定义
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>,Cloneable,Serializable
接口定义：标准、能力、对外暴露方法
Cloneable 进行对象克隆的时候，必须实现接口，才有克隆的能力
Serializable：要实现序列化的类，必须实现接口才能能有序列化的的能力

特点： 插入方便，任意节点之间都可以插入，但是查询并不方便，效率不高
LinkedList的常用方法
1. public void addFirst(E e);
2. public void addList(E e);

import java.util.LinkedList;

public class LinkedListDemo1 {
    public static void main(String[] args) {
        LinkedList<String> list =new LinkedList<>() ;
        list.add("hello");
        list.add("world");
        list.add("java");
        list.addFirst("first");
        list.addLast("last");
        for (String str:list){
            System.*out*.println(str);
        }
    }

}

经过对比，ArrayList和LinkedList有什么区别？
1. ArrayList 是基于数组开发的，查询效率很高，但是修改数据效率会低一些
2. LinkedList 是基于链表开发的，两端插入的时候效率很高，但是查询效率会低一些