目录

• ArrayList
• • 含义
  • 体系结构
  • 常用方法
  • 注意点
  • 迭代器示意图
  • 案例
• Vector
• • 含义
  • 体系结构
  • 案例
• Stack
• • 含义
  • 特点
  • 体系结构
  • 常用方法
  • 案例
• LinkedList
• • 含义
  • 链表分类
  • 体系结构
  • 注意点
  • 和ArrayList的比较
  • • 存储结构不同
    • 效率不一样
  • 案例

ArrayList

含义

容量可以变化的数组

体系结构

• Collection
  • List
    • ArrayList

常用方法

add     //向集合添加元素
isEmpty //判断是否为空
size    //元素个数
remove  //删除
toArray //转成数组
contains//是否包含
get     //获取
set     //更新
.....

注意点

• 集合存放的是元素的引用【TODO 自行验证】
• add 和 addAll的区别
  • add是当做一个整体元素
  • addAdd是把参数的每一个元素当做一个单独元素插入

迭代器示意图

案例

public class ArrayListDemo {
	
	//数组
	    //含义:大小固定的容器
	
	//集合
	    //学习内容:
	        //Collection 具体子类
	        //Map        具体子类
	
	    //含义:
	        //大小可以变化的容器
	        //是对数据结构的实现
	             
	    //体系结构
	         //Collection
	             //List
	                 //ArrayList
	                 //LinkedList
	                 //Vector
	                     //Stack
	
	    //方法
	       //add     //向集合添加元素
	       //isEmpty //判断是否为空
	       //size    //元素个数
	       //remove  //删除
	       //toArray //转成数组
	       //contains//是否包含
	       //get     //获取
	       //set     //更新
	       //.....
	
	
	//ArrayList
	    //体系结构
	         //Collection
	             //List
	                 //ArrayList
	    //本质
	         //会扩容的数组
	 
	public static void main(String[] args) {
		
		List arrayList = new ArrayList();
		
		//联系常用方法
		
		//末尾插入
		arrayList.add(1);
		arrayList.add(2);
		
		//指定位置插入
		arrayList.add(0, 3); 
		
		//根据位置获取元素
		System.out.println(arrayList.get(0));
		
		//根据下标删除
		arrayList.remove(0);
		
		//根据元素删除
		Integer element = 2;
		arrayList.remove(element);
		
		//大小
		System.out.println(arrayList.size());
		
		//是否为空
		System.out.println(arrayList.isEmpty());
		
		//判断是否包含
		System.out.println(arrayList.contains(1));
		
		//清空
		arrayList.clear();
		
		arrayList.add(1);
		
		//更新
		arrayList.set(0, 2);
		
		arrayList.add("zhangsan");
		
		arrayList.add("zhangsan");
		
		
		System.out.println(arrayList.indexOf("zhangsan"));
		System.out.println(arrayList.lastIndexOf("zhangsan"));
		
		Object [] array = arrayList.toArray();
		System.out.println(Arrays.toString(array));
		
		System.out.println(arrayList);
		 
		//遍历
		System.out.println("--------方式一--------");
		int size = arrayList.size();
		for(int i=0;i<size;i++){
			System.out.println(arrayList.get(i));
		}
		
		
		System.out.println("--------方式二--------");
		Iterator iterator = arrayList.iterator();
		
		while(iterator.hasNext()){
			System.out.println(iterator.next()); 
		}
		
		System.out.println("--------方式三--------");
		//增强for
		//语法
		   //for(元素类型 名称:集合){
			  //syso(名称);    
		   //}
		//本质:
		    //迭代器
		 
		for(Object temp:arrayList){
			System.out.println(temp);
		}
		
		
		//集合存储的是元素的引用
		List userList = new ArrayList();
		
		User user = new User();
		user.setName("laowang");
		
		userList.add(user);
		
		user.setName("laoli");
		
		System.out.println(userList);
		
		
		//add addAll的区别
		List oneList = new ArrayList();
		oneList.add(1);
		oneList.add(2);
		
		List twoList = new ArrayList();
		twoList.add(3);
		twoList.add(4);
		
		//oneList.add(twoList);
		//System.out.println(oneList);  // [1,2,[3,4]]  
		
	 
		oneList.addAll(twoList);
		System.out.println(oneList);  // [1,2,3,4]  
	}
}

