集合2--list

集合有两组 单列集合、双列集合
collection接口有两个重要子接口 List ，Set，他们的实现子类是单列集合

list接口

1.list集合类中元素是有序的（添加顺序和取出顺序一致），可重复
2.list集合中每个元素都有对应的顺序索引，即支持索引。
3.list容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
4.JDK API中list借口实现类有：
ArrayList（数组实现数据存储，等同于Vector，但是ArrayList线程不安全，多线程情况下，不建议使用ArrayList） ，
LinkedList ，Vector

ArrayList

结论：

1. ArrayList中维护了一个Object类型的数组eleData。 transient Object[] eleData 该属性不会被序列化
2. ArrayList如果使用无参构造器，则初始eleData容量为0，第一次天剑，扩容eleData为10，如需再次扩容，则扩容eleData为1.5倍
3. 如果使用的是指定大小的构造器，则初始eleData容量指定大小，如需再扩容，则直接扩容eleData为1.5倍。

方法：
add添加元素
remove：删除指定元素
contains：查找元素是否存在
size：获取元素个数
isEmpty：判断是否为空
clear:清空
addAll：添加多个元素
containsAll：查找多个元素是否都存在
removeAll：删除多个元素
indexOf() 返回在集合中首次出现的位置
lastIndexOf()返回集合中末次出现的位置
remove(int index)删除指定下标元素
get(int index)获取指定位置上元素
set(int index , elem)设置指定位置元素，相当于替换
代码：

	ArrayList<String> arry = new ArrayList();
	arry.add("5月9号，天气阴");
	
	List list = new ArrayList(); 
	list.add("春");
	list.add(true);
	list.add(1, "夏季");
	list.add(2, 56);
	list.addAll(arry);//添加一个集合 
	System.out.println(list);//[春, 夏季, 56, true, 5月9号，天气阴]
	list.remove(1);//[春, 56, true, 5月9号，天气阴]
	System.out.println(list.contains(56));//true
	System.out.println(list.size());//4	

集合的四种遍历方式：

	//1.数组类型解析为对象
	Object[] objs = list.toArray();
	for(int i =0 ; i< objs.length ; i++ ) {
		System.out.println(objs[i]);
	}
	//2.迭代器遍历集合
	Iterator iter = list.iterator();
	while(iter.hasNext()) {
		Object obj = iter.next();
		System.out.println(obj.toString());
	}
	//3.增强for循环
			for(Object obj : list) {
            System.out.println(obj.toString());
		}
	//4.传统for循环遍历
		for(int i = 0 ; i<list.size();i++) {
			System.out.println(list.get(i));
		}
		/*
		 * 判断强转
		 * instanceOf是一个运算符，来判断当前的变量
		 * A instanceOf B 如果A是B类型返回true，否则返回FALSE
		 */
		for(Object o : list) {
			if(o instanceof String) {
				String s1 = (String)o;
				System.out.println("s1");
				if(s1.contains("小花")) {
					System.out.println("====");
				}
			}
		}

Vector

Vector 是线程同步的，即线程安全
Vector类操作方法带有synchronized
扩容（无参，默认10）满后，按2倍扩容 ;若指定大小，则每次直接按2倍扩

LinkedList

1. LinkedList底层维护了一个双向链表
   2.LinkedList中维护了两个属性first和last分别指向首节点和尾结点
   3.每个节点（Node对象），里面又维护了prev，next，item三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表。
   4. linkedList的元素增加删除不通过数组完成，相对来说效率较高。

   public class Linkedt {
   public static void main(String[] args) {
   //模拟双向链表node
   Node jackNode = new Node(“jack”);
   Node lqlNode = new Node(“刘丽”);
   Node TNode = new Node(“泰山”);

    //把Smith加入刘丽之后，泰山之前链表
    Node simithNode = new Node("smith");
    //向后指
    jackNode.nextNode=lqlNode;
    //lqlNode.nextNode=TNode;
    
    lqlNode.nextNode = simithNode;
    simithNode.nextNode = TNode;
    //指针向前
    TNode.preNode = simithNode;
    simithNode.preNode = lqlNode;
    lqlNode.preNode=jackNode;
    		
    Node firstNode = jackNode;//首指针指向jackNode
    Node lastNode = TNode; //尾指针指向Tnode
    
    //演示，从头到尾遍历
    while(true){
    	if(lastNode == null) 
    	 {
    		break;
    	}
    	System.out.println(lastNode);
    	//从后往前走
    	lastNode = lastNode.preNode;
    }
    System.out.println("-----");
    while(true) {
    	if(firstNode == null) 
    	 {
    		break;
    	}
    	System.out.println(firstNode);
    	//从前往后走
    	firstNode = firstNode.nextNode;	}		}}
    	//定义一个node类，node对象 表示双向链表的一个结点
    	class Node{
    	public Object itemObject;	//真正存放的数据
    	public Node nextNode;	//指向后一个结点
    	public Node preNode;	//指向前一个结点
    	public Node(Object name) {
    	this.itemObject = name;
    }
    @Override
    public String toString() {
    return  (String) itemObject;
    	}	 	
   

结果：

泰山
smith
刘丽
jack
=======
jack
刘丽
smith
泰山