List集合简介与使用

List集合

• List是Collection的子接口

• List中常用的方法

  • add：添加。
  • addAll：添加一个集合到当前集合中来的行为。
  • remove：移除元素的行为。
  • clear：清空元素的行为。
  • iterator：得到集合迭代器的行为，通过迭代器可以遍历元素。
  • get：获取指定位置的元素。
  • size：获取元素个数的行为。

• List的实现类

  • ArrayList
  • LinkedList

ArrayList的使用

• ArrayList是一个泛型类，泛型约束了ArrayList的数据结构中存储元素的元素类型。任意类型就用Object。

• ArrayList中插入数据和存储元素的顺序是一致的。（数据可重复）

• ArrayList在底层是使用数组存储数据。

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

public class ArrayListDemo {
    public static void main(String[] args) {
        //获取list集合对象
        List<String> list = new ArrayList<String>();
        //添加数据
        list.add("abc");
        list.add("123");
        list.add("你好");
        list.add("abc");//ArrayList集合中可以添加可重复的数据
        //获取集合大小
        System.out.println("集合的大小是：" + list.size());
        System.out.println(list);

        //移除数据
        list.remove(3);//可以根据下标和元素，和索引一样

        //根据下标得到元素
        System.out.println(list.get(1));

        //清空集合中所有元素
        list.clear();

    }
}

LinkedList的使用

• 它的使用和ArrayList集合基本相同。
• LinkedList在底层是使用双向链表保存数据的。

import java.util.LinkedList;
import java.util.List;

public class LinkedListDemo {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<Integer>();

        list.add(1);
        list.add(2);
        list.add(3);

        list.remove(1);//通过下标移除元素。索引为1

        System.out.println(list.get(1));//因为2被移除，所以是3

        System.out.println(list);//[1, 3]

        list.clear();//清空

    }
}

Vector的使用(了解)

• 使用方法和ArrayList使用相同。
• 底层也是使用数组。
• Vector对数据的操作（add或者get）都是同步方法。（也就是可用于多线程）。
• 但是在线程中一般都使用ArrayList，自己添加同步方法，因此不使用。

下面写入加入自定义类的方法。

自定义类：

public class Person {
    private String name;
    private int age;
    private String address;

    public Person() {
    }

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

    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 String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

Vector类：

import java.util.List;
import java.util.Vector;

public class VectorDemo {
    public static void main(String[] args) {
        List<Person> list = new Vector<Person>();

        Person p1 = new Person("zhangsan", 18, "chengdu");
        Person p2 = new Person("lisi", 20, "chongqing");
        Person p3 = new Person("wangwu", 25, "beijing");

        list.add(p1);
        list.add(p2);
        list.add(p3);

        for (Person person : list) {
            System.out.println(person);
        }
    }
}

结果为：

Person{name='zhangsan', age=18, address='chengdu'}
Person{name='lisi', age=20, address='chongqing'}
Person{name='wangwu', age=25, address='beijing'}

List总结：

1. ArrayList（底层是数组，查询，修改元素时较快）。
2. LinkedList（底层是双向链表，增加，删除元素时速度较快）。
3. Vector（底层也是数组，线程安全的，自己同步，但是效率低）。
4. 其中的数据泛型，任意类型用Object，基本数据类型用封装类。
5. 添加元素的顺序与集合中存储数据的顺序相同。
6. 集合中可以添加重复的元素。
7. 可以添加null值，但是排序时不能使用。