java之14天 Collection,Vectory,ArrayList集合 (一)

Collection集合框架

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/***
 *Cellection
 *    |--List:元素是有序的,元素可以重复,因为该集合体系有索引.
 *        |--ArrayList   :底层的数据结构使用的是数组结构,特点: (查询,修改)速度很快,但是(插入删除)很慢 ,线程不同步
 *        |--LinkedList  :底层使用的是链表数据结构,特点: (查询,修改)慢,(插入,删除)快! 线程不同步
 *        |--Vector      :元老级干部 1.0的时候 就是Vector天下,1.2后 集合框架才出来. 
 *        					特点 :线程同步,
 *                              底层是数据结构是数组结构.被ArrayList替代了.
 *                              如果后期要用到同步的,那么也不使用vector,需要自己加锁.
 *                              
 *        数组结构 的 	ArrayList  和   Vector 一般数组长度是不变的  
 *           ArrayList:默认长度为10,以后使用 50%的增加,超过后,将原来的10个元素复制到 长度为15的数组中,然后再在后面添加新的元素(可变长度数组,就是不断new数组完成的)
 *           Vector:默认长度为 10,超过后100%延长,这样就变成了20,比较浪费空间
 *        
 *        
 *    |--Set : 元素是无序,元素不可以重复,该集合中没有索引.
 *   
 * List:
 *    特有方法: 凡是可以操作角标的方法都是该体系中特有的方法.
 *    
 * 增
 *   add(index,element)
 *   addAll(index,Collection);
 * 删
 *   remover(index);
 * 改
 *   set(index,element);
 * 查
 *   get(index)
 *   subList(from,to);
 *   listIterator();
 *   
 * list集合特有的迭代器 叫做 listIterator 是Iterator的子接口.
 * 
 * 在迭代时,不可以通过集合对象的方法操作集合中的呀un苏.因为会发生ConcurrentModificationException
 * 
 * 所以,在迭代时,只能使用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作.
 * 如果想要其他的操作如,添加  修改 等就需要使用  listIterator 子接口
 * 
 * 该接口只能通过list集合的listIterator 获取
 * 
 * 
 * 
 */


public class ListDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	
	public static void main(String[] args) {
		method_1();
		method_2();
	}
	
	public static void method_2(){
		//演示列表迭代器
		ArrayList al=new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		sop("原集合:"+al);
		
		//跌带动的时候  找到后想删除 发现 使用普通的 Iterator 不能做到  
		/*Iterator it=al.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			if(obj.equals("java02")){
				//发现 有问题  .因为在使用it时候,同时对集合al进行了操作,这样就有可能出现安全问题
				al.add("java08");
				//it.remove(); //在使用 Iterator 的只能使用  Iterator的方法.
			}
			sop("obj="+obj);
		}*/
		
		//正向遍历
		ListIterator li=al.listIterator();
		while(li.hasNext()){
			Object obj=li.next();
			if(obj.equals("java02")){
				li.add("java007");
			}
		}
		sop("obj="+al);
		
		//逆向遍历
		while(li.hasPrevious()){
			sop("previous:"+li.previous());//是否有前一个 
		}
	}
	public static void method_1(){
		ArrayList al=new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		sop("原集合:"+al);
		
		//在制定的位置添加元素
		al.add(1,"java09");
		sop("添加:"+al);
		
		//删除指定位置上的元素
		al.remove(2);
		sop("删除:"+al);
		
		
		//修改元素
		al.set(2, "java007");
		sop("修改:"+al);
		
		//通过角标获取元素
		sop("get(1):"+al.get(1));
		
		//获取所有元素
		for(int x=0;x<al.size();x++){
			System.out.println("al("+x+")="+al.get(x));
		}
		
		Iterator it=al.iterator();
		while(it.hasNext())
			it.next();
		
		//通过indexOf获取对象的位置
		sop("indexOf="+al.indexOf("java09"));
		
		List sub=al.subList(1, 2);
		sop("sub"+sub);
		
	}

}

Collection的操作

/**
 *集合类
 * 1.add方法 的参数类型是Object,以便于接受任意类型对象
 * 2.集合中存储的都是对象的引用  (地址)
 * 
 * 什么是迭代器呢 ?
 *   其实就是  集合的取出元素的方式.
 *  
 *
 */
public class CollectionDemo {

	public static void main(String[] args) {
		
		base_method2();
		method_get();
	}
	
	//取出元素
	public static void method_get(){
		ArrayList al=new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		al.add("java05");
		
		/*
		 * 
		Iterator it=al.iterator(); //获取迭代器 用于取出集合中的元素
		while(it.hasNext())
			sop(it.next());
		 */
		
		//这种有优势, 增加了 内存优化,使用完后  it就会被回收.
		for(Iterator it=al.iterator();it.hasNext();){
			sop(it.next());
		}
		
	}
	
