集合
程序引例
/*
需求：利用数组存储3个学生信息，遍历数组获取每一个学生的信息
*/
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class ObjectArrayDemo1 {
public static void main(String[] args) {
Student[] arr = new Student[3];
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);//null
}
System.out.println("---------------------------------");
//创建3个学生对象
Student xiaowang = new Student("王力宏", 40);
Student dengdeng = new Student("邓超", 45);
Student huazai = new Student("刘德华", 60);
//将创建好的3个学生对象，放到数组中
// for(int i=0;i<arr.length;i++){
// arr[i] = s1;
// }
//给对象数组赋值，使用循环是有问题的，因为对象的名字没有规律，
//没办法将每次循环依次赋值不一样的对象
//所以给对象数组赋值，只能一个一个赋值
arr[0] = xiaowang;
arr[1] = dengdeng;
arr[2] = huazai;
//遍历数组获取每一个学生对象
for (int i = 0; i < arr.length; i++) {
// 方法1：通过Students中重写的toString()方法
// System.out.println(arr[i]);
// 通过get()方法依次获取每个对象的信息
Student student = arr[i];
System.out.println(student.getName() + "--" + student.getAge());
}
}
}
内存图解
集合与数组的不同点以及Collection接口概述和成员方法
import java.util.ArrayList;
import java.util.Collection;
/*
为什么出现集合类？
在上一个例子当中，假设在存储完所有的学生对象的后，来了一个新同学A,也想放到
对象数组中，直接放进去的话，长度已经是确定的，很明显没有空余的位置。
那怎么办呢？搞一个新的数组，长度是原来数组长度+1，然后再挨个存放。
这时候，有一个学生B,提前毕业，数组中的元素就少了一个，但是呢，现在数组中就有一个空的位置。
而这个空的位置依旧是占用内存的，也不太好，所以你又创建一个新的数组，长度-1，然后挨个存放。
上面的例子，无论是从增加还是删除，都非常麻烦，其实原则上我们修改是根据原先的东西基础上进行修改的。
想一想，如果有一个东西，可以根据存放的内容多少，自由改变长度就好了。
这时候我们想到之前还学过一个容器，叫做StringBuffer，它就可以根据元素的多少来改变长度。
但是，StringBuffer里面存储始终是一个一个的字符，而我们现在需要存放学生对象
所以用StringBuffer也不太合适。
Java替我们考虑到了这一点，根据存储的元素不同，元素的特点不同以及存储方式不同，
提供了一个集合继承体系给我们--------集合
集合和数组的不同点：
1、数组的长度是不可变的，集合是可以改变
2、数组可以存放同一种基本数据类型或者引用数据类型
而集合只能存放引用数据类型，并且集合中可以存放不同的引用数据类型
（我们虽然说了集合可以存放不同的引用数据类型，确实也可以这么做，但是，
开发中一个集合存放一种数据类型。）
集合可以存放各种各样的数据，每种数据的长度，大小以及自身的特点都不一样。
所以，java提供的集合也应该不能够是单一的，我们要针对不同的需求，java提供不同的集合类。
这么多不同的集合，它们的底层数据结构也是不同的，不同并不重要，我们只要知道集合是可以用来
存放东西的，不光可以存放，而且可以去使用这些东西，比如：查找获取，判断等等。
既然可以上面的操作，这些不同的集合类应该有某种共性的内容，所以我们根据集合的共性内容不断地
向上提取，最终整体形成一个继承体系。
Collection:是集合中的顶层接口，它存在由它扩展开来的继承体系，为什么要分出很多不同的集合？
因为根据元素是否唯一、是否有序来区分这么多集合（后面会一一介绍）
Collection：
1、添加功能
boolean add(Object obj)
确保此集合包含指定的元素（可选操作）。
boolean addAll(Collection c)
将指定集合中的所有元素添加到此集合（可选操作）。
2、删除功能
boolean remove(Object o)
从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
boolean removeAll(Collection<?> c)
删除指定集合中包含的所有此集合的元素（可选操作）。
void clear()
从此集合中删除所有元素（可选操作）。
3、获取功能
Iterator<E> iterator() 返回此集合中的元素的迭代器。
4、判断功能
boolean contains(Object o)
如果此集合包含指定的元素，则返回 true 。
boolean containsAll(Collection<?> c)
如果此集合包含指定 集合中的所有元素，则返回true。
boolean isEmpty()
如果此集合不包含元素，则返回 true 。
5、获取长度功能
int size()
返回此集合中的元素数。
6、求交集功能
boolean retainAll(Collection<?> c)
仅保留此集合中包含在指定集合中的元素（可选操作）。
7、将集合转换成数组
Object[] toArray()
返回一个包含此集合中所有元素的数组。
*/
public class CollectionDemo1 {
public static void main(String[] args) {
//通过子类的形式创建对象，这叫接口多态
Collection c = new ArrayList();
//boolean add(Object obj) 确保此集合包含指定的元素（可选操作）。
//如果此集合由于调用而更改，则返回true 。
//（如果此集合不允许重复，并且已包含指定的元素，则返回false。 ）
//ArrayList里面可以允许有重复的元素
System.out.println(c.add("hello"));//true
System.out.println(c.add("hello"));//true
c.add(20);//--这里面含有自动装箱（包装类）
c.add(12.34);//--这里面含有自动装箱（包装类）
//void clear() -- 清空
//从此集合中删除所有元素（可选操作）。
//c.clear();
//boolean remove(Object o)
//从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
//如果此集合包含指定的元素（或等效地，如果此集合由于调用而更改），则返回true 。
//只移除一个符合条件的
System.out.println("从该集合中删除指定元素" + c.remove("hello"));
//boolean contains(Object o)
//如果此集合包含指定的元素，则返回 true 。
System.out.println(c.contains("hello"));
//boolean isEmpty()
//如果此集合不包含元素，则返回 true 。
System.out.println(c.isEmpty());
//获取长度功能int size()
//返回此集合中的元素数。
System.out.println(c.size());
//String toString()
//返回此集合的字符串表示形式。 AbstractCollection类中的toString()方法
/**
*继承体系：
* java.lang.Object
* java.util.AbstractCollection<E>
* java.util.AbstractList<E>
* java.util.ArrayList<E>
*/
System.out.println("集合c: " + c);
}
}
集合的继承体系及学习顺序
Collection接口中带all的成员方法
import java.util.ArrayList;
import java.util.Collection;
/*
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)
*/
public class CollectionDemo2 {
public static void main(String[] args) {
//创建一个集合对象
Collection c1 = new ArrayList();
//向集合中添加元素
c1.add("hello");
c1.add("world");
c1.add("java");
c1.add("hadoop");
c1.add("hive");
//定义另一个集合
Collection c2 = new ArrayList();
c2.add("hello");
c2.add("world");
c2.add("hive");
c2.add("spark");
System.out.println("c1: "+c1);
System.out.println("c2: "+c2);
System.out.println("===============================");
//boolean addAll(Collection c)
// System.out.println("将c2添加到从c1中：");
//将c2整体作为一个元素添加到c1中
// System.out.println(c1.add(c2));//true--//[hello,world,java,hadoop,hive,[hello,world,hive,spark]]
//将c2中每个元素取出来添加到c1中
// System.out.println(c1.addAll(c2));//true--//[hello,world,java,hadoop,hive,hello,world,hive,spark]
// System.out.println("c1: "+c1);
// System.out.println("c2: "+c2);
System.out.println("===============================");
//boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素（可选操作）。
//此调用返回后，此集合将不包含与指定集合相同的元素。
//就是将c1中和c2一样的元素全部删掉
// System.out.println(c1.removeAll(c2));//true
// System.out.println("c1: "+c1);//[java, hadoop]
// System.out.println("c2: "+c2);//[hello, world, hive, spark]
System.out.println("===============================");
// //boolean containsAll(Collection c)
//如果此集合包含指定集合中的所有元素，则返回true。
// System.out.println(c1.containsAll(c2));//false
System.out.println("===============================");
//boolean retainAll(Collection c)
//仅保留此集合中包含在指定集合中的元素（可选操作）。
//换句话说，从该集合中删除所有不包含在指定集合中的元素。
//假设有两个集合 c1,c2
//c1对c2做交集，最终的结果保存在c1中，c2不变
//并且c1中删除与c2不是共同的其他元素
// System.out.println(c1.retainAll(c2));
// System.out.println("c1: "+c1);
// System.out.println("c2: "+c2);
}
}
