数据类型笔记一

connection
|
|
     ---------------------------
list         set
|   |
|   |
--------------------             ------------------
| | |   |                |
| | |   |       |
ArrayList  LinkedList Vector HashSet          TreeSet

为什么会出现这么多的容器？
因为每个容器对数据的存储方式不同
这个存储方式称之为：数据结构

==========================================================================================================================
集合框架共性的操作

package CollectionDemo;

import java.util.*;
/**
 * add方法的参数类型是Object 方便接收各种任意类型的对象
 * 集合中存储的都是对象的引用或者是地址
 * @author bing
 *
 */
public class CollectionDemo {
	public static void main(String[] args) {
		base_Method2();
	}
	
	public static void base_Method2()
	{
		ArrayList al1 = new ArrayList();
		ArrayList al2 = new ArrayList();
		al1.add(new Person("Kobe","男",34));
		al1.add(new Person("Lebron","男",27));
		al1.add(new Person("姚明","男",34));
		al2.add(new Person("Kobe","男",34));
		al2.add(new Person("Bosh","男",27));
		al2.add(new Person("姚明","男",34));
		al1.add("A");
		al2.add("A");
		al1.retainAll(al2);//取交集，al1中只会保留和al2相同的元素
		sop(al1);//这里只会输出A 只有A为交集中的元素
		sop(al2);
	}
	
	public static void base_Method()
	{
		ArrayList a1 = new ArrayList();
		// 1 ，添加元素
		Person p1 = new Person("林书豪","男",21);
		a1.add(p1);
		a1.add(new Person("Kobe","男",34));
		a1.add(new Person("Lebron","男",27));
		a1.add(new Person("姚明","男",34));
		a1.add("asdfghj");
		// 2， 获取元素
		sop("size"+a1.size());
		
		sop(a1);//打印集合删除前的集合
		//3,  删除元素
		a1.remove(p1);
		//a1.remove("asdfghj");
		sop(a1);//打印删除后的集合
		//4 ， 判断元素
		sop("asdfghj是否存在"+ a1.contains("asdfghj"));
		sop("集合是否为空"+a1.isEmpty());
		a1.clear();//清空集合
		
		sop(a1);//打印清空后的集合
		sop("集合是否为空"+a1.isEmpty());
	} 
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

==========================================================================================================================
迭代器

public static void method_get()
	{/**
	*迭代器是用来取出集合中元素的方法
	*取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素，
	*那么取出方式就被定义成了内部类。
	*而每一个容器的数据结构是不同的，所以取出动作的动作细节也不相同。但是有共性
	*内容判断和取出，那么可以将其共性抽取。这些内部类都符合一个规则。该规则就是
	*Iterator接口。那么如何获取集合的取出对象呢？通过对外提供一个方法
	*这个方法就是iterator();
	*/
		ArrayList al1 = new ArrayList();
		al1.add("java01");al1.add("java02");al1.add("java03");
		//获取迭代器，用于输出集合中的元素
		Iterator it = al1.iterator();//al1.iterator()返回的是一个Iterator的子类对象
		//Iterator 是个接口 无法自行生产对象 但是可以由al中的方法生产对象并返回
		sop(it.next());sop(it.next());
		//可以通过循环输出所有的集合中的元素
		/*while(it.hasNext())//hasNext()如果集合中还有元素 则返回true
		{
			sop("while中的");
			sop(it.next());
		}*/
		for(Iterator it1 = al1.iterator();it1.hasNext();)
		{
			sop(it1.next());
		}
	
	}

==========================================================================================================================
List的共性方法以及操作

package ListDemo;
import java.util.*;
/**
 * collection
 * 	|--List:元素是有序的，元素可以重复，因为该集合体系有索引
 * 	|--set：元素是无序的，元素不可以重复 ，该集合体系无索引
 * 
 * List：
 * 		特有方法，凡是可以操作角标的方法都是该体系的特有方法
 * 	增
 * 		add(index),element);
 * 		addAll(index,Collection)//添加一堆元素
 * 	删
 * 		remove(index)
 *  改
 *  	set(index,element)
 *  查
 *  	get(index)
 *      subList(from,to)
 *      listIterator()//list特有的迭代器
 * @author bing
 *
 */
public class ListDemo {
	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		//在指定位置添加元素
		sop("原集合是"+al);
		al.add(1, "java");
		sop("在角标为1位置添加元素后的集合是"+al);
		//删除指定位置的元素
		al.remove(4);
		sop("在角标为4位置删除元素后的集合是"+al);
		//修改元素 修改角标为4的元素  
		al.set(3, "javahello");
		sop(al);
		//通过角标获取 元素
		sop("al.get(3)"+al.get(3));
		//获取所有所有元素
		for(int i = 0;i<al.size();i++)//注意这里是al.size()
		{
			System.out.println("al("+i+")"+al.get(i));
		}
		Iterator it = al.iterator();
		Iterator ti = al.listIterator();
		while(it.hasNext())
		{
			sop("next"+it.next());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

==========================================================
迭代器

/**在迭代过程中，删除元素 这里需要注意的是 在迭代的过程中可能会发生并发访问异常
		 * 注意：访问List的方法有两类一种是集合的方式比如al.add()这是属于集合的访问 方式 另一种是迭代器的方式 不能再迭代的同时再用集合的
		 * 方法访问List 因为---迭代器在建立的时候是根据原来的List建立的 如果在迭代的过程，对List进行集合操作，会造成迭代器无法确认List
		 * 是原List还是操作后的List 造成并发访问异常。如果要在迭代的过程中对List进行操作，那么参阅Iterator类中的方法。其实Iterator类
		 * 中就三个方法hasNext(),next(),remove(),所以可以在迭代的过程中根据条件删除元素
		 * 从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操作）。每次调用 next 只能调用一次此方法。如果进行迭代时用调用此方法之外的
		 * 其他方式修改了该迭代器所指向的集合，则迭代器的行为是不明确的。
		 * 但是ListIterator功能很多 这是List集合特有的迭代器 
		 * 可以向前遍历 可以向后遍历 可以删除添加 很好很强大
		 */
		sop(arrl);
		while(ite.hasNext())
		{
			Object obj = ite.next();//取出List中的对象
			if(obj.equals("java1"))//与给定条件判断
			{
				ite.remove();//删除元素
			}
		}
		sop(arrl);