接口Collection和List

 集合：
 * 		由于我们使用的是面向对象语言，所以，我们要经常使用对象。而很多时候，我们可能需要使用很的对象，
 * 		这个时候，我们就只能使用以前讲过的数组进行存储了，而数组的特点是长度固定。
 * 		这样的话就不适合变化的数据。所以，java重新提供了一种容器，用于存储对象，这种容器叫集合。
 * 
 * 集合的特点：
 * 		A:长度是可以发生改变的。
 * 		B:集合只能存储对象。
 * 
 * 集合和数组的区别?
 * 		数组：
 * 			数组长度固定。
 * 			数组可以存储基本数据类型，也可以存储引用类型。
 * 			数组存储的数据类型是一致的。
 * 		集合：
 * 			集合长度可变。
 * 			集合只能存储引用类型。
 * 			集合可以存储不同类型的对象。
 * 
 * 我们的集合这种容器，由于数据结构不同，所以，java就对应的提供了很多种集合类，供我们使用。
 * 
 * 数据结构：就是数据的组织(存储)方式。
 * 
 * Collection中应该有什么功能
 * A:添加功能
 * 		boolean add(Object obj):向集合中添加一个元素
 * 		boolean addAll(Collection c)：向集合中添加一个集合的元素。
 * B:删除功能
 * 		void clear()：删除集合中的所有元素。
 * 		boolean remove(Object obj)：从集合中删除指定的元素
 * 		boolean removeAll(Collection c):从集合中删除一个指定的集合元素。 
 * C:判断功能
 * 		boolean isEmpty()：判断集合是否为空。
 * 		boolean contains(Object obj)：判断集合中是否存在指定的元素。
 * 		boolean containsAll(Collection c)：判断集合中是否存在指定的一个集合中的元素。
 * D:遍历功能
 * 		Iterator iterator():就是用来获取集合中每一个元素。
 * E:长度功能
 * 		int size():获取集合中的元素个数
 * F:交集功能
 * 		boolean retainAll(Collection c):判断两个集合中是否有相同的元素。???
 * G:把集合转换成数组
 * 		Object[] toArray():把集合变成数组。 
 
public class CollectionDemo {
	public static void main(String[] args) {
		// 创建对象
		// Collection c = new Collection();//接口不能被实例化
		Collection c = new ArrayList();

		// 添加元素
		// boolean add(Object obj):一个是添加，一个是返回添加是否成功。
		// System.out.println(c.add("hello"));
		// c.add("world");
		c.add("hello");
		c.add("world");
		c.add("java");

		// 删除功能
		// void clear()：删除集合中的所有元素。
		// c.clear();
		// boolean remove(Object obj)
		// System.out.println("remove:"+c.remove("world"));
		// System.out.println("remove:"+c.remove("wor"));

		// 判断功能
		// boolean isEmpty()
		// System.out.println("isEmpty:"+c.isEmpty());
		// boolean contains(Object obj)
//		System.out.println("contains:" + c.contains("world"));
//		System.out.println("contains:" + c.contains("wor"));

		// 长度功能
		// int size()
		System.out.println("size:" + c.size());

		System.out.println("c:" + c);
	}
}
import java.util.ArrayList;


import java.util.Collection;


 * 所有带All的方法：
 * boolean addAll(Collection c)：向集合中添加一个集合的元素。
 * boolean removeAll(Collection c):从集合中删除一个指定的集合元素。 
 * boolean containsAll(Collection c)：判断集合中是否存在指定的一个集合中的元素。
 * boolean retainAll(Collection c):判断两个集合中是否有相同的元素。???
 
public class CollectionDemo3 {
	public static void main(String[] args) {
		// 创建一个集合
		Collection c1 = new ArrayList();
		c1.add("abc1");
		c1.add("abc2");
		c1.add("abc3");
		c1.add("abc4");

		// 再创建一个集合
		Collection c2 = new ArrayList();
		c2.add("abc1");
		c2.add("abc2");
		c2.add("abc3");
		c2.add("abc4");
		c2.add("abc5");
		c2.add("abc6");
		c2.add("abc7");

		// boolean addAll(Collection c)：向集合中添加一个集合的元素。
		//System.out.println("addAll:" + c1.addAll(c2));

		// boolean removeAll(Collection c):从集合中删除一个指定的集合元素。
		// 只要有数据被删除，则返回true。
		// System.out.println("removeAll:" + c1.removeAll(c2));

		// boolean containsAll(Collection c)：判断集合中是否存在指定的一个集合中的元素。
		// 只有所有数据包含了，才返回true
		// System.out.println("containsAll:" + c1.containsAll(c2));

		// boolean retainAll(Collection c)
		
		 * 如果有两个集合A和B。
		 * A对B做交集。
		 * A集合保存的是交集元素。B集合不发生改变。
		 * 返回值表示的是A集合是否发生过改变。
		 
		//System.out.println("retainAll:" + c1.retainAll(c2));

		System.out.println("c1:" + c1);
		System.out.println("c2:" + c2);
	}
}





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


 * Iterator iterator():就是用来获取集合中每一个元素。
 * 
 * 成员方法：
 * 		Object next():获取元素,并自动移动到下一个位置等待获取。
 * 		boolean hasNext():判断迭代器中是否还有元素。
 * 		
 * NoSuchElementException:没有这样的元素异常。你已经获取到元素末尾了，你还要获取，已经没有元素了。所以报错了。
 
