集合基础学习笔记（一）

1、数组与集合的区别

数组：长度固定，可以存储基本数据类型，也能存储对象

集合：长度可变，只能存储对象类型（由于有包装类的存在，集合可以存储任何类型）。

2、集合的体系结构

集合也叫容器用于存储对象。我们根据不同的需求和不同的数据结构来对集合做了不同的抽象。

3、集合的方法

①添加

②删除

③判断

④数组的转换

⑤遍历

package cn.tx.coll;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo4 {
	public static void main(String[] args) {
		//创建一个集合
		Collection coll = new ArrayList();
		for(int i = 0;i<10;i++){
			coll.add("哈哈"+i);
		}
		//System.out.println(coll);
		
		//创建集合的迭代器，这个迭代器it创建在ArrayList&It里面的内部类，只能给coll这个集合使用
		Iterator it = coll.iterator();
		while(it.hasNext()){
			//Object ob = it.next();
			//已经知晓后直接将其强转为相应的数据类型
			//shift+ait+r 可以修改同名变量
			String str = (String)it.next();
			System.out.println(str);
			
			//ctrl+对应字能查看源代码和需要实现类等
		}
		//再次创建一个迭代器
		Iterator it1 = coll.iterator();
		while(it1.hasNext()){
			String str = (String)it1.next();
			System.out.println(str);
		}
		/**
		//迭代器在遍历的时候不能进行其他操作
		Iterator it2 = coll.iterator();
		while(it2.hasNext()){
			String str = (String)it2.next();
			if("哈哈2".equals(str)){
				
				coll.add("嘻嘻");
			}
			System.out.println(str);
		}
		*/
		//游标一旦走过循环后就不能在回去了
		boolean isHs = it.hasNext();
		System.out.println(isHs);
		
	}
}

3、List

    有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

需要掌握的方法：

①存储

②获取

③遍历

④删除

package cn.tx.coll;

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

public class CollectionDemo6 {
	public static void main(String[] args) {
		//创建一个List接口的集合
		List list = new ArrayList();
		list.add("11");
		list.add("22");
		list.add("33");
		
		//创建一个迭代器
		ListIterator li = list.listIterator();
		while(li.hasNext()){
			Object obj = li.next();
			System.out.println(obj);
			
		}
		//是否有前一个元素
		boolean isHasPre = li.hasPrevious();
		System.out.println(isHasPre);
		
		System.out.println("--------------");
		//反向遍历
		while(li.hasPrevious()){
			Object obj2 = li.previous();
			System.out.println(obj2);
			
		}
		
		System.out.println("--------------------");
		//listIterator的迭代器只能遍历出创建迭代器对象之前的list的状态的内容
		/**
		ListIterator li1 = list.listIterator();
		while(li1.hasNext()){
			Object obj3 = li1.next();
			if("发".equals(obj3)){
				//通过这个迭代器可以在list中添加元素，不会出现并发问题
				li1.add("heihei");
			}
			System.out.println(obj3);
			
		}
		System.out.println(list);
		*/
		System.out.println("-----------------");
		//这个循环中size是动态的，添加后每次都在获取size的值
		for(int i = 0;i < list.size();i++){
			Object obj4 = list.get(i);
			if("22".equals(obj4)){
				list.add("嘿嘿");
			}
			System.out.println(obj4);
		}
	}
}

4、ArrayList

    List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

特点：

ArrayList中的元素和可以重复。

是有序的集合，长度不固定。

不是线程安全的。

效率高。

5、LinkedList

    List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括null）。除了实现 List 接口外，LinkedList类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。不是线程安全的。

package cn.tx.coll;

import java.util.LinkedList;
import java.util.List;

public class CollectionDemo8 {
	public static void main(String[] args) {
		//创建一个List接口的集合
		LinkedList list = new LinkedList();
		list.add("11");
		list.add("22");
		list.add("33");
		
		//把元素插入列表的头和尾
		list.addFirst("woaini");
		list.addLast("wojiushiaini");
		System.out.println(list);
		
		//获得头元素，只是获得，没有提走
		Object ob = list.element();
		System.out.println(ob);
		
		//出栈
		Object ob1 = list.poll();
		System.out.println(ob1);
		System.out.println(list);
		//压栈
		list.push("cheng");
		System.out.println(list);
	}
}

6、Vector

    和ArrayList功能类似，最主要的区别就在于vector是线程并发安全的。但是缺点是效率比较低。

package cn.tx.coll;

import java.util.Enumeration;
import java.util.Vector;


public class CollectionDemo9 {
	public static void main(String[] args) {
		Vector v = new Vector();
		v.add("张三");
		v.add("李四");
		v.add("王五");
		
		//获得集合中的每个元素
		Enumeration em=v.elements();
		
		while(em.hasMoreElements()){
			Object ob = em.nextElement();
			if("李四".equals(ob)){
				v.add("田八");
			}
			System.out.println(ob);
			
		}
		
		
	}
}

7、泛型

    我们在项目中使用集合基本99%都是在集合中存储同一种数据类型。既然我们在集合中存储同一种数据类型，我们事先一定知道这个集合中要存储什么数据类型。我们就可以预先去指定要存储的数据类型。

①泛型在集合中的运用

泛型：就是提前指定要操作的数据类型。

在集合使用的语法：

在定义集合的时候，List<数据类型> 变量名= new ArrayList<数据类型>();

package cn.tx.generic;

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

public class GenericDemo2 {
	
	public static void main(String[] args) {
		//集合中可以存储任何数据类型，实际情况都是在集合中存储一种数据类型，我们可以通过泛型来指这种数据类型
		
		Collection<String> sc = new ArrayList<String>();
		sc.add("haha");
		sc.add("xixi");
		sc.add("hehe");
		sc.add("eueu");
		
		//迭代器也带泛型
		Iterator<String> it =sc.iterator();
		while(it.hasNext()){
			//直接使用String来接收
			String str = it.next();
			System.out.println(str);
		}
	
		List<String> list = new ArrayList<String>();
		list.add("haha");
		list.add("xixi");
		list.add("hehe");
		list.add("eueu");
		
		for(int i = 0;i < list.size();i++){
			String str2 = list.get(i);
			System.out.println(str2);
			
		}
	}
	
}

②自定义泛型

在自定义泛型时

语法：class/interface 类名/接口名 <T>{  }

T只是泛型的一个标准，使用什么字符都可以，但是都要大写，不要使用特殊字符，建议用T。

package cn.tx.generic;

import java.util.Date;

import cn.tx.coll.Student;

public class GenericTestMain<T> {
	public static void main(String[] args) {
		GenericTest<String> gt = new GenericTest<String> ();
		String[] arr = new String[3];
		arr[0]="张三";
		arr[1]="李四";
		arr[2]="王五";
		
		gt.setArr(arr);
		
		String str = gt.getByIndex(1);
		System.out.println(str);
		
		System.out.println("-----------------");
		GenericTest<Student> gt1 = new GenericTest<Student> ();
		Student[] arr1 = new Student[3];
		arr1[0]=new Student(1,"aa",1,new Date());
		arr1[1]=new Student(1,"bb",1,new Date());
		arr1[2]=new Student(1,"cc",1,new Date());
		
		gt1.setArr(arr1);
		
		Student stu = gt1.getByIndex(1);
		System.out.println(stu);
	}

}

8、小结

①数组如果不遍历只能输出对应的地址；

②接口的方法都是抽象的，不能被实例化；

③ctrl+对应关键字 找出源代码；

④Vector是线性同步的，安全但是效率不高；

⑤迭代器只能用在创建的的集合中，只能单次使用，如果需要再次使用，需要重新定义。