Java数据结构-列表List

List
-有序的Collection
-允许重复元素

List主要实现
-ArrayList（非同步）
-LinkedList（非同步）
-Vector（同步）

ArrayList
-以数组实现的列表，不支持同步
-利用索引的位置可以快速定位访问
-不适合指定位置的插入和删除动作
-适合变动不大，主要用于查询的数据
-和Java数组相比，其容量是可动态调整的
-ArrayList在元素填满容器是会自动扩充容器大小的50%
——————————————————————————————————
/**

• @author ppf

• @create 2020/08/16/21:52
  */
  public class ArrayListTest {
  public static void main(String[] args) {
  ArrayList a = new ArrayList();
  a.add(1);
  a.add(2);
  a.add(3);
  a.add(4);
  a.add(5);
  a.add(new Integer(6));
  System.out.println(“the third element is” + a.get(2));
  a.remove(3);//删除第四个元素，后面元素往前移动
  a.add(3, 7);//将7插入到第四个元素，后面元素往后移动
  ArrayList a1 = new ArrayList();
  for (int i = 0; i < 100000; i++) {
  a1.add(i);
  }
  traverseByIterator(a1);
  traverByIndex(a1);
  traverByfor(a1);
  }

  public static void traverseByIterator(ArrayList a) {
  long startTime = System.nanoTime();//返回可用系统计时器的当前值
  System.out.println(“迭代器遍历”);
  Iterator iter1 = a.iterator();
  while (iter1.hasNext()) {//如果仍有元素迭代，则返回true
  iter1.next();
  }
  long endTime = System.nanoTime();
  long duration = endTime - startTime;
  System.out.println(duration);//19180500ms
  }
  public static void traverByIndex(ArrayList a){
  long startTime = System.nanoTime();
  System.out.println(“随机索引值遍历”);
  for(int i=0; i<a.size(); i++){
  a.get(i);
  }
  long endTime = System.nanoTime();
  long duration = endTime - startTime;
  System.out.println(duration);//10717500ms
  }
  public static void traverByfor(ArrayList a){
  long startTime = System.nanoTime();
  System.out.println(“for循环遍历”);
  for(Integer item: a){
  ;
  }
  long endTime = System.nanoTime();
  long duration = endTime - startTime;
  System.out.println(duration);//17328300ms
  }
  }

LinkedList
-以双向链表实现的列表，不支持同步
-可被当做堆栈，队列和双端队列进行操作
-顺序高效，随机访问，中间插入和删除高效
-适用于经常变化的数据
-不可以采用随机位置的访问
————————————————————————————————
import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
LinkedList ll = new LinkedList();
ll.add(0);
ll.add(1);
ll.add(2);
ll.add(3);
ll.add(4);
ll.add(new Integer(5));
System.out.println(ll.size());
LinkedList list = new LinkedList();
for(int i=0; i<100000; i++) {
list.add(i);
}
traverseByIterator(list);
traverByIndex(list);
traverByfor(list);
}
public static void traverseByIterator(LinkedList list) {
long startTime = System.nanoTime();//返回可用系统计时器的当前值
System.out.println(“迭代器遍历”);
Iterator iter1 = list.iterator();
while (iter1.hasNext()) {//如果仍有元素迭代，则返回true
iter1.next();
}
long endTime = System.nanoTime();
long duration = endTime - startTime;
System.out.println(duration);//12270100ms
}
public static void traverByIndex(LinkedList list){
long startTime = System.nanoTime();
System.out.println(“随机索引值遍历”);
for(int i=0; i<list.size(); i++){
list.get(i);
}
long endTime = System.nanoTime();
long duration = endTime - startTime;
System.out.println(duration);//7564343800ms
}
public static void traverByfor(LinkedList list){
long startTime = System.nanoTime();
System.out.println(“for循环遍历”);
for(Integer item: list){
;
}
long endTime = System.nanoTime();
long duration = endTime - startTime;
System.out.println(duration);//14708700ms
}
}

ArrayList和LinkedList比较
——————————————————————————
import java.util.ArrayList;
import java.util.LinkedList;

public class LInkCompareTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
int times = 10*100;
ArrayList al = new ArrayList();
LinkedList ll = new LinkedList();
System.out.println(“time”+times);
System.out.println("____________");
//ArrayList add //ArrayList会发生大面积的移动，ArrayList是数组形式的存在
long startTime = System.nanoTime();
for(int i=0; i<times; i++) {
al.add(0,i);
}
long endTime = System.nanoTime();
long duration = endTime - startTime;
System.out.println(duration); //1440800
//LinkedList add //LinkedList是双向链表，直接是指针指向，添加容易
startTime = System.nanoTime();
for(int i=0; i<times; i++) {
ll.add(0,i);
}
endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println(duration); //940200
//ArrayList get //for循环位置访问，ArrayList效果会好
startTime = System.nanoTime();
for(int i=0; i<times; i++) {
al.get(i);
}
endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println(duration); //176200
//LinkedList get //位置访问表现比较差
startTime = System.nanoTime();
for(int i=0; i<times; i++) {
ll.get(i);
}
endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println(duration); //1882400
//ArrayList remove
startTime = System.nanoTime();
for(int i=0; i<times; i++) {
al.remove(0);
}
endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println(duration); //899300
//LinkedList remove
startTime = System.nanoTime();
for(int i=0; i<times; i++) {
ll.remove(0);
}
endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println(duration); //599600
}
}
ArrayList适用于较多查询的静态数据，根据位置索引快速查询
LinkedList适用于频繁增删的数据

Vector（同步）
-与ArrayList类似，可变数组实现的列表
-Vector同步，适合在多线程下使用
-原先不属于JCF框架，性能较差
-官方文档建议在非同步情况下，优先使用ArrayList
——————————————————————————————————————
import java.util.*;
public class VectorTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Vector< Integer> v = new Vector< Integer>();
v.add(0);
v.add(1);
v.add(2);
v.add(3);
System.out.println(v);
v.remove(2);
v.add(2,3);
System.out.println(v);
Vector< Integer> v2 = new Vector< Integer>(100000);
for(int i=0; i<100000; i++) {
v2.add(i);
}
traverseByIterator(v2);
traverseByIndex(v2);
traverseByFor(v2);
traverseByEnumeration(v2);
}
public static void traverseByIterator(Vector< Integer> v) {
long startTime = System.nanoTime();
Iterator< Integer> iter = v.iterator();
while(iter.hasNext()) {
iter.next();
}
long endTime = System.nanoTime();
long duration = endTime - startTime;
System.out.println(duration); ///13916900
}
public static void traverseByIndex(Vector< Integer> v) {
long startTime = System.nanoTime();
Iterator< Integer> iter = v.iterator();
for(int i=0; i<v.size(); i++) {
v.get(i);
}
long endTime = System.nanoTime();
long duration = endTime - startTime;
System.out.println(duration); ///13948600
}
public static void traverseByFor(Vector< Integer> v) {
long startTime = System.nanoTime();
Iterator< Integer> iter = v.iterator();
for(Integer item:v) {
;
}
long endTime = System.nanoTime();
long duration = endTime - startTime;
System.out.println(duration); ///13221800
}
public static void traverseByEnumeration(Vector< Integer> v) {
long startTime = System.nanoTime();
Iterator< Integer> iter = v.iterator();
for(Enumeration< Integer> enu = v.elements(); enu.hasMoreElements(); ) {
enu.nextElement();
}
long endTime = System.nanoTime();
long duration = endTime - startTime;
System.out.println(duration); //15849400
}
}