public class IteratorDemo {
	public static void main(String[] args) {
		// 创建对象
		Collection c = new ArrayList();

		// 添加元素
		c.add("hello");
		c.add("world");
		c.add("java");

		// 方式1
		// Object[] objs = c.toArray();
		// for (int x = 0; x < objs.length; x++) {
		// String s = (String) objs[x];
		// System.out.println(s);
		// }

		// 方式2
		// Iterator iterator():就是用来获取集合中每一个元素。
		// 通过集合对象获取迭代器对象
		Iterator it = c.iterator();// 这是返回的是Iterator的子类对象,多态

		// Object obj = it.next();
		// System.out.println(obj);
		// System.out.println(it.next());
				

		while (it.hasNext()) {
			// System.out.println(it.next());
			String s = (String) it.next();
			System.out.println(s);
		}
	}
}



 List的特有功能：
 * A:添加功能
 * 		void add(int index, Object obj):在指定位置添加元素
 * B:删除功能
 * 		Object remove(int index):根据指定索引删除元素，并把删除的元素返回。
 * C:修改功能
 * 		Object set(int index, Object obj):把指定索引位置的元素修改为指定的值，返回修改前的值。
 * D:获取功能
 * 		int indexOf(Object o):返回指定元素在集合中第一次出现的索引
 * 		Object get(int index):获取指定位置的元素
 * 		ListIterator listIterator()：列表迭代器
 * E:截取功能
 * 		List subList(int fromIndex, int toIndex)：截取集合。
 
public class ListDemo2 {
	public static void main(String[] args) {
		// 创建集合对象
		List list = new ArrayList();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// void add(int index, Object obj):在指定位置添加元素
		// list.add(1,"javaEE");
		// IndexOutOfBoundsException
		// list.add(14,"javaSE");

		// Object remove(int index):根据指定索引删除元素，并把删除的元素返回。
		// System.out.println("remove:"+list.remove(1));
		// System.out.println("remove:"+list.remove(12));

		// Object set(int index, Object obj):把指定索引位置的元素修改为指定的值，返回修改前的值。
		// System.out.println("set:" + list.set(1, "javaee"));
		
		//List subList(int fromIndex, int toIndex)：截取集合。
		// List list2 = list.subList(1, 2);
		// System.out.println("list2:"+list2);
		
		//int indexOf(Object o):返回指定元素在集合中第一次出现的索引
		System.out.println("indexOf:"+list.indexOf("world"));
		System.out.println("indexOf:"+list.indexOf("world2"));

		System.out.println("list:" + list);
	}
}





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


 * Object get(int index):获取指定位置的元素
 
public class ListDemo3 {
	public static void main(String[] args) {
		// 创建集合对象
		List list = new ArrayList();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// System.out.println("get:" + list.get(0));
		// System.out.println("get:" + list.get(1));
		// System.out.println("get:" + list.get(2));
		// IndexOutOfBoundsException
		// System.out.println("get:" + list.get(3));
		// 通过上面的测试，我们发现，索引在变
		// 那么，如果我们有办法知道，索引的范围，我们就可以遍历集合
		// 我们知道吗?0-(size()-1)
		// 结合size()和get()对集合进行遍历
		for (int x = 0; x < list.size(); x++) {
			String s = (String) list.get(x);
			System.out.println(s);
		}
	}
}



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


 * ListIterator listIterator()：列表迭代器
 * 
 * public interface ListIterator extends Iterator
 * 
 * 面试题：ConcurrentModificationException:并发修改异常。
 * 		这是个什么异常，怎么产生的，怎么解决的?
 
 * 怎么产生：
 * 	当我们通过迭代器迭代元素的过程中，又通过集合去添加了元素。这种情况是不允许的。
 * 	因为迭代器是依赖于集合存在的，如果集合发生改变，迭代器也应该相应的发生改变。
 * 	而我们目前看到的确实，迭代器没变，集合变了。所以，报出了一个并发修改异常。
 * 
 * 注意问题：通过迭代器遍历集合的时候，是不能通过集合去操作(添加，删除)。
 * 那么，我们可不可以这样理解呢？
 * A:全部通过迭代器操作：元素是添加到刚遍历的那个元素后面。
 * 		通过迭代器迭代的时候，可以通过迭代器对集合进行操作。
 * B:全部通过集合操作：元素是添加到最后的。
 * 		通过集合普通for遍历的时候，可以通过集合去操作。
 *
public class ListDemo4 {
	public static void main(String[] args) {
		// 创建集合对象
		List list = new ArrayList();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// 迭代器
		// Iterator it = list.iterator();
		// while (it.hasNext()) {
		// String s = (String) it.next();
		// System.out.println(s);
		// }
		// System.out.println("-----------");

		
// 需求：请遍历集合，判断其中是否有"hello"这个元素，如果有，就再添加一个元素:"IOS"
		// Iterator it = list.iterator();
		// while (it.hasNext()) {
		// String s = (String) it.next();
		// if ("hello".equals(s)) {
		// list.add("IOS");
		// // it = list.iterator();//这样从原理是可以解决的，但是它会引起另外一个问题。
		// }
		// }
		// System.out.println("list:" + list);
		// System.out.println("-----------");

		// 完全通过集合实现
		// for (int x = 0; x < list.size(); x++) {
		// String s = (String) list.get(x);
		// if ("hello".equals(s)) {
		// list.add("IOS");
		// }
		// }
		// System.out.println("list:"+list);
		// System.out.println("-----------");

		// 遍历
		ListIterator lit = list.listIterator();
		while (lit.hasNext()) {
			String s = (String) lit.next();
			if ("hello".equals(s)) {
				lit.add("IOS");
			}
		}
		System.out.println("list:" + list);
	}
}