1）、集合是一个装”引用类型”的”容器”
2）、Java内部提供了很多”集合类”，每种集合类对元素的存储采用了不同的”数据结构”–集合存储数据的方式。
3）、这些数据结构都是各有千秋，有的增删快，查询慢；有的增删慢，查询快
4）、常用数据结构：
1）、数组：ArrayList（增删慢，查询快，常用于查询）
2）、链表：LinkedList（增删快，查询慢，常用于操作数据）
3）、哈希表：HashSet（增删改查都快，但每次都要生成哈希值）
……
5）、集合体系
1）、添加
public boolean add(E e)： 把给定的对象添加到当前集合中 。
ArrayList会永远返回true；
set中添加重复元素时，返回false；
2）、删除
public void clear() :清空集合中所有的元素。
public boolean remove(E e): 把给定的对象在当前集合中删除。
当移除多个相同元素，只移除遇到的第一个
3）、判断
public boolean contains(E e): 判断当前集合中是否包含给定的对象。
public boolean isEmpty(): 判断当前集合是否为空。
4）、获取
public int size(): 返回集合中元素的个数。
public Object[] toArray(): 把集合中的元素，存储到数组中。
5）、遍历
public Iterator iterator():获取一个迭代器
public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。
1）、public boolean hasNext():如果仍有元素可以迭代，则返回 true。
2）、public E next():返回迭代的下一个元素。
publicstaticvoidmain(String[] args) {
Collection list =newArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
System.out.println(list);
Iterator iterable = list.iterator();while(iterable.hasNext()){
System.out.println(iterable.next());
}
}
1）、增强for也叫：foreach循环，是一种for循环的新写法；
2）、使用增强for可以遍历数组、集合：
1）、数组：
int[] arr = {1,2,3,4,5,6};for(int i = 0; i < arr.length ; i++){
int n = arr[i];
System.out.println(n);
}//增强forfor(int n:arr){//底层编译为：普通for循环 System.out.println(n);
}
2）、集合：
ArrayList list =newArrayList<>();
//增强forfor(String str:list){
//底层编译为：迭代器System.out.println(str);
}
1）、ArrayList list = new ArrayList<>();
String就是这个集合的泛型
集合中只允许写入泛型的类型数据
2）、泛型的好处：可以让编译器帮助我们监视，只能向集合中添加指定的类型
泛型定义说明：
1）、中的E：可以是大写、小写、字符、多个字符；
2）、类中的方法可以使用这个类型名
class Student<E>{
public void add(E e){}
public E get(){return null;}
}
测试类：
Student<引用类型> stu = new Student<>();
stu.add(引用类型 对象名);
stu.get();//返回对应的引用类型
public classStudent{ public <E> void sum(E e1,E e2,E e3,E e4){//定义一个接收4个相同的值 System.out.println("e1 = "+e1);
System.out.println("e2 = "+e2);
System.out.println("e3 = "+e3);
System.out.println("e4 = "+e4);
}
}
测试类：
public static void main(String[] args) {
Student student = new Student();
student.<Integer>sum(1,2,3,4);//规定4个值的泛型为Integer
student.<String>sum("aaa","bbb","ccc","ddd");//String
}
同泛型类：
public interfaceIA{
public void add(E e);
}
1）、定义一个方法，方法的参数：任何泛型的集合
**
class Demo{
public static void main(String[] args){
ArrayList<String> list1 = new ArrayList<>();
ArrayList<Integer> list2 = new ArrayList<>();
ArrayList<Student> list3 = new ArrayList<>();
p1(list1);//OK的 p1(list2);//OK的 p1(list3);//OK的 p1("呵呵");//错误 }
public static void p1(ArrayList<?> list){
}
}
2）、定义一个方法，方法的参数：一个类和他的子类做泛型的集合(
class Person{}
class Student extends Person{}
class JavaStudent extends Student{}
测试类：
class Demo{
public static void main(String[] args){
ArrayList<Person> list1 = new ArrayList<>();
ArrayList<Student> list2 = new ArrayList<>();
ArrayList<JavaStudent> list3 = new ArrayList<>();
p1(list1);//错误 p1(list2);//OK的 p1(list3);//OK的 }
public static void p1(ArrayList<? extends Student> list){}
}
3）、定义一个方法，方法的参数：一个类和他的父类做泛型的集合(
class Demo{
public static void main(String[] args){
ArrayList<Person> list1 = new ArrayList<>();
ArrayList<Student> list2 = new ArrayList<>();
ArrayList<JavaStudent> list3 = new ArrayList<>();
p1(list1);//OK的 p1(list2);//OK的 p1(list3);//错误 }
public static void p1(ArrayList<? super Student> list){}
}
[ ] 能够说出集合与数组的区别
1、集合的长度是可变的，集合可以存放引用类型
2、数组的长度是有限的，数组可以存放任意类型
[ ] 说出Collection集合的常用功能
.add(E e):向集合中添加元素
.clear():将集合清空
.remove(E e):清除集合中的特定元素
.contains(E e):查找集合中是否有这个元素，返回boolean
.isEmpty();检查集合是否为空，为空返回true
.size():返回集合的长度
.toArray():将集合转化为数组返回
[ ] 能够使用迭代器对集合进行取元素
Iterator i = list.iterator;
i.hasNext():检查集合中下一个是否有元素
i.Next():返回集合中的数据
[ ] 能够说出集合的使用细节
[ ] 能够使用集合存储自定义类型
[ ] 能够使用foreach循环遍历集合
ArrayList<数据类型> list = new ArrayList<>();
for(数据类型 对象名：list){遍历}
[ ] 能够使用泛型定义集合对象
[ ] 能够理解泛型上下限
[ ] 能够阐述泛型通配符的作用
