Java学习笔记之集合(一)：Collection集合的方法

package com.collection;

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

import org.junit.Test;

/*
* 数组：存储同一种数据类型的集合容器；
*
* 数组的特点：
* 	1、只能存储同一种数据类型的容器；
* 	2、一旦初始化，长度固定；
* 	3、数组中的元素与元素之间的内存地址是连续的；
*
* 注意：Object类型的数组可以存储任意类型的数据（特殊的数组）；
*
* 集合的引入：
* 需求：收集全班同学的兴趣爱好。
* 如果使用数组存储：
* 	String[] arr = new String[]; // 问题：数组长度没法确定；太短不够，太长浪费；
*
* 集合：存储对象数据的集合容器；
* 特点：
* 	1、集合可以存储任意类型的对象数据；数组只能存储同一种类型的数据；
* 	2、集合的长度是不固定的，可以改变；数组的长度是固定的，不能改变；
*
* Collection：单例集合的根接口，定义了集合的规范；
* 	List：如果是实现了List接口的集合类，具备的特点：有序，可重复；
* 	Set：如果是实现了Set接口的集合类，具备的特点：无序，不可重复；
*
* Collection接口中的方法：
* 	增加：
* 		add(E e)：向集合中添加元素，添加成功返回true，添加失败返回false；
* 		addAll(Collection<?> c)：将一个集合中的元素添加到另一个集合中；
* 	删除：
* 		clear()：清空集合中的元素；
* 		remove(Object o)：删除集合中指定的元素；删除成功返回true，删除失败返回false；
* 		removeAll(Collection<?> c)：删除集合中与另一个集合的交集元素；
* 		retainAll(Collection<?> c)：保留集合中与另一个集合的交集元素，其他元素全部删除；
* 	查看：
* 		size()：查看元素的个数；
* 	判断：
* 		isEmpty()：判断集合是否为空；
* 		contains(Object o)：判断集合中是否存在指定的元素；
* 		containsAll(Collection<?> c)：如果集合中包含另一个集合中的所有元素，则返回true；
* 	迭代：
* 		toArray()：返回集合中所有元素的数组；
* 		iterator()：返回一个迭代器Iterator；
* 	迭代器的方法：
* 		1、hasNext()：判断迭代器中是否有元素可遍历，如果有返回true，没有返回false；
* 		2、next()：获取元素；
* 		3、remove()：移除迭代器最后一次返回的元素；
*/

