Java--集合--List

Java–集合–Collection https://blog.csdn.net/lulu950817/article/details/79746721
Java–集合–Set：https://blog.csdn.net/lulu950817/article/details/79774258

List

---| Iterable     接口 
Iterator iterator()
----| Collection     接口
------| List      接口 元素可以重复，允许在指定位置插入元素，并通过索引来访问元素

1. List集合特有方法

1：增加
        void add(int index, E element) 指定位置添加元素            
        boolean addAll(int index, Collection c) 指定位置添加集合  
2：删除
        E remove(int index) 删除指定位置元素

3：修改
        E set(int index, E element)    返回的是需要替换的集合中的元素
4：查找：
        E get(int index)             注意： IndexOutOfBoundsException
        int indexOf(Object o)         // 找不到返回-1
        lastIndexOf(Object o) 
5：求子集合
         List<E> subList(int fromIndex, int toIndex) // 不包含toIndex   

1.1. 增加

public static void main(String[] args) {
        List list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // add,在0角标位置添加一本书
        list.add(0, "舒克和贝塔");
        System.out.println(list);
        // 在list2集合的1角标位置添加list集合元素
        List list2 = new ArrayList();
        list2.add("史记");
        list2.add("资治通鉴");
        list2.add("全球通史");
        boolean addAll = list2.addAll(1, list);
        System.out.println(addAll); //true       System.out.println(list2);
    }

1.2. 删除

public static void main(String[] args) {
        List list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // 删除0角标元素
        Object remove = list.remove(0);
        System.out.println(remove);
    }

1.3. 修改：

public static void main(String[] args) {
        List list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // 修改2角标位置的书，返回的原来2角标位置的书
        Object set = list.set(2, "边城");
        System.out.println(set); //java编程思想
        System.out.println(list); 

    }

1.4. 查找

public static void main(String[] args) {
        List list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        list.add("java编程思想");
        System.out.println(list);
        // 查找： E get(int index) 注意角标越界
        Object set = list.get(list.size() - 1);
        System.out.println(set); // java语言程序设计
        System.out.println(list);
        // list.get(list.size()); //IndexOutOfBoundsException

// indexOf(Object o) 返回第一次出现的指定元素的角标
        int indexOf = list.indexOf("java编程思想");
        System.out.println(indexOf); // 2
        // 没有找到，返回-1
        int indexOf2 = list.indexOf("三国志");
        System.out.println(indexOf2); // -1

// lastIndexOf 返回最后出现的指定元素的角标
        int lastIndexOf = list.lastIndexOf("java编程思想");
        System.out.println(lastIndexOf); // 5
    }

2. ArrayList

--| Iterable
----| Collection
------| List
---------| ArrayList  底层采用数组实现，默认10。每次增长60%,((oldCapacity*3)/2 +1) 查询快，增删慢。
---------| LinkedList          

ArrayList:实现原理：

数组实现, 查找快, 增删慢

数组为什么是查询快?

因为数组的内存空间地址是连续的.

1、ArrayList底层维护了一个Object[] 用于存储对象，默认数组的长度是10。可以通过 new ArrayList(20)显式的指定用于存储对象的数组的长度。
2、当默认的或者指定的容量不够存储对象的时候，容量自动增长为原来的容量的1.5倍。
3、由于ArrayList是数组实现, 在增和删的时候会牵扯到数组增容, 以及拷贝元素， 所以慢。数组是可以直接按索引查找, 所以查找时较快。
4、可以考虑，假设向数组的0角标未知添加元素，那么原来的角标位置的元素需要整体往后移，并且数组可能还要增容，一旦增容，就需要要将老数组的内容拷贝到新数组中，所以数组的增删的效率是很低的。

练习：去除ArrayList集合中重复元素
1：存入字符串元素
2：存入自定义对象元素（如Perosn对象）

原理：
循环遍历该集合，每取出一个放置在新的集合中，放置之前先判断新的集合是否以包含了新的元素。

思路:
存入人的对象.
1先定义person 类
2将该类的实例存入集合
3 将对象元素进行操作. 注意:自定义对象要进行复写toString 和 equals 方法.
为什么? 因为object 是person 的父类,object 中的toString 返回的是哈希值,object 类中equals方法比较的是对象的地址值.

思路
1存入字符串对象
2存入自定义对象 如person
2创建容器,用于存储非重复元素
3对原容器进行遍历,在遍历过程中进行判断遍历到的元素是否在容器中存在.(contains)
4如果存在,就不存入,否则存入.
5 返回新容器

public class Demo6 {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList();
        Person p1 = new Person("jack", 20);
        Person p2 = new Person("rose", 18);
        Person p3 = new Person("rose", 18);
        arr.add(p1);
        arr.add(p2);
        arr.add(p3);
        System.out.println(arr);
        ArrayList arr2 = new ArrayList();
        for (int i = 0; i < arr.size(); i++) {
            Object obj = arr.get(i);
            Person p = (Person) obj;
            if (!(arr2.contains(p))) {
                arr2.add(p);
            }
        }
        System.out.println(arr2);
    }
}

class Person {
    private String name;
    private int age;
    public Person() {

}

    public Person(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 int hashCode() {
        return this.name.hashCode() + age * 37;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person) obj;

        return this.name.equals(p.name) && this.age == p.age;
    }

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

}

在实际的开发中ArrayList是使用频率最高的一个集合。

