Java入门：List集合

1List介绍:

List是Collection的子接口

在开发中一般使用List而不使用Collection，因为List不仅拥有Collection所有的方法，还有很多自己独有的方法

它是有序的可重复的。

1.1List独有的方法

1.2遍历List集合中的数据

1.2.1for循环

package com.ccx.Collection_1;

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

public class Demo3 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王麻子");
        list.add("麻五");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        
    }
}

1.2.2增强for循环

package com.ccx.Collection_1;

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

public class Demo3 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王麻子");
        list.add("麻五");
        for (String s : list) {
            System.out.println(s);
        }

    }
}

1.2.3迭代器

package com.ccx.Collection_1;

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

public class Demo3 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王麻子");
        list.add("麻五");

//        for (String s : list) {
//            System.out.println(s);
//        }
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next(););
        }
    }
}

1.3集合中存对象

package com.ccx.Collection_1;

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

public class Demo4 {
    public static void main(String[] args) {
        Collection <People> list = new ArrayList<>();
        list.add(new People("张三",18,'男'));
        list.add(new People("李四",19,'男'));
        list.add(new People("王五",20,'男'));
        list.add(new People("刘六",21,'男'));
        list.add(new People("牛七",22,'男'));
        Iterator <People>iterator = list.iterator();//迭代器
        while (iterator.hasNext()) {//使用while循环遍历，有快捷键itit
            Object next =  iterator.next();
            System.out.println(next);
        }
        //当while循环结束时候，迭代器的指针已经指到最后一个数据，再使用iterator.next();就会报异常
        //iterator.next();//会报异常NoSuchElementException
        //如果想要重新再遍历一遍的话，使用iterator = list.iterator();
        System.out.println(iterator);//第一个地址@1b6d3586
        System.out.println("=================第二遍遍历================");
        iterator = list.iterator();//这个时候iterator已经指向了另外一个地址
        while (iterator.hasNext()) {
            People next =  iterator.next();
            System.out.println(next);
        }
        System.out.println(iterator);//第二个地址@4554617c
        //获取指定下标的元素,下表为1的
        People people = list.get(1);
        System.out.println(prople.getName());
    }
}
class People{
    private String name;
    private int age;
    private char sex;

    public People(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {//重写Object的方法
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}

2ArrayList

ArrayList的底层是数组，可以自动扩容的，默认的容量是10，每次增长1.5倍。

特征：

查询快，增删慢。

开发的时候ArrayList用的多，因为开发查询用的比较多

2.2LinkedList

LinkedList的底层是双向链表

特征：

查询慢，增删快。

2.3Vector

Vector的底层也是数组

特征：

用于线程安全，相比而言效率较低

2.4三者的区别总结

ArrayList和Vector 底层是数组，但是Vector是线程安全的，所以效率底，开发中不用Vector
接下来介绍ArrayList和linkedListu区别:
    1.ArrayList底层是数组
     LinkedList底层是双向链表
    2.ArrayList 的特征：
        查询快： 底层是索引，有序的通过内存有序地址，直接找到 时间复杂度  o(1)
        增删慢： 增加数据和删除数据有可能扩容。每次扩1.5倍。扩容的话，浪费内存浪费时间o（n）
    3.LinkedList的特征：
        查询慢：底层是二分法查找的算法 时间复杂度是log以2为底 n的对数
        增删快：直接找前置结点 Node prev，后继结点 Node next
        。时间复杂度是 o(1)
    所以开发时候的用ArrayList

3List常用的方法

返回值类型	方法名	方法用法
boolean	add（E e）	添加一个数据到集合中
boolean	addAll（Collection<? extends E> c）	添加一个集合数据到这个集合中
boolean	remove（Object obj）	删除一个指定的数据
boolean	removeAll（Collection<? extends E> c）	删除所有和指定的集合数据重复的数据
void	clear（）	清空
int	size（）	查询集合中元素的个数
Object []	toArray（）	把集合转为数组
boolean	contains（Object obj）	查询集合中是否存在指定的数据
boolean	containsAll（Collection<? extends E> c）	查询集合中是否存在指定的集合的数据
boolean	isEmpty（Collection<? extends E> c）	判断集合是否为空
void	add(int index, E e);	在指定的位置上插入一个元素
boolean	addAll(int index, Collection<? extends E> e);	将一个集合插入到另外一个集合的指定的位置
E	remove(int index);	通过索引来删除指定的元素。返回的是被删除的元素
E	set(int index, E e);	通过指定的索引修改数据元素，返回值是被修改的原数据
E	get(int index);	通过索引下标去获取指定元素
int	indexOf(Object obj);	通过元素获取它第一次出现的下标
int	lastIndexOf(object obj);	通过元素获取最后一次出现的元素的下标
List<E>	subList(int formIndex, int toIndex);	截取一部分出来[前，后)

占位