Java中的List集合以及集合的部分总结

一、泛型Generics

概念：广泛的类型——>声明要存储的类型是什么。
作用：存入到容器中的元素，Object类型，向上转型。当获取的时候，需要手动的向下转型，降低效率，容易出错。
使用：在创建集合的时候，使用泛型来指明该容器中，能够存储的数据类型。
目的：保护容器中的数据的类型的安全。
	String-->Object
	Integer-->Object
	Person-->Object
	
	String-->String
	Integer-->Integer
	Person-->Person
	
语法：
	容器<数据类型> 容器对象 = new 容器<>();

注意点：因为集合仅限于存储引用类型，所以声明泛型不能直接写基本数类型，需要写对应的包装类。

()-->方法
[]-->数组
{}-->....
<>-->泛型



泛型限定：未完待续。。。

数组的语法格式：

数据类型[] 数组名= new 数据类型[长度];

int[] arr = new int[5];

arr[0]–>int

Arrays.toString(arr);//—>数组的元素

集合对象直接打印，不显示集合的地址，直接显示集合中存储的元素。集合对象，都重写了toString();

二、迭代器Iterator

集合：容器–>装数据，取数据。。。

使用迭代器Iterator来获取集合中的数据。一个一个一个的获取。。第1个，第2个，第3个。。。。

迭代器使用：
step1：//先在要遍历的集合上，获取迭代器对象
	c1.iterator();--->Iterator it
step2：判断迭代器对象之后是否有元素
	it.hasNext();--->boolean
step3：获取该元素：
	it.next()-->元素
	
注意点：
	1、每次迭代获取前(调用next())，应该先判断是否有这个元素(hasNext())，如果有再获取，如果没有就不要获取，如果强行获取，就报错：java.util.NoSuchElementException
	2、迭代器在工作期间，集合本身不要去更改集合的结构。但是迭代器对象自己可以删除。(功能慎用)

public static void main(String[] args) {
		Collection<String> c1 = new ArrayList<String>();
		c1.add("aaa");
		c1.add("bbb");
		c1.add("ccc");
		
		//问题：如何获取集合中的元素？
		//方法一：for-each：增强for循环
		/*
		 * 语法原理：
		 * for(数据类型 变量名 : 数组/集合){
		 * 	打印变量名即可。
		 * }
		 */
		for(String s:c1){
			System.out.println(s);
			//aaa
			//bbb
			//ccc
		}
		
		//方法二：Iterator，迭代器，依次获取集合中的元素。。
		/*
		 * Iterator接口：
		 * 	hasNext()-->boolean，判断是否有下一个元素
		 * 	next()-->元素，获取元素
		 */
		//step1：从该集合上获取迭代器对象--->it，接口类型的
		//接口类型 =  对象
		// 接口  		  接口引用   = new 实现类对象();
		//Collection c1     = new ArrayList();
		Iterator<String> it = c1.iterator();//c1.iterator()，该方法，专门获取c1集合上的迭代器对象
		//接口类型  = 调用方法();
		
		//安装jdk1.8--->String，Object，Arrays,语法。。。Math,Random....
		//Collection接口,..add(),remove();iterator()...
		//ArrayList实现类，LinkedList，hashSet...
		
		//step2：
		//判断迭代器对象，是否有下一个元素
//		boolean b1= it.hasNext();
//		System.out.println(b1); //true
//		//A：获取迭代器后的对象，B：迭代器向后移动一下
//		String s1 = it.next();
//		System.out.println(s1);//aaa
//		
//		
//		boolean b2 = it.hasNext();
//		System.out.println(b2);//true
//		String s2 = it.next();
//		System.out.println(s2);//bbb
//		
//		boolean b3 = it.hasNext();
//		System.out.println(b3);//true
//		
//		String s3 = it.next();
//		System.out.println(s3); //ccc
//		
//		boolean b4 = it.hasNext();
//		System.out.println(b4);//false
//		
//		String s4 = it.next(); //java.util.NoSuchElementException
//		System.out.println(s4);
		
		while(it.hasNext()){//判断it后是否有下一个元素
			String s = it.next();//获取it后的这个元素，并向后移动一下。
			System.out.println("--->"+s);
		}
		
		
		
		
		
	}

