集合
集合和数组都是容器，用来存储多个数据，他们之间的区别是：
- 数组长度固定，集合长度可变
- 集合存储的数据类型必须是引用类型
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
- 注意：
1、Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。
5、Map用 put(k,v) / get(k)，还可以使用containsKey()/containsValue()来检查其中是否含有某个key/value。HashMap会利用对象的hashCode来快速找到key。
* hashing
哈希码就是将对象的信息经过一些转变形成一个独一无二的int值，？？？，这个值存储在一个array中。
我们都知道所有存储结构中，array查找速度是最快的。所以，可以加速查找。
发生碰撞时，让array指向多个values。即，数组每个位置上又生成一个梿表。
6、Map中元素，可以将key序列、value序列单独抽取出来。
使用keySet()抽取key序列，将map中的所有keys生成一个Set。
使用values()抽取value序列，将map中的所有values生成一个Collection。
为什么一个生成Set，一个生成Collection？那是因为，key总是独一无二的，value允许重复。
Iterator迭代器
java提供多个集合，它们在存储数据时，采用的存储方式不同，我们要通过一种通用的获取方式来完成。
Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包括了可以返回迭代器实例的迭代方法。迭代器可以在迭代过程中删除底层集合的元素，但是不可以直接调用集合的remove(Object obj)删除，可以通过迭代器的remove()方法删除。
package cn.itcast.demo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 集合中的迭代器:
* 获取集合中元素方式
* 接口 Iterator : 两个抽象方法
* boolean hasNext() 判断集合中还有没有可以被取出的元素,如果有返回true
* next() 取出集合中的下一个元素
*
* Iterator接口,找实现类.
* Collection接口定义方法
* Iterator iterator()
* ArrayList 重写方法 iterator(),返回了Iterator接口的实现类的对象
* 使用ArrayList集合的对象
* Iterator it = array.iterator(),运行结果就是Iterator接口的实现类的对象
* it是接口的实现类对象,调用方法 hasNext 和 next 集合元素迭代
*/
public class IteratorDemo {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<String>();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
//迭代器,对集合ArrayList中的元素进行取出
//调用集合的方法iterator()获取出,Iterator接口的实现类的对象
Iterator<String> it = coll.iterator();
//接口实现类对象,调用方法hasNext()判断集合中是否有元素
//boolean b = it.hasNext();
//System.out.println(b);
//接口的实现类对象,调用方法next()取出集合中的元素
//String s = it.next();
//System.out.println(s);
//迭代是反复内容,使用循环实现,循环的条件,集合中没元素, hasNext()返回了false
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}
- 常用方法
- 集合元素的向下转型
增强for循环
jdk1.5新特性，增强for循环
新增超级接口Interable
格式：
for(数据类型 变量名：数组或集合）{}
public class ForEachDemo {
public static void main(String[] args) {
function_2();
}
/*
* 增强for循环遍历集合
* 存储自定义Person类型
*/
public static void function_2(){
ArrayList<Person> array = new ArrayList<Person>();
array.add(new Person("a",20));
array.add(new Person("b",10));
for(Person p : array){
System.out.println(p);
}
}
public static void function_1(){
//for对于对象数组遍历的时候,能否调用对象的方法呢
String[] str = {"abc","itcast","cn"};
for(String s : str){
System.out.println(s.length());
}
}
public static void function(){
int[] arr = {3,1,9,0};
for(int i : arr){
System.out.println(i+1);
}
System.out.println(arr[0]);
}
}实现for循环,遍历数组
- 好处: 代码少了,方便对容器遍历
- 弊端: 没有索引,不能操作容器里面的元素
泛型
泛型：就是一种不确定的数据类型。
泛型: 指明了集合中存储数据的类型 <数据类型>
比如：ArrayList<E> E就是泛型。 这种不确定的数据类型需要在使用这个类的时候才能够确定出来。
泛型可以省略，如果省略，默认泛型是Object类型。
- 泛型的好处：
- 省略了强转的代码。
- 可以把运行时的问题提前到编译时期。
- 带泛型的类
package cn.itcast.demo3;
import java.util.ArrayList;
import java.util.Iterator;
/*
* 带有泛型的类
* ArrayList
* E: Element 元素, 实际思想就是一个变量而已
* ArrayList<Integer> , E 接受到类型,就是Integer类型
* public class ArrayList<E>{
*
* public boolean add(Integer e){
* elementData[size++] = e;
* }
*
* public boolean add(E e){}
* }
*
* Iterator<E>
* E next()
*
* Iterator<Integer>
* Integer next()
*
*/
public class GenericDemo1 {
public static void main(String[] args) {
ArrayList<Integer> array = new ArrayList<Integer> ();
array.add(123);
array.add(456);
// ArrayList集合,自己有个方法
// <T> T[] toArray(T[] a)
Integer[] i = new Integer[array.size()];
Integer [] j = array.toArray(i);
for(Integer k : j){
System.out.println(k);
}
}
}- 带泛型的接口
package cn.itcast.demo3;
/*
* 带有泛型的接口
*
* public interface List <E>{
* abstract boolean add(E e);
* }
* 实现类,先实现接口,不理会泛型
* public class ArrayList<E> implements List<E>{
* }
* 调用者 : new ArrayList<String>() 后期创建集合对象的时候,指定数据类型
*
* 实现类,实现接口的同时,也指定了数据类型
* public class XXX implements List<String>{
* }
* new XXX()
*/
public class GenericDemo2 {
}- 使用泛型的好处
- 指定数据类型后，不可以存其他数据类型，否则编译不通过，保证了安全性
- 带来了增强for的使用
泛型通配符
/*
* 定义方法,可以同时迭代2个集合
* 参数: 怎么实现 , 不能写ArrayList,也不能写HashSet
* 参数: 或者共同实现的接口
* 泛型的通配,匹配所有的数据类型 ?
*/
public static void iterator(Collection<?> coll){
Iterator<?> it = coll.iterator();
while(it.hasNext()){
//it.next()获取的对象,什么类型
System.out.println(it.next());
}
}collection<?>就是泛型的通配，仅仅适用于遍历，不能做强转
- 泛型的限定
限定操作的集合类型只能是Employee的子类