3. LinkedList

--| Iterable
----| Collection
------| List
---------| ArrayList  底层采用数组实现，默认10。每次增长60%,（(oldCapacity * 3)/2 + 1） 查询快，增删慢。
---------| LinkedList  底层采用链表实现，增删快，查询慢。

LinkedList:链表实现, 增删快, 查找慢
由于LinkedList 在内存中的地址不连续,需要让上一个元素记住下一个元素.所以每个元素中保存的有下一个元素的位置.虽然也有角标,但是查找的时候,需要从头往下找,显然是没有数组查找快的.但是,链表在插入新元素的时候,只需要让前一个元素记住新元素,让新元素记住下一个元素就可以了.所以插入很快.
由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高。
但查询时需要一个一个的遍历, 所以效率较低。

特有方法

1：方法介绍
addFirst(E e) 
addLast(E e) 
getFirst() 
getLast() 
removeFirst() 
removeLast() 
如果集合中没有元素，获取或者删除元素抛：NoSuchElementException
2：数据结构
        1：栈 （1.6）
            先进后出
            push() ---addFirst()
            pop()  ---removeFirst()
        2：队列（双端队列1.5）
            先进先出
            offer() ---addLast()
            poll()  ---removeFirst()
3：返回逆序的迭代器对象      
            descendingIterator()   返回逆序的迭代器对象

基本方法

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

public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("西游记");
        list.add("三国演义");
        list.add("石头记");
        list.add("水浒传");
        list.add("全球通史");
        list.addFirst("史记");
        list.addLast("呐喊");
        // list.addFirst(null);
        // list.addLast(null);
        System.out.println(list);
        // 获取指定位置处的元素。
        String str = (String) list.get(0);
        // 返回此列表的第一个元素。
        String str2 = (String) list.getFirst();
        System.out.println(str.equals(str2));

   // 获取指定位置处的元素。
        String str3 = (String) list.get(list.size() - 1);
        // 返回此列表的最后一个元素。
        String str4 = (String) list.getLast();
        System.out.println(str3.equals(str4));

// 获取但不移除此列表的头（第一个元素）。
        Object element = list.element();
        System.out.println(element);

        int size = list.size();
        System.out.println(size);
}

迭代

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

public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("西游记");
        list.add("三国演义");
        list.add("石头记");
        list.add("水浒传");
        list.add("全球通史");
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String next = (String) it.next();
            System.out.println(next);
        }
    }
}

逆序迭代

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

public class Demo6 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        Iterator dit = list.descendingIterator();
        while (dit.hasNext()) {
            System.out.println(dit.next());
        }
    }
}

注意：可以使用该集合去模拟出队列(先进先出) 或者堆栈(后进先出) 数据结构。
堆栈(后进先出)
//堆栈(后进先出) 数据结构

public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        // 压栈，先进后出
        list.push("西游记");
        list.push("三国演义");
        list.push("石头记");
        list.push("水浒传");
        System.out.println(list);
        // 弹栈
        String str1 = (String) list.pop();
        System.out.println(str1);
        String str2 = (String) list.pop();
        System.out.println(str2);
        String str3 = (String) list.pop();
        System.out.println(str3);
        String str4 = (String) list.pop();
        System.out.println(str4);
        System.out.println(list.size());// 0
        System.out.println(list); //[]
    }
}

队列，先进先出

import java.util.LinkedList;

public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        // 队列，先进先出
        list.offer("西游记");
        list.offer("三国演义");
        list.offer("石头记");
        list.offer("水浒传");
        System.out.println(list);
        // 出队列
        System.out.println(list.poll());
        System.out.println(list.poll());
        System.out.println(list.poll());
        System.out.println(list.poll());

System.out.println(list.size());

System.out.println(list.peek()); // 获取队列的头元素，但是不删除
System.out.println(list.peekFirst()); // 获取队列的头元素，但是不删除
System.out.println(list.peekLast()); // 获取队列的最后一个元素但是不删除

    }
}

ArrayList 和 LinkedList的存储查找的优缺点：
1、ArrayList 是采用动态数组来存储元素的，它允许直接用下标号来直接查找对应的元素。但是，但是插入元素要涉及数组元素移动及内存的操作。总结：查找速度快，插入操作慢。
2、LinkedList 是采用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快
问题：有一批数据要存储，要求存储这批数据不能出现重复数据，ArrayList、LinkedList都没法满足需求。解决办法：使用 set集合。

4. Vector

Vector: 描述的是一个线程安全的ArrayList。

ArrayList： 单线程效率高
Vector ： 多线程安全的，所以效率低

特有的方法：

 void addElement(E obj)  在集合末尾添加元素
 E elementAt( int index) 返回指定角标的元素
 Enumeration elements()  返回集合中的所有元素，封装到Enumeration对象中

Enumeration 接口：

 boolean hasMoreElements() 
          测试此枚举是否包含更多的元素。 
  E nextElement() 
          如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

public static void main(String[] args) 
    {
        Vector v = new Vector();
        v.addElement("aaa");
        v.addElement("bbb");
        v.addElement("ccc");
        System.out.println( v );
        System.out.println( v.elementAt(2) );   // ccc
        // 遍历Vector遍历
        Enumeration ens = v.elements();
        while ( ens.hasMoreElements() )
        {
            System.out.println( ens.nextElement() );
        }
    }