public class Demo1 {

@Test
public void test1(){
// Object类型的数组
Object[] arr = new Object[10];
// 可以存储任意类型的数据
arr[0] = "abc";
arr[1] = 'e';
arr[2] = 123;
}

// 添加方法
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void test2(){
// 集合可以存储任意类型的数据，并且集合的长度是可变的；
Collection c = new ArrayList();
c.add("abc");
c.add(123);
c.add(3.14);
System.out.println("集合的元素：" + c);	// 集合的元素：[abc, 123, 3.14]

Collection c2 = new ArrayList();
c2.add("张三");
c2.add("李四");
c.addAll(c2);	// 将c2集合中的元素添加到c集合中
System.out.println("集合的元素：" + c); // 集合的元素：[abc, 123, 3.14, 张三, 李四]
}

// 删除方法
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void test3(){
Collection c = new ArrayList();
c.add("张三");
c.add("李四");
c.add("王五");

Collection c2 = new ArrayList();
c2.add("赵六");
c2.add("张三");

//		c.clear(); // 清空集合c中的元素

//		boolean b = c.remove("李四"); 	// 删除集合中的"李四"，元素存在，删除成功；
//		boolean b = c.remove("李三");		// 删除集合中的"李三"，元素不存在，删除失败；
//		System.out.println("删除成功了吗？" + b);

//		c.removeAll(c2); 	// 从c集合中删除与c2集合的交集元素；删除的是调用者集合中的元素；
c.retainAll(c2);	// 保留c集合中与c2集合的交集元素，其他元素全部删除；

System.out.println("c集合中的元素：" + c);
System.out.println("c2集合中的元素：" + c2);
System.out.println("c2集合中元素的个数：" + c2.size());
}

// 判断方法
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void test4(){
Collection c = new ArrayList();
c.add("张三");
c.add("李四");
c.add("王五");

//		c.clear();
System.out.println("集合是否为空：" + c.isEmpty()); // 集合为空返回true，不为空返回false；
System.out.println("存在该元素吗？" + c.contains("田七")); // 存在返回true；不存在返回false；

// 在集合中添加自定义元素
Collection c2 = new ArrayList();
c2.add(new Person(1, "张三"));
c2.add(new Person(2, "李四"));
c2.add(new Person(3, "王五"));
System.out.println("集合中的自定义元素：" + c2);

/*
结果为：false，即集合不存在该元素，为什么？
可以从源码查看，那么查看谁的源码？因为在多态的情况下，使用的永远是实现类的方法，所以此处查看ArrayList类的方法；
contains源码为：可以看出，调用的是indexOf()方法，那么继续查看indexOf方法；
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
indexOf()方法源码为：
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
从indexOf源码可以看出，当用于比较的对象，即Object对象不为空时，实际上调用的是传入对象的equals方法，
然后将传入的对象与集合中的元素依次比较；而equals方法默认比较的是对象在内存中的地址，所以此处
新new的Person对象不存在集合中；
那么现在要求只要id一样，就是同一个对象，该怎样实现？
重写equals方法，判断id一样时，就认为是同一个对象；
*/
System.out.println("存在该自定义元素吗？" + c2.contains(new Person(2, "李四")));

// containsAll()：如果集合中包含另一个集合中的所有元素，则返回true；
Collection c3 = new ArrayList();
c3.add(new Person(1, "张三"));
c3.add(new Person(2, "李四"));
System.out.println("c2包含c3中的所有元素吗？" + c2.containsAll(c3)); // true

c3.add(new Person(7, "田七"));
System.out.println("此时c2还包含c3中的所有元素吗？" + c2.containsAll(c3)); // false
}

// 迭代方法
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void test5(){
Collection c = new ArrayList();
c.add("张三");
c.add("李四");
c.add("王五");
Object[] arr = c.toArray(); // 把集合中的元素全部存储到一个Object数组中；
System.out.println("数组中的元素：" + Arrays.toString(arr));

Collection c2 = new ArrayList();
c2.add(new Person(1, "张三"));
c2.add(new Person(2, "李四"));
c2.add(new Person(3, "王五"));
// 需求：取出编号为2的人员的信息；
Object[] arr2 = c2.toArray();
for (int i = 0; i < arr2.length; i++){
Person p = (Person) arr2[i];
if (p.id == 2){
System.out.println("id为2的元素：" + p);
}
}

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

// 遍历集合c2中的所有元素：方式一
for (int i = 0; i < arr2.length; i++){
Person p = (Person) arr2[i];
System.out.println(p);
}

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

// 遍历集合c2中的所有元素：方式二
// 问题：iterator()方法返回的是一个接口类型，为什么可以直接调用方法使用呢？
// 查看ArrayList类中的iterator()方法源码：
// public Iterator<E> iterator() {
//    return new Itr();
// }
// private class Itr implements Iterator<E> {}
// 可以看出，iterator()方法实际上返回的是Iterator接口的实现类的对象；
Iterator it =  c2.iterator(); // 返回一个迭代器
while (it.hasNext()){
Person p = (Person)it.next();
System.out.println(p);
}

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

// remove()：移除迭代器最后一次返回的元素；
Iterator it2 = c2.iterator();

// 此处直接移除，会出现异常：java.lang.IllegalStateException，因为迭代器还没有返回元素；
//		it2.remove();

it2.next();		// 此处返回的是第一个元素；
it2.remove();	// 那么此处移除的就是第一个元素；

System.out.println("集合中的元素：" + c2);
}

}

class Person{

int id;
String name;

public Person(int id, String name) {
this.id = id;
this.name = name;
}

@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + "]";
}

// 重写equals方法，要求只要id一样，就是同一个对象
@Override
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.id == p.id;
}

// Java中的规范：一般重写equals()方法时，都要重写hashcode()方法；
@Override
public int hashCode() {
return this.id;
}

}