	//取交集 批量删除
	public static void base_method2(){
		
		ArrayList al=new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		al.add("java05");
		
		ArrayList al2=new ArrayList();
		al2.add("java01");
		al2.add("java02");
		al2.add("java05");
		al2.add("java06");
		
		//al.retainAll(al2); //取交集,al中只会保留和 al2中相同的元素
		al.removeAll(al2);// 一次删除一堆元素
		sop("al1"+al);
		sop("al2"+al2);
		
		
		
	}
	public static void base_method(){
		//创建一个集合容器,使用Collection接口的子类.ArrayList
		ArrayList al=new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		al.add("java05");

		//1.获取集合的长度
		sop("size:"+al.size());
	
		//2.打印集合
		sop("原集合:"+al);
		
		//3.删除元素
		al.remove("java02");
		sop("现集合:"+al);
		//判断元素
		sop("java03是否存在:"+al.contains("java03"));
		sop("集合是否为空:"+al.isEmpty());
		
		//清空集合
		al.clear();
		sop("现集合:"+al);
	}
	
	public static void sop(Object obj){
		System.out.println(obj);
	}
	

}

Vector

/**
 * 元老级 
 * Vector类中 带有Element的就是 Vector的特有方法
 * 
 * Enumeration 枚举 就是早起Vector特有的取出方式.
 * 发现 枚举和 迭代器很像
 * 
 * 其实枚举和 迭代器是一样的.
 * 因为枚举的名称以及方法的名称都过长,所以被迭代器取代了 枚举郁郁而终了
 *
 */
public class VectorDemo {
	//Vector中 带有Element的就是 Vector的特有方法
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vector v=new Vector();
		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");
		
		Enumeration en=v.elements();
		while(en.hasMoreElements()){
			System.out.println(en.nextElement());
		}
			
	}

}

ArrayList的使用

/**
 * 将自定义对象最为元素存储到ArrayList集合中,并除去重复元素
 * 比如 :存人对象, 同姓名 同年龄,视为同一个人,为重复元素
 * 
 * 思路:
 *	 1.对人描述,将数据封装进人对象
 *   2.定义容器,将人存如
 *   3.取出 
 *   
 * List判断元素是否相同,依据的是元素的equals
 *
 */
class Person{
	private String name;
	private int age;
	
	Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	@Override
	public boolean equals(Object obj) {
		
		if(!(obj instanceof Person))
			return false;
		Person p=(Person)obj;
		
		return this.getName().equals(p.getName()) && this.getAge()==p.age;
	}
	
	
}


public class ArrayListDemo {
	public static void main(String[] args) {
		ArrayList al=new ArrayList();
		al.add(new Person("admin",12));
		al.add(new Person("BBBBB",12));
		al.add(new Person("CCCCC",12));
		al.add(new Person("admin",12));
		
		al=singleElement(al);
		Iterator it=al.iterator();
		while(it.hasNext()){
			//sop(it.next().getName()+"::"+it.next().getAge());//编译失败 父类引用指子类对象
			Person p=(Person)it.next();
			sop(p.getName()+":::"+p.getAge());
		}
		
		sop("remove 03:"+al.remove(new Person("BBBBB",12)));
		sop(al);
	}
	

	public static void sop(Object obj){
		System.out.println(obj);
	}
	
	public static ArrayList singleElement(ArrayList al){
		//定一个容器
		ArrayList newAl=new ArrayList();
		
		Iterator it=al.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			
			if(!newAl.contains(obj))  //判断的是对象是否相同
				newAl.add(obj);
		}
		return newAl;
	}

}

ArrayList的练习

/**
 * 去除ArrayList中的重复元素
 */
public class ArrayListTest {

	
	public static void sop(Object obj){
		System.out.println(obj);
	}
	
	public static void main(String[] args) {
		ArrayList al=new ArrayList();
		al.add("java01");
		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java02");
		al.add("java03");
		
		sop("原集合:"+al);
		sop(al=singleElement(al));
			
		/*在迭代时循环中next调用一次,就要使用hasNext判断一次
		Iterator it=al.iterator();
		while(it.hasNext()){
			System.out.println(it.next()+"..."+it.next());
		}
		*/
	}
	
	public static ArrayList singleElement(ArrayList al){
		//定一个容器
		ArrayList newAl=new ArrayList();
		
		Iterator it=al.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			
			if(!newAl.contains(obj))
				newAl.add(obj);
		}
		return newAl;
	}

}