简单介绍List

Listde 三个字实现类:
ArrayList,LinkList,Vector
List接口下面的三个子实现类各自特点:

	ArrayList:大小可变的数组实现(,默认容量10,扩容性 1.5倍)
	        底层数据结构是数组,查询快增删慢
		    线程角度(执行效率):线程是不安全的,不同步的---->单线程中执行性效率高
		
		
	LinkedList:类似于栈结构的特点(先进后出) 
			存在一些特有功能:给链接列表开头添加元素addFirst()
						     获取链接列表开头的元素:getFirst()等等
	        底层数据结构是链接列表实现的,查询慢,增删快
		    线程角度(执行效率):线程不安全的,不同步---->执行效率高
		
	Vector:底层数据结构是一种对象数组,查询快,增删慢
	 线程角度(执行效率):线程安全的类--->同步--->执行效率低
	 一般,开发中没有告诉是用什么集合,都默认ArrayList(不考虑多线程问题)
     考虑多线程环境,使用Vector集合

List

List集合是Collection集合的子接口
基本功能以及高级功能都可以继承过来

•  特点:
       1)有序,存储和取出一致
   	 2)该集合可以允许元素重复
  

List集合的特有功能:

• 添加元素:
   void add(int index,Object element):在指定的位置处添加新的元素  index位置的前面插入元素)
  

•  删除元素:
   Object remove(int index):删除指定位置处的元素,返回该元素
  

•  获取功能:(重点)
   Object get(int index):根据索引值获取指定的元素		+ size()  
  

•  修改元素:
   Object set(int index, Object element):在指定位置处,使用新元素去替换该位置处的元素
  

ArrayList

一般情况:没有提示使用什么集合,默认都是用ArrayList

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

public class StringDemo {
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<>();
		al.add("HELLO");
		al.add("JAVAEE");
		al.add("WORLD");
		// 普通for循环
		for (int i = 0; i < al.size(); i++) {
			String s = al.get(i);
			System.out.println(s + "---" + s.length());

		}
		System.out.println("-----------");
		// Iterator iterator() :Collection迭代器
		Iterator<String> it = al.iterator();

		while (it.hasNext()) {
			String s = it.next();

			System.out.println(s + "---" + s.length());
		}
		System.out.println("-------------");
		// toArray()
		Object[] obj = al.toArray();
		for (int i = 0; i < obj.length; i++) {
			String s = (String)obj[i];
			System.out.println(s + "---" + s.length());
		}

		System.out.println("--------------");
		// 增强for循环 foreach
		for (String s : al) {
			System.out.println(s + "---" + s.length());
		}
	}
}

集合去重:

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

//集合去重
public class ArrayDemo {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("hello");
		list.add("javaee");
		System.out.println(list);
		// 去重
		List<String> list1 = new ArrayList<String>();
		for (int i = 0; i < list.size(); i++) {
			String s = list.get(i);
			if (!list1.contains(s)) {
				list1.add(s);

			}
		}
		System.out.println(list1);
		system.out.println("----------------------");
		for (String s : list) {
				if (!list1.contains(s)) {
					list1.add(s);

				}
			}
			System.out.println(list1);
	}
}

LinkedList

底层数据结构是一种链接列表
查询慢,增删快,线程不安全,执行效率高!

特有功能:

•  添加:
   public void addFirst(Object e):添加元素到列表的开头
   public void addLast(Object e):添加元素到末尾
  

•  删除:
   public Object removeFirst():移除此列表的开头元素
   public Object removeLast():移除末尾的元素
  

•  获取:
   public Object getFirst():获取列表开头
   public Object getLast() :获取列表末尾
  

模拟栈内存

public class LinkedListTest {

	public static void main(String[] args) {
		MyTool mt = new  MyTool() ;
		
		mt.add("hello");
		mt.add("world"); 
		mt.add("Java");
		while(!mt.isEmpty()) {
			System.out.println(mt.get());
		}
	}
}
import java.util.LinkedList;

//模拟栈存储
public class MyTool {
	private LinkedList link ;
	
	public MyTool() {
		link = new LinkedList() ;
	}
	public void add(Object obj) { 
		link.addFirst(obj); 
	}
	public Object get() {
		return link.removeFirst() ;
	}
	public boolean isEmpty() {
		return link.isEmpty() ;
	}
}

模拟队列

public class LinkedListTest1 {

	public static void main(String[] args) {
		MyTool1 mt1 = new MyTool1();
		mt1.add("genwei");
		mt1.add("niuwenbin");
		mt1.add("wenbin");
		mt1.add("weigen");
				
		while (!mt1.isEmpty()) {
			System.out.println(mt1.get());
		}

	}

}
import java.util.LinkedList;

public class MyTool1 {
	private LinkedList link;
//队列
	public void add(Object obj) {
		link.addLast(obj);
	}

	public boolean isEmpty() {
		return link.isEmpty();
	}

	public Object get() {
		return link.removeFirst();
	}

	public MyTool1() {
		super();
		link = new LinkedList() ;
	}
}
	

Vector

线程安全的类,执行效率低 (底层数据结构是数组:查询快,增删慢)

• 特有功能:
   public Enumeration<E> elements():
   获取Vector集合的迭代器(向量的组件枚举)			----  public Iterator iterator() 
          Enumeration接口里面有两个抽象方法:
                boolean hasMoreElements():判断是否包含很多的元素----  boolean hasNext()
   	          Object nextElement():获取下一个元素				---Object next()
   public Object elementAt(int index):获取指定位置处的组件----->Object get(int index)
  

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo {
	public static void main(String[] args) {
		//创建Vector集合的对象
		Vector<String> s = new Vector<String>();
		s.add("hello");
		s.add("java");
		s.add("world");
		//遍历
		Enumeration<String> em = s.elements();
		//boolean hasMoreElements();判断是否包含很多元素     boolean hasNext();
		//Object nextElement():获取下一个元素                          Object next();
		while(em.hasMoreElements()){
			String s1 = em.nextElement();
			System.out.println(s1);
		}
		System.out.println("-------------------");
		//普通for循环
		for (int i = 0; i < s.size(); i++) {
			String s1 = s.elementAt(i);
			System.out.println(s1);
			
		}
		System.out.println("--------------------");
		//增强for循环
		for (String s1 : s) {
			System.out.println(s1);
			
		}
	}
}