List接口（继承Collection）：存储有序的，可重复的数据------“动态”数组，可用来代替数组
-
实现类：
1、ArrayList：作为List的主要实现类，线程不安全，效率高，底层使用Object[] elementData存储。
2、LinkedList：底层使用双向链表存储。对于频繁的插入和删除操作，使用此类效率比ArrayList高
3、Vector：作为List接口的古老实现类，线程安全，效率低，底层使用Object[] elementData存储。
>*1. List接口框架
>*
>* |----Collection接口：单列集合，用来存储一个一个的对象
>* |----List接口：存储有序的、可重复的数据。 -->“动态”数组,替换原有的数组
>* |----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
>* |----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
>* |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储
>*
>*
>* 2. ArrayList的源码分析：
>* 2.1 jdk 7情况下
>* ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
>* list.add(123);//elementData[0] = new Integer(123);
>* ...
>* list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
>* 默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
>*
>* 结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
>*
>* 2.2 jdk 8中ArrayList的变化：
>* ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组
>*
>* list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
>* ...
>* 后续的添加和扩容操作与jdk 7 无异。
>* 2.3 小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象
>* 的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
>*
>* 3. LinkedList的源码分析：
>* LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null
>* list.add(123);//将123封装到Node中，创建了Node对象。
>*
>* 其中，Node定义为：体现了LinkedList的双向链表的说法
>* 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;
> }
> }
>*
>* 4. Vector的源码分析：jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
>* 在扩容方面，默认扩容为原来的数组长度的2倍。
>*
* 面试题：ArrayList、LinkedList、Vector三者的异同？
* 同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
* 不同：见上
- ArrayList类方法
常用：
增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：
① Iterator迭代器方式
② 增强for循环
③ 普通的循环
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ListTest {
@Test
public void test1(){
ArrayList list1 = new ArrayList();
list1.add(123);
list1.add(456);
list1.add("A");
list1.add(false);
list1.add(new Person("冯宏志",20));
System.out.println(list1);//[123, 456, A, false, Person{name='冯宏志', age=20}]
//void add(int index,Object ele):在index处插入ele元素
list1.add(1,2);
System.out.println(list1);//[123, 2, 456, A, false, Person{name='冯宏志', age=20}]
//void addAll(int index,Collection eles):从index位置开始将eles中的所有元素添加进来
List list2 = Arrays.asList("a","b");
list1.addAll(2,list2);
System.out.println(list1);//[123, 2, a, b, 456, A, false, Person{name='冯宏志', age=20}]`
System.out.println(list1.size());//8
//Object get(int index):获取指定index位置的元素
System.out.println(list1.get(0));//123
}
@Test
public void test2(){
ArrayList list1 = new ArrayList();
list1.add(123);
list1.add(456);
list1.add("A");
list1.add(false);
list1.add(new Person("冯宏志",20));
//int indexOf(Object obj):返回obj在集合中首次出现的位置,如果不存在，返回-1
System.out.println(list1.indexOf(456));//1
//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置,如果不存在，返回-1
list1.add(123);
System.out.println(list1.lastIndexOf(123));//5
//Object remove(int index)
Object removeEle = list1.remove(5);
System.out.println(removeEle);//123
//Object set(int index,Object ele):设置指定index位置的元素为ele
list1.set(0,1234);
System.out.println(list1.get(0));//1234
//List subList(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
List subList = list1.subList(1, 4);
System.out.println(subList);//[456, A, false]
}
}
@Test
public void test3(){//ArrayList遍历的三种方式
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
//方式一、Iterator迭代器方式
Iterator iterator1 = list.iterator();
while (iterator1.hasNext()){
System.out.println(iterator1.next() );
}
//方式二、增强for循环
for(Object obj : list )
System.out.println(obj);
//方式三、普通for循环
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
}
网友评论