黑马程序员--Java集合

Java集合

一、集合的基本概念

集合：
 *   由于我们使用的是面向对象语言，所以，我们要经常使用对象。而很多时候，我们可能需要使用很的对象，
 *   这个时候，我们就只能使用以前讲过的数组进行存储了，而数组的特点是长度固定。
 *   这样的话就不适合变化的数据。所以，java重新提供了一种容器，用于存储对象，这种容器叫集合。
 *
 * 集合的特点：
 *   A:长度是可以发生改变的。
 *   B:集合只能存储对象。
 *
 * 集合和数组的区别?
 *   数组：
 *    数组长度固定。
 *    数组可以存储基本数据类型，也可以存储引用类型。
 *    数组存储的数据类型是一致的。
 *   集合：
 *    集合长度可变。
 *    集合只能存储引用类型。
 *    集合可以存储不同类型的对象。
 *
 * 我们的集合这种容器，由于数据结构不同，所以，java就对应的提供了很多种集合类，供我们使用。
 *
 * 数据结构：就是数据的组织(存储)方式。

二、Collection接口

Collection是最基本的集合接口，一个Collection代表一组Object的集合，这些Object被称作Collection的元素。

    所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，

有一个Collection参数的构造函数用于创建一个新的Collection，这 个新的Collection与传入的Collection有相同的元素

。后一个构造函数允许用户复制一个Collection。

    如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，

该方法返回一个迭代子，使用该迭代子即可逐一访问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);
	}
}

* 请遍历集合。也就是说要获取到集合中的每一个元素。
 判断集合中是否存在"hello"这个元素.
 

public class CollectionDemo2 {
	public static void main(String[] args) {
		Collection c = new ArrayList();

		c.add("hello"); // String -- Object
		c.add("world");
		c.add("java");
		// c.add(new Student())

		// 直接使用判断功能
		// System.out.println("contains:"+c.contains("hello"));
		// System.out.println("c:" + c);

		// 遍历集合，获取到每一个元素，然后判断这个元素是否是hello
		// Object[] toArray():把集合变成数组。
		Object[] objs = c.toArray();
		for (int x = 0; x < objs.length; x++) {
			// System.out.println(objs[x]);
			// Object obj = objs[x];
			// System.out.println(obj);
			String s = (String) objs[x];
			System.out.println(s + "***" + s.length());
		}
	}
}

二、List接口

Collection
 *   |--List
 *    元素有序(指的是存储顺序和取出顺序是否一致)，可重复。
 *   |--Set
 *    元素无序,唯一。

List继承自Collection接口。List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引

（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。

    跟Set集合不同的是，List允许有重复元素。对于满足e1.equals(e2)条件的e1与e2对象元素，可以同时存在于List集合中。

当然，也有List的实现类不允许重复元素的存在。

    除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，

返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，

 还能向前或向后遍历。

 * List三个儿子的特点：
 * List:
 *   |--ArrayList
 *    底层数据结构是数组，查询快，增删慢
 *    线程不安全，效率高。
 *   |--Vector
 *    底层数据结构是数组，查询快，增删慢
 *    线程安全，效率低。
 *   |--LinkedList
 *    底层数据结构是链表，查询慢，增删快
 *    线程不安全，效率高。
 *   请问，以后我们到底用他的哪个儿子呢?
 *   想安全吗：
 *    想：Vector
 *    不想：ArrayList和LinkedList
 *     查询多：ArrayList
 *     增删多：LinkedList
 *  你根本不会分析，不知道用谁。用ArrayList

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);
	}
}

ArrayList的具体一些用法：

我现在用ArrayList存储多个字符串元素。
 *     比如说数据如下：
 *       hello,world,java,hello,.net,java,php,IOS,java,android
 *     我要求你写程序，实现去除重复元素。
 *       也就是说结果是：
 *       hello,world,java,.net,php,IOS,android

public class ArrayListTest {
	public static void main(String[] args) {
		//创建旧集合，并添加元素
		ArrayList array = new ArrayList();
		array.add("hello");
		array.add("world");
		array.add("java");
		array.add("hello");
		array.add(".net");
		array.add("java");
		array.add("java");
		array.add("java");
		array.add("php");
		array.add("IOS");
		array.add("java");
		array.add("android");
		
		//创建新集合
		ArrayList array2 = new ArrayList();
		
		//遍历旧集合，获取到每一个元素
		Iterator it = array.iterator();
		while(it.hasNext()){
			String s = (String)it.next();
			//在新集合中判断，看是否存在这个元素
			if(!array2.contains(s)){
				//如果s不再array2中存在，就添加
				array2.add(s);
			}
		}
		
		//array2就是没有重复元素的集合。
		//遍历array2
		for(int x=0; x<array2.size(); x++){
			String s = (String) array2.get(x);
			System.out.println(s);
		}
	}
}

