Java——集合（Collection接口），迭代器，增强for循环，泛型
一、集合
Collection接口中的方法是集合中所有实现类必须拥有的方法。
- ArrayList implements List
- List extends Collection
1、基本使用
import java.util.ArrayList; /* * 集合体系, * 目标 集合本身是一个存储的容器: * 必须使用集合存储对象 * 遍历集合,取出对象 * 集合自己的特性 */ public class ArrayListDemo { public static void main(String[] args) { /* * 集合ArrayList,存储int类型数 * 集合本身不接受基本类,自动装箱存储 */ ArrayList<Integer> array = new ArrayList<Integer>(); array.add(11); array.add(12); for(int i = 0 ; i < array.size() ;i++){ System.out.println(array.get(i)); } /* * 集合存储自定义的Person类的对象 */ ArrayList<Person> arrayPer = new ArrayList<Person>(); arrayPer.add(new Person("a",20)); arrayPer.add(new Person("b",18)); arrayPer.add(new Person("c",22)); for(int i = 0 ; i < arrayPer.size();i++){ //get(0),取出的对象Person对象 //打印的是一个对象,必须调用的toString() System.out.println(arrayPer.get(i)); } } }
2、清空集合中的元素
/*
* Collection接口的方法
* void clear() 清空集合中的所有元素
* 集合容器本身依然存在
*/
public static void function(){
//接口多态的方式调用
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("bcd");
System.out.println(coll); // ["abc","bcd"]
coll.clear();
System.out.println(coll);
}
3、判断对象是否存在于集合中
/*
* Collection接口方法
* boolean contains(Object o) 判断对象是否存在于集合中,对象存在返回true
* 方法参数是Object类型
*/
private static void function_1() {
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("money");
coll.add("123");
boolean b = coll.contains("abc");
System.out.println(b);
}
4、将集合转成数组
/* Collection接口方法
* Object[] toArray() 集合中的元素,转成一个数组中的元素, 集合转成数组
* 返回是一个存储对象的数组, 数组存储的数据类型是Object
*/
private static void function_2() {
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("itcast");
coll.add("itheima");
coll.add("money");
coll.add("123");
Object[] objs = coll.toArray();
for(int i = 0 ; i < objs.length ; i++){
System.out.println(objs[i]);
}
}
5、移除元素
/*
* Collection接口方法
* boolean remove(Object o)移除集合中指定的元素
*/
private static void function_3(){
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("money");
coll.add("money");
coll.add("123");
System.out.println(coll);
boolean b = coll.remove("money"); //只会移除第一个
System.out.println(b);
System.out.println(coll);
}
二、迭代器
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
集合中的迭代器
由于Java中有多种不同的集合，我们又想有一个统一的方式来获取它的值，所以有了迭代器。
接口Iterator : 其中有两个抽象方法
- boolean hasNext() 判断集合中还有没有可以被取出的元素,如果有返回true
- next() 取出集合中的下一个元素
ArrayList重写方法 iterator()，返回了Iterator接口的实现类的对象
Iterator it = array.iterator()，运行结果就是Iterator接口的实现类的对象
it是接口的实现类对象，调用方法 hasNext 和 next 集合元素迭代
1、基本使用
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo1 {
public static void main(String[] args) {
//集合可以存储任意类型的对象
//集合中,不指定存储的数据类型, 集合就可以什么都存
Collection coll = new ArrayList(); // 多态
coll.add("abc");
coll.add("uyjgtfd");
//迭代器获取
Iterator it = coll.iterator();
while(it.hasNext()){
//it.next()获取出来的是什么数据类型,Object类
//Object obj = it.next();
//System.out.println(obj);
String s = (String)it.next();
System.out.println(s.length());
}
}
}
2、指定迭代数据类型
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 (Iterator<String> it2 = coll.iterator(); it2.hasNext(); ) { // for循环实现迭代器
System.out.println(it2.next());
}*/
}
三、增强for循环
JDK1.5新特性,增强for循环
JDK1.5版本后,出现新的接口 java.lang.Iterable，Collection接口是继承Iterable
增强for循环格式:
for( 数据类型 变量名 : 数组或者集合 ){
sout(变量);
}
/*
* 增强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对于对象数组遍历的时候,能否调用对象的方法呢？当然能，s就是遍历出的对象
String[] str = {"abc","itcast","cn"};
for(String s : str){
System.out.println(s.length());
}
}
/*
* 实现for循环,遍历数组
* 好处: 代码少了,方便对容器遍历
* 弊端: 没有索引,不能操作容器里面的元素
*/
public static void function(){
int[] arr = {3,1,9,0};
for(int i : arr){
System.out.println(i+1);
}
System.out.println(arr[0]);
}
四、泛型
泛型是JDK1.5出现新的安全机制，保证程序的安全性
- 泛型: 指明了集合中存储数据的类型 <数据类型>
public static void function(){
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("rtyg");
coll.add("43rt5yhju");
//coll.add(1);
Iterator<String> it = coll.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s.length());
}
}
1、带有泛型的类
/*
* 带有泛型的类
* 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);
}
}
}
2、带有泛型的接口
public static void function(){
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("rtyg");
coll.add("43rt5yhju");
//coll.add(1);
Iterator<String> it = coll.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s.length());
}
}
3、泛型的通配符
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
/*
* 泛型的通配符
*/
public class GenericDemo {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();
HashSet<Integer> set = new HashSet<Integer>();
array.add("123");
array.add("456");
set.add(789);
set.add(890);
iterator(array);
iterator(set);
}
/*
* 定义方法,可以同时迭代2个集合
* 参数: 怎么实现 , 不能写ArrayList,也不能写HashSet
* 参数: 或者共同实现的接口
* 泛型的通配,匹配所有的数据类型 ?
*/
public static void iterator(Collection<?> coll){
Iterator<?> it = coll.iterator();
while(it.hasNext()){
//it.next()获取的对象,什么类型
System.out.println(it.next());
}
}
}
4、示例
/*
* 将的酒店员工,厨师,服务员,经理,分别存储到3个集合中
* 定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法
*/
import java.util.ArrayList;
import java.util.Iterator;
public class GenericTest {
public static void main(String[] args) {
//创建3个集合对象
ArrayList<ChuShi> cs = new ArrayList<ChuShi>();
ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>();
ArrayList<JingLi> jl = new ArrayList<JingLi>();
//每个集合存储自己的元素
cs.add(new ChuShi("张三", "后厨001"));
cs.add(new ChuShi("李四", "后厨002"));
fwy.add(new FuWuYuan("翠花", "服务部001"));
fwy.add(new FuWuYuan("酸菜", "服务部002"));
jl.add(new JingLi("小名", "董事会001", 123456789.32));
jl.add(new JingLi("小强", "董事会002", 123456789.33));
// ArrayList<String> arrayString = new ArrayList<String>();
iterator(jl);
iterator(fwy);
iterator(cs);
}
/*
* 定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法 work
* ? 通配符,迭代器it.next()方法取出来的是Object类型,怎么调用work方法
* 强制转换: it.next()=Object o ==> Employee
* 方法参数: 控制,可以传递Employee对象,也可以传递Employee的子类的对象
* 泛型的限定 本案例,父类固定Employee,但是子类可以无限?
* ? extends Employee 限制的是父类, 上限限定, 可以传递Employee,传递他的子类对象
* ? super Employee 限制的是子类, 下限限定, 可以传递Employee,传递他的父类对象
*/
public static void iterator(ArrayList<? extends Employee> array){
Iterator<? extends Employee> it = array.iterator();
while(it.hasNext()){
//获取出的next() 数据类型,是什么Employee
Employee e = it.next();
e.work();
}
}
}