class User{
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "User [name=" + name + "]";
	}	
}

Vector

含义

• 和ArrayList一样,底层都是采用可变数组
• 方法几乎都有synchronized关键字,是线程安全的

体系结构

• Collection
  • List
    • Vector

案例

public class VectorDemo {	
	//Vector
	    //含义:和ArrayList一样,底层都是采用可变数组
	    //体系结构
	         //Collection
	              //List
	                  //ArrayList
	                  //Vector
	                       //方法都有synchronized,代表线程安全。
	
	
	//synchronized代表同步,线程安全
	
	//字符串
	    //String
	
	    //StringBuffer       方法都添加了synchronized
	    //StringBuilder      方法没有添加synchronized修饰
	
	
	public static void main(String[] args) {
		
		List data = new Vector();
		
		data.add("11");
		System.out.println(data.get(0));
		
	}
}

Stack

含义

栈数据结构

特点

先进后出;后进先出

体系结构

• Collection
  • List
    • Vector
      • Stack

常用方法

• push
• peek
• pop
• empty

案例

package com.neu.day08._02list;

import java.util.Stack;
import java.util.Vector;

public class StackDemo {
	
	
	//栈
	    //特点:后进先出[LIFO]
	    //体系结构
	       //Collection
	            //List
	                //ArrayList
	                //Vector
	                    //Stack
	
	public static void main(String[] args) {
		Stack stack = new Stack();
		
		stack.push("11");
		stack.push("22");
		stack.push("33");
		
		//pop 删除并且返回栈顶元素
		
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		
		if(!stack.empty()){
			System.out.println(stack.pop());
		}
	 
		/*
		//返回栈顶元素但不删除
		System.out.println(stack.peek());
		System.out.println(stack.peek());
		System.out.println(stack.peek());
		*/
	}
}

LinkedList

含义

双向链表数据结构

链表分类

• 单向链表
• 双向链表

体系结构

• Collection
  • List
    • LinkedList

注意点

没有根据下标索引去获取元素的方法;但有获取第几个元素的功能

和ArrayList的比较

存储结构不同

• ArrayList底层采用可扩容的数组
• LinkedList采用双向链表结构

效率不一样

案例

public class LinkedListDemo {
	
	//LinkedList
	    //含义:链表
	    //分类
	        //单向链表
	        //双向链表
	    //体系结构
	        //Collection
	             //List
	                  //ArrayList
	                  //Vector
	                       //Stack
	                  //LinkedList
	
	
	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		
		list.add("11");
		list.add("22");
		list.add("33");
		
		//链表不同于数组,链表没有所谓的下标索引说法。
		//这里获取的是第几个节点,底层从头节点往后节点依次查找
		System.out.println(list.get(2));
		
		testAdd();
	}
	
	public static void testAdd(){
		//思路
		//获取当前时间
		//添加
		//获取当前时间
		
		List arrayList = new ArrayList();
		long start = System.currentTimeMillis();
		
		//添加
		for(int i=0;i<100000;i++){
			arrayList.add(0,i);
		}
		long end = System.currentTimeMillis();
		System.out.println("数组插入的时间为:"+(end-start));
		
		
		List linkedList = new LinkedList();
		start = System.currentTimeMillis();
		
		//添加
		for(int i=0;i<100000;i++){
			linkedList.add(0,i);
		}
		end = System.currentTimeMillis();
		System.out.println("链表插入的时间为:"+(end-start));
	}
	
	//ArrayList和LinkedList的比较
	//存储结构不一样
	//效率
	
}