三、Set接口

Set继承自Collection接口。Set是一种不能包含有重复元素的集合，即对于满足e1.equals(e2)条件的e1与e2对象元素，

不能同时存在于同一个Set集合里，换句话说，Set集合里任意两个元素e1和e2都满足e1.equals(e2)==false条件，Set最多有一个null元素。

     因为Set的这个制约，在使用Set集合的时候，应该注意：

    1，为Set集合里的元素的实现类实现一个有效的equals(Object)方法。

    2，对Set的构造函数，传入的Collection参数不能包含重复的元素。

    请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

public class SetDemo {
	public static void main(String[] args) {
		// 创建集合对象
		// Collection<String> c = new HashSet<String>();
		// Set<String> set = new HashSet<String>();
		// HashSet<String> hs = new HashSet<String>();

		Set<String> set = new HashSet<String>();

		// 创建并添加元素
		set.add("hello");
		set.add("world");
		set.add("java");
		set.add("world");

		// 遍历
		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			String s = it.next();
			System.out.println(s);
		}

		System.out.println("--------------");

		for (String s : set) {
			System.out.println(s);
		}
	}
}

四、Map集合

以上的所有集合中可以解决很多的东西，但是却不能解决一一对应的关系，但是Map恰恰提供了这个功能。

* Map：最大的优点就是体现对应关系。
 * Map是一个键值对形式的集合。它的数据不再是单个的了，必须同时有键和值组成。
 *
 * Map和Collection的区别?
 * Map:是(键值对)双列形式的集合;键必须是唯一的，不能重复，值可以重复;看成是夫妻对的集合。
 * Collection:是单列值的集合;Collection的List儿子，是可以重复，它的Set儿子是唯一的;看成是单身汉的集合。

* Map接口的功能：
 * A:增加功能
 *   V put(K key,V value):当key在集合中不存在时，添加元素；当key在集合存在时候，替换元素。
 * B:删除功能
 *   void clear():清除所有键值对数据。
 *   V remove(Object key)：根据指定的键删除键值对。
 * C:判断功能
 *   boolean containsKey(Object key):判断指定的键是否在集合中存在
 *   boolean containsValue(Object vlaue):判断指定的值是否在集合中存在
 *   boolean isEmpty():判断集合是否为空
 * D:获取功能
 *   Set<Map.Entry<K,V>> entrySet():键值对对象的集合。
 *   Object get(Object key):根据键获取值
 *   Set<K> keySet():所有键的集合
 *   Collection<V> values()：所有值的集合
 * E:长度功能
 *    int size()
 *
 * 注意：Map集合中的具体实现类的数据结构，是针对键有效

public class MapDemo {
	public static void main(String[] args) {
		// 创建集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 创建元素对象
		// 添加元素
		map.put("czbk001", "林青霞");
		map.put("czbk003", "林志玲");
		map.put("czbk002", "林志颖");

		// V put(K key,V value)
		// 添加元素，如果键存在，就替换。
		// 返回的值是根据键找到的。
		// System.out.println(map.put("czbk004", "林心如"));
		// System.out.println(map.put("czbk003", "林志炫"));
		// System.out.println(map.put("czbk005", "林青霞"));

		// void clear():清除所有键值对数据。
		// map.clear();
		// V remove(Object key)：根据指定的键删除键值对。
		// System.out.println("remove:" + map.remove("czbk003"));
		// System.out.println("remove:" + map.remove("czbk007"));

		// boolean containsKey(Object key):判断指定的键是否在集合中存在
		// System.out.println("containsKey:" + map.containsKey("czbk003"));
		// System.out.println("containsKey:" + map.containsKey("czbk007"));
		// boolean containsValue(Object vlaue):判断指定的值是否在集合中存在
		// boolean isEmpty():判断集合是否为空
		// System.out.println("isEmpty:" + map.isEmpty());
		
		//int size()
		System.out.println("size:"+map.size());

		// 遍历集合(输出集合对象名称)
		System.out.println("map:" + map);
	}
}

* Set<K> keySet():所有键的集合
* Collection<V> values()：所有值的集合

public class MapDemo2 {
	public static void main(String[] args) {
		// 创建集合对象
		Map<Integer, String> map = new HashMap<Integer, String>();

		// 创建并添加元素
		map.put(1, "貂蝉");
		map.put(2, "黄忠");
		map.put(3, "赵云");

		// 显示数据
		// System.out.println(map);

		// Set<K> keySet():所有键的集合
		Set<Integer> set = map.keySet();
		for (Integer i : set) {
			System.out.println(i);
		}

		System.out.println("----------");

		// Collection<V> values()：所有值的集合
		Collection<String> con = map.values();
		for (String str : con) {
			System.out.println(str);
		}
	}
}