Java 数组集合（一）

List

Java的List是一个非常有用的数据类型。List是有序的Collection。Java List一共有三个实现类，分别是ArrayList、Vector和LinkedList。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class ListTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//In_List();
		//St_List();
	}
	
	private static void In_List() {
		List<Integer> lt = new ArrayList<Integer>();
		for (int i = 0; i < 20; i++) {
			//添加元素
			lt.add((int)(Math.random()*100+1));
		}
		//输出 
		System.out.println(lt.toString());
		//排序
		Collections.sort(lt);
		System.out.println(lt.toString());
	}
	
	private static void St_List() {
		List<String> lt = new ArrayList<String>();
		lt.add("10");
		
		for (int i = 0; i < 25; i++) {
			//添加元素
			lt.add(""+(int)(Math.random()*50+1));
		}
		System.out.println(lt.toString());
		
		//是否包含
		System.out.println("是否包含 50： "+lt.contains("50"));
		
		//查找
		System.out.println("下标为2的元素： "+lt.get(2));
		System.out.println("下标为20设置为1 "+lt.set(20, "1"));
		System.out.println("1所在下标："+lt.indexOf("1"));
		System.out.println("最后一个1所在下标："+lt.lastIndexOf("1"));
		
		//删除
		lt.remove(2);
		System.out.println(lt.toString());
		lt.remove("10");
		System.out.println(lt.toString());
		
		
		//转换成数组
		String[] st = new String[lt.size()];
		lt.toArray(st);
		System.out.println(Arrays.toString(st));
	}

}

ArrayList

ArrayList是常用的List实现类，内部是通过数组实现的，它允许对元素快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要将已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动，代价比较高。因此，他适合随机查找和遍历，不适合插入和删除。

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

public class ArrayListTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 ArrayList<Integer> al= new ArrayList<Integer>();
		 //添加
		 for (int i = 0; i < 25; i++) {
			al.add(i);
		}
		 //遍历
		 AL_for(al);
		 System.out.println();
		 AL_For(al);
		 System.out.println();
		 AL_It(al);
         
	}
	
	public static void AL_It(ArrayList<Integer> al) {
		//通过迭代器进行遍历
        System.out.println("通过迭代器进行遍历");
        Iterator<Integer> it= al.iterator();
        while (it.hasNext()) {
           System.out.print(it.next()+" ");
        }  
	}
	
	public static void AL_For(ArrayList<Integer> al) {
		//增强for循环
		System.out.println("增强for循环");
        for (Integer num:al) {
            System.out.print(num+" ");

       }
	}
	
	public static void AL_for(ArrayList<Integer> al) {
		 //通过索引值进行遍历
		System.out.println("通过索引值进行遍历");
        for (int i = 0; i < al.size(); i++) {
            System.out.print(al.get(i)+" ");
       }
	}

}

Vector

Vector与ArrayList相似但是不同之处在于它支持线程同步，及某一时刻只能有一个线程能够编写Vector，这就避免多线程同时写而引起的不一致性，但是实现同步需要花费很高的代价，并且访问速度不如ArrayList

import java.util.Vector;
import java.util.concurrent.CountDownLatch;

public class VectorTest {

	public static void Ve(Vector<Integer> ve) {
		// 添加元素
		for (int i = 0; i < 25; i++) {
			ve.add(i);
		}
		// 输出
		System.out.println(ve.toString());
		// 删除
		ve.remove(1);
		System.out.println(ve.toString());
		ve.removeElement(9);
		System.out.println(ve.toString());
		// 查找
		System.out.println("12的下标： " + ve.indexOf(12));
	}

	//线程
	static class MyThread extends Thread {
		private CountDownLatch countDownLatch;
		private Vector<String> vector;
		private String element;

		public MyThread(CountDownLatch countDownLatch, Vector<String> vector, String element) {
			this.countDownLatch = countDownLatch;
			this.vector = vector;
			this.element = element;
		}

		@Override
		public void run() {
			super.run();

			try {
				synchronized (vector) {
					if (!vector.contains(element)) {
						Thread.sleep(1000);
						vector.add(element);
					}
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				countDownLatch.countDown();
			}
		}
	}

	public static void main(String[] args) throws InterruptedException {
		CountDownLatch countDownLatch = new CountDownLatch(2);
		Vector<String> vector = new Vector<>();

		MyThread myThread1 = new MyThread(countDownLatch, vector, "AA");
		MyThread myThread2 = new MyThread(countDownLatch, vector, "AA");
		MyThread myThread3 = new MyThread(countDownLatch, vector, "BB");

		myThread1.start();
		myThread2.start();
		myThread3.start();

		countDownLatch.await();

		int vectorSize = vector.size();
		System.out.println("vector size: " + vectorSize);
		for (int i = 0; i < vectorSize; i++) {
			System.out.println("index " + i + ": " + vector.get(i));
		}
	}
}

LinkList

LinkList使用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外它还有专门用于操作表头和尾元素，可以当作堆栈和双向队列使用。

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

public class LinkListTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

	public static void LLT() {
		LinkedList<String> ll = new LinkedList<String>();
		// 添加
		for (int i = 0; i < 25; i++) {
			ll.add("" + i);
		}
		// 输出
		System.out.println(ll);
		ll.addFirst("12");
		System.out.println(ll);
		ll.addLast("23");
		System.out.println(ll);
		// 查找
		System.out.println("链表的第一个元素是 : " + ll.getFirst());
		System.out.println("链表最后一个元素是 : " + ll.getLast());
		// 删除
		ll.remove(2);
		System.out.println(ll);
		// 生成子链表
		List subl = ll.subList(1, 4);
		System.out.println("子链表");
		System.out.println(subl);

	}
}

ArrayList、Vector、LinkedList比较

ArrayList
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程不安全，效率高
Vector
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低
LinkedList
优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高