Java——集合框架，迭代器遍历

集合框架的学习：
             集合类能存储任意对象，长度是可以改变的，随着元素的增加而增加，随着元素的减少而减少
             集合只能存储引用数据类型(对象)，集合中也可以存储数据类型，但是存储时自动装箱成为对象
             元素个数不固定的用集合
         collections的常见方法：
             boolean add(E e)
             boolean remove(Object o)
             void clear()
             boolean contains(Object o)
             boolean isEmpty()
             int size()
             
             collections的所有子类都能使用迭代器去遍历
             
            集合的遍历：集合转换成数组遍历
        迭代器的原理：迭代器是对集合进行遍历，而每一个集合内部的存储结构是不同的，所以每一个集合存和取都是不一样，那么需要在每一个类中定义hasNext()和next()方法，这样做事可以的，但是会让整个集合体系过于臃肿，迭代器是将这样的方法向上抽取出接口，然后在每个类的内部，定义自己迭代方式，这样做既规定了整个集合体系的遍历方式都是hasNext()和next()方法，同时代码用底层内部实现，使用者不需要知道怎么实现，会用就行。
        List集合:是Collections的子接口，所以有很多是和Collections重复的
            void add(int inde,E element)
            E remove(int index)
            E get(int index)
            E set(int index,E element)
            
        ListIterator：是集合的遍历方式
            boolean hasNext()
            boolean hasPrevious()
            Object next()
            Object previous()
            
        Vector迭代

 

 

package pra_09;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;

public class J_17 {
	public static void main(String[] args){
		int[] arr1=new int[5];			//基本数据类型数组
		Student[] stu=new Student[5];	//引用数据类型数组
		stu[0]=new Student("aa",11);	//创建一个学生对象存储在数组的第一个位置
		stu[1]=new Student("bb",22);
		stu[2]=new Student("cc",33);
		stu[3]=new Student("dd",44);	
			//pra_09.Student@6365d2be,如果想要输出数据，需要重写toString方法
		System.out.println(stu.length);
		for (int i = 0; i < stu.length; i++) {
			System.out.println(stu[i]);
		}
		
		Collection col=new ArrayList();		//父类引用指向子类对象
		boolean bol=col.add("abcd");		//添加元素
		boolean bol2=col.add("true");		
		boolean bol3=col.add("100");
		boolean bol4=col.add(new Student("qq",99));
		System.out.println(bol);
		System.out.println(bol2);
		System.out.println(bol3);
		System.out.println(bol4);
		System.out.println(col); 	//[abcd, true, 100, Student [name=qq, age=99]]
		
		col.remove("abcd");
		System.out.println(col); 	//删除指定元素
		
		System.out.println(col.contains("true"));	//判断是否包含
		
		col.clear();				//清空集合
		System.out.println(col);	
		
		System.out.println(col.isEmpty()); 			//判断集合是否为空
		System.out.println(col.size()); 			//获取元素的个数
		
		//集合转换成数组遍历(用toArray方法)
		Collection col2=new ArrayList();
		col2.add("1");
		col2.add("2");
		col2.add("3");
		Object[] arr=col2.toArray();	//将集合转换成数组
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
		Collection col3=new ArrayList();
		col3.add(new Student("aa",11));
		col3.add(new Student("bb",22));
		col3.add(new Student("cc",33));
		col3.add(new Student("dd",44));
		Object[] arr2=col3.toArray();
		for (int i = 0; i < arr2.length; i++) {
			System.out.println(arr2[i]);
			
			Student s=(Student)arr2[i];	//向下转型
			System.out.println(s.getName()+"..."+s.getAge());
		}
		
		//List接口实现方法
		List list=new ArrayList();
		list.add("a");
		list.add("b");
		list.add("v");
		list.add("q");
		System.out.println(list);
		list.add(2, "m");							//在指定位置添加元素
		System.out.println(list);
		Object obj2=list.remove(2);					//通过索引删除元素，被删除的元素返回
		System.out.println(obj2);
		System.out.println(list);
		Object obj3=list.get(3);					//通过索引获取元素
		System.out.println(list);
		Object obj4=list.set(1, "n");				//修改指定索引位置的元素
		System.out.println(list);
		
		//通过索引遍历List集合
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}
		
		//并发修改异常的产生和解决
		List list2=new ArrayList();
		list2.add("q");
		list2.add("w");
		list2.add("aaa");
		list2.add("e");
		list2.add("r");
		
		/*
		Iterator it=list2.iterator();		//获取迭代器
		while(it.hasNext()){				//判断集合是否有元素
			String str=(String)it.next();	//返回的是一个Object类,需要强转
			if("aaa".equals(str)){
				list2.add("bbb");			
				//遍历的同时在增加元素，报错 java.util.ConcurrentModificationException,并发修改异常
			}						
		}
		*/
		
		//以下位解决方案
		
		//迭代器迭代元素，可以用迭代器修改元素，集合遍历元素，集合修改元素
		ListIterator lit=list2.listIterator();	//获取迭代器(List集合特有的)
		while(lit.hasNext()){				//判断集合是否有元素
			String str2=(String)lit.next();	//返回的是一个Object类,需要强转
			if("aaa".equals(str2)){
				lit.add("bbb");			
				//遍历的同时在增加元素，报错 java.util.ConcurrentModificationException,并发修改异常
			}						
		}
		System.out.println(list2);	//[q, w, aaa, bbb, e, r]
		
		ListIterator lit2=list2.listIterator();
		while(lit2.hasNext()){
			System.out.println(lit2.next());		//获取元素并将指针向后移动
		}
		
		while(lit2.hasPrevious()){
			System.out.println(lit2.previous());	//获取元素并将指针向前移动
		}
		
		//Vector迭代
		Vector v=new Vector();
		v.addElement("a");
		v.addElement("b");
		v.addElement("c");
		v.addElement("d");
		Enumeration en=v.elements();		//获取枚举
		while(en.hasMoreElements()){		
			System.out.println(en.nextElement());
		}
	}
}
class Student{
	private String name;
	private int age;
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
}