public static void main(String[] args) {
//		迭代器在工作期间，不要去更改集合的结构。
		Collection<String> c1 = new ArrayList<String>();
		c1.add("aaa");
		c1.add("bbb");
		c1.add("ccc");
		//---->迭代器对象
		
		System.out.println(c1);
		
		Iterator<String> it = c1.iterator();//从集合上获取的迭代器对象：it
		while(it.hasNext()){
			String s = it.next();
			System.out.println(s);
		}
		
		System.out.println("----------");
		//迭代的注意点：1.一个迭代器对象，从头迭代到后，不能再使用了，因为后面没有元素了，迭代不出来了。。
		while(it.hasNext()){
			String s2 = it.next();
			System.out.println(s2);
		}
		//2.迭代器工作期间：不能更改集合中的元素的个数。
		Iterator<String> it2 = c1.iterator();
		//it2--> aaa		bbb		ccc
		String s3 = "";
		while(it2.hasNext()){//迭代器在工作期间，相当于锁定了这个集合容器。集合本身不要去删除数据。
		
			if("bbb".equals(s3)){
//				c1.remove("bbb");//操作集合，删除一个元素："bbb" ,java.util.ConcurrentModificationException
				it2.remove();//了解。。
			}
			s3 = it2.next();//aaa ,bbb
			System.out.println(s3);
		}
		System.out.println(c1);
	
		
	}

三、List接口

作为Collection接口的子接口，也是一种容器。但是有自己的独特的存储特点。

• 有序，有下标。
• 可以允许数据重复。

新增了自己特有的功能方法：都是和下标有关系的。

set(index,E)-->指定位置替换元素
get(index)-->E，获取指定位置的元素
add(index,E)-->指定位置添加元素
remove(index)-->根据位置进行删除
indexOf()-->int，搜索指定的元素，返回下标，如果没有就返回-1
subList(fromIndex,endIndex)-->List，截取子集合

遍历一个List接口中的所有元素：

• for-each，增强for循环
• Iterator，迭代器
• 普通的for循环，结合get()方法。
  

四、ArrayList实现类

作为List接口的实现类，将接口中的方法全部实现。

底层：数组的结构来实现的。也会有人叫动态数组。

数组结构：在内存中连续空间。

理解为ArrayList相当于一个可变长度的数组，访问遍历效率较高。增加，删除元素，效率较低。

JDK1.2的版本的类。

五、总结

集合：

概念：也叫容器，理解为存储数据的。动态的存储多个对象。——元素Element
	动态：集合的大小随着存储的数据的个数而改变。
	对象：集合中存储的都是引用类型的数据。(对象的地址)

集合的结构：

父接口：Collection，关于集合的最基本的规则。

add()-->boolean，向集合中添加元素。
remove()-->boolean，从集合中删除指定的元素。
size()-->int，获取集合的长度。集合中存储的元素的个数
iterator()-->Iterator，获取该集合上的迭代器对象，用于遍历集合，获取里面的每一个元素。
contains()-->是否包含指定的元素。
clear()-->清空集合
addAll(),removeAll(),toArray().....

子接口：List

特点：
	1、有序，有下标，有位置。
	2、允许重复的元素
	
新增的方法：大多和下标有关
add(index,E)-->允许在指定的位置添加新增的元素。
remove(index)-->根据下标删除元素
get(index)-->获取元素
set(index,E)--->根据下标，替换元素
indexOf()-->搜索指定的元素，返回下标，如果元素没有，返回-1。
subList(fromIndex,toIndex)-->截取子容器
iterator()
listIterator()
。。。。

泛型：

概念：广泛的类型。指定一个类型。
作用：存入到集合中的元素，Object类类型，自动向上转型。当获取的时候，需要手动的向下转型，降低效率，容易出错。使用泛型，指定集合中存储的元素的数据类型，保护容器中数据类型的安全。
	String-->Object,Person-->Object ...
	String-->String,Person-->Person
使用：创建集合的时候，使用泛型来指明该容器能够存储的数据类型。
语法格式：
	容器<数据类型> 容器对象 = new 容器<>();
注意点：
	集合中的泛型：限于引用类型，基本类型需要写成对应的包装类类型。

迭代器：

用途：专门用于遍历集合中每一个元素的。
工作原理：
step1：先获取Collection上获取迭代器对象：iterator()--->Iterator对象：it
step2：调用迭代器hasNext()，用于判断迭代器是否有下一个元素可以迭代获取。
	boolean：true，false
step3：调用next()，获取下一个元素。迭代器对象会向后移动一个位置。


Iterator接口中：
	hasNext()-->是否有下一个元素。
	next()-->获取下一个元素对象，同时迭代器对象向后移动一个位置
	remove()-->移除，已经迭代出的最后一个元素。也就是移出了迭代器左侧的元素。
	
	
注意点：
	1、当迭代器进行迭代工作的时候，不能操作集合本身进行添加或删除工作；如果想删除元素，使用迭代器子代的remove()进行删除。
	2、迭代器工作的时候：先调用hasNext()，判断是否有可以迭代的元素，调用next()。否则异常：NoSuchElementException。

集合的遍历迭代：

1、Collection集合：没有下标
	A：Iterator迭代器来遍历
	B：for-each，增强for循环
	
2、List集合：有下标	
	A：Iterator迭代器来遍历
	B：for-each，增强for循环
	C：普通for循环，结合get(index)-->E
	D：ListIterator迭代器也能遍历。