【java知识点】数组 JCF 列表list

数组

JCF

列表List

迭代器https://www.cnblogs.com/zyuze/p/7726582.html

java 多线程https://www.cnblogs.com/wxd0108/p/5479442.html

数组索引最快

import java.util.ArrayList;
import java.util.Iterator;
//Vector 几乎和ArrayList一样，除了Vector本身是同步的

public class ArrayListTest {
	public static void main(String[] a) {  
	    ArrayList<Integer> al = new ArrayList<Integer>();  
	    al.add(3);  
	    al.add(2);          
	    al.add(1);  
	    al.add(4);  //ArrayList只能装对象，当add（3）时，会自动将普通int变量3自动装箱
	    al.add(5);  //为Integer(3)的对象，然后放入ArrayList变量容器中
	    al.add(6);  //对象占有一定的内存
	    al.add(new Integer(6));  
	  
	    System.out.print("The third element is  ");
	    System.out.println(al.get(3));//但不能访问未存值的内存
	    al.remove(3);  //删除第四个元素，后面元素往前挪动
	    al.add(3, 9);  //将9插入到第4个元素，后面元素往后挪动
	    
	    System.out.println("======遍历方法=============");
	     //for(int i = 0;i < al.size(); i ++){
       	 //	    System.out.println(i);//不要用get（i）
       	    //}
//al.forEach(x -> System.out.print(x));
	    ArrayList<Integer> as = new ArrayList<Integer>(100000);
	    for (int i=0; i<100000; i++)
	    {
	    	as.add(i);
	    }
	    traverseByIterator(as);
	    traverseByIndex(as);
	    traverseByFor(as);    
	}  
	public static void traverseByIterator(ArrayList<Integer> al)
	{
		long startTime = System.nanoTime();
		System.out.println("============迭代器遍历=============="); 
	    Iterator<Integer> iter1 = al.iterator();  
	    while(iter1.hasNext()){  
	        sysout(iter1.next());//遍历 用一次指针往后挪一次  
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}
	public static void traverseByIndex(ArrayList<Integer> al)
	{
		long startTime = System.nanoTime();
		System.out.println("============随机索引值遍历=============="); 
	    for(int i=0;i<al.size();i++)
	    {
	    	al.get(i);
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}
	public static void traverseByFor(ArrayList<Integer> al)
	{
		long startTime = System.nanoTime();
		System.out.println("============for循环遍历=============="); 
	    for(Integer item : al)
	    {
	    	;
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}
}
//public static void main(String[] args) {
//		ArrayList<String> list = new ArrayList<String>(); // 创建List集合
//		list.add("abc"); // 初始化list集合
//		list.add("def");
//		list.add("ghi");
//		list.add("jkl");
//		list.add("mno");
//		list.add("pqr");
//		System.out.print("Foreach遍历集合: \n\t");
//		for (String string : list) { // 遍历List集合
//			System.out.print(string); // 输出集合的元素值
//		}
//		System.out.println();
//		String[] strs = new String[list.size()];
//		list.toArray(strs); // 创建数组
//		System.out.println("Foreach遍历数组:\n\t");
//		for (String string : strs) { // 遍历数组
//			System.out.print(string); // 输出数组元素值
//		}
//	}
//}

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

public class LinkedListTest {

	public static void main(String[] args) {
		LinkedList<Integer> ll = new LinkedList<Integer>();  
	    ll.add(3);  
	    ll.add(2);  
	    ll.add(5);  
	    ll.add(6);  
	    ll.add(6);  
	    System.out.println(ll.size());
	    ll.addFirst(9);  //在头部增加9
	    ll.add(3, 10);   //将10插入到第四个元素，四以及后续的元素往后挪动
	    ll.remove(3);    //将第四个元素删除
	    
	    LinkedList<Integer> list = new LinkedList<Integer>();
	    for (int i=0; i<100000; i++)
	    {
	    	list.add(i);
	    }
	    traverseByIterator(list);
	    traverseByIndex(list);
	    traverseByFor(list);    

	}
	
	public static void traverseByIterator(LinkedList<Integer> list)
	{
		long startTime = System.nanoTime();
		System.out.println("============迭代器遍历=============="); 
	    Iterator<Integer> iter1 = list.iterator();  
	    while(iter1.hasNext()){  
	        iter1.next();  
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}
	public static void traverseByIndex(LinkedList<Integer> 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 + "纳秒");
	}
	public static void traverseByFor(LinkedList<Integer> 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 + "纳秒");
	}
}

import java.util.ArrayList;
import java.util.LinkedList;

public class ListCompareTest {

	public static void main(String[] args) {
		int times = 10 * 1000;
	    // times = 100 * 1000;
	    // times = 1000 * 1000;
	    
		ArrayList<Integer> arrayList = new ArrayList<Integer>();
	    LinkedList<Integer> linkedList = new LinkedList<Integer>();

	    System.out.println("Test times = " + times);
	    System.out.println("-------------------------");
	    
	    // ArrayList add
	    long startTime = System.nanoTime();

	    for (int i = 0; i < times; i++) {
	        arrayList.add(0,i);
	    }
	    long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + " <--ArrayList add");

	    // LinkedList add
	    startTime = System.nanoTime();

	    for (int i = 0; i < times; i++) {
	        linkedList.add(0,i);
	    }
	    endTime = System.nanoTime();
	    duration = endTime - startTime;
	    System.out.println(duration + " <--LinkedList add");
	    System.out.println("-------------------------");
	    
	    // ArrayList get
	    startTime = System.nanoTime();

	    for (int i = 0; i < times; i++) {
	        arrayList.get(i);
	    }
	    endTime = System.nanoTime();
	    duration = endTime - startTime;
	    System.out.println(duration + " <--ArrayList get");

	    // LinkedList get
	    startTime = System.nanoTime();

	    for (int i = 0; i < times; i++) {
	        linkedList.get(i);
	    }
	    endTime = System.nanoTime();
	    duration = endTime - startTime;
	    System.out.println(duration + " <--LinkedList get");
	    System.out.println("-------------------------");

	    // ArrayList remove
	    startTime = System.nanoTime();

	    for (int i = 0; i < times; i++) {
	        arrayList.remove(0);
	    }
	    endTime = System.nanoTime();
	    duration = endTime - startTime;
	    System.out.println(duration + " <--ArrayList remove");

	    // LinkedList remove
	    startTime = System.nanoTime();

	    for (int i = 0; i < times; i++) {
	        linkedList.remove(0);
	    }
	    endTime = System.nanoTime();
	    duration = endTime - startTime;
	    System.out.println(duration + " <--LinkedList remove");
	}
}

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class VectorTest {

	public static void main(String[] args) {
		Vector<Integer> v = new Vector<Integer>();
		v.add(1);
		v.add(2);
		v.add(3);
		v.remove(2);
		v.add(1, 5);
		System.out.println(v.size());

		System.out.println("======遍历方法=============");

		Vector<Integer> v2 = new Vector<Integer>(100000);
        System.out.println(v2.size());
		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();
		System.out.println("============迭代器遍历==============");
		Iterator<Integer> iter1 = v.iterator();
		while (iter1.hasNext()) {
			iter1.next();
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
	}

	public static void traverseByIndex(Vector<Integer> v) {
		long startTime = System.nanoTime();
		System.out.println("============随机索引值遍历==============");
		for (int i = 0; i < v.size(); i++) {
			v.get(i);
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
	}

	public static void traverseByFor(Vector<Integer> v) {
		long startTime = System.nanoTime();
		System.out.println("============for循环遍历==============");
		for (Integer item : v) {
			;
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
	}

	public static void traverseByEnumeration(Vector<Integer> v) {
		long startTime = System.nanoTime();
		System.out.println("============Enumeration遍历==============");
		for (Enumeration<Integer> enu = v.elements(); enu.hasMoreElements();) {
			enu.nextElement();
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
	}
}