标签：java collection iterator foreach 泛型(generic)
一.Collection(java.util)
1.概述:具有相同性质的一类事物的汇聚的整体,称为集合.任何集合都包含三块内容:对外的接口/接口的实现/对集合运算的算法.
java中使用Collection来表示单列集合顶层的接口.
public interface Collection<E> extends Itretaor<E>{}
注意:接口不能直接实例化,得需要其子类
2.特点及体系:Collection为顶层接口,仅描述集合的共性内容.常用的子接口为 List 和 Set.
共性内容:
(1)集合容器的的长度可以改变;
(2)存储的是同一个类型的数据;
(3)只能存引用数据类型(基本数据类型需进行装箱操作);
List : 有序/允许重复;
Set : 无序/不允许重复;
Queue:队列接口;
SortedSet:对集合中的数据进行排序;
3.常用方法:
public boolean add(E e){}:向集合中插入对象;
public boolean addAll(Collection<? extends E> c){}:插入一个集合的内容;
public void clear(){}:清除此集合中的所有内容,但是保留该集合容器;
public boolean contains(Object o){}:判定某一对象是否存在该集合中;
public boolean containsAll(Collection<?> c){}:判断一组对象是否存在该集合中;
public boolean equals(Object o){}:对象比较;
public int hashCode(){}:哈希值;
public boolean isEmpty(){}:判断集合是否为空;
public Iterator<E> iterator(){}:为Iterator接口实例化;返回迭代器实例化对象;
public boolean remove(Object o){}:删除指定对象;
public boolean removeAll(Collection<?> c){}:删除一组对象;
public boolean retainAll(Collection<?> c){}:保存指定内容;
public int size(){}:求出集合大小;
public Object[] toArray(){}:将一个集合变为对象数组;
代码:
import java.util.Collection;
import java.util.ArrayList;
public class Coll{
public static void main(String[] args){
//通过子类实例化接口对象,因为接口全为抽象无法直接实例化
Collection<String> c = new ArrayList<String>();
//添加元素add()
c.add("Rose");
c.add("Jack");
//查看集合内容
System.out.println(c);//[Rose, Jack]
//查看集合长度
System.out.println(c.size());//2
//查看是否包含tom
System.out.println(c.contains("tom"));//false
//查看是否包含Tom
c.add("Tom");
System.out.println(c.contains(new String("Tom")));//true--new String("Tom")返回一个"Tom"字符串
//删除指定对象remove()
c.remove("Rose");
System.out.println(c);//[Jack, Tom]
//删除所有对象-保留集合
c.clear();
System.out.println(c);//[]
//判断是否为空
System.out.println(c.isEmpty());//true
}
}二.Iterator(java.util)
1.定义:专门操作集合的工具类,只要碰到集合的输出操作就一定使用Iterator接口
pbulic interface Iterator<E>
2.常用方法:
public boolean hasNext(){}:判断是否存在下一个值;
public E next(){}:取出当前元素;
public void remove(){}:移除当前元素;
3.注意事项:
(1)使用迭代器只能删除数据,不能添加数据;
(2)迭代器迭代数据的过程中,不能使用集合自带的方法,改变集合的长度!否则会报异常:ConcurrentModificationException 并发修改异常!
(3)注意在构建迭代器的时候,其后<>内指定类型(如:Iterator<String> it = Collection.iterator();),否则运算会出错,仅打印没问题;
代码1://需求:利用Iterator输出集合内容
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class IteratorDemo{
public static void main(String[] args){
//通过子类实例化对象实例化Collection对象
Collection<String> c = new ArrayList<String>();
//向集合c中添加元素
c.add("Green");
c.add("Smith");
c.add("Philip");
//通过Collection的iterator方法,创建iterator对象
Iterator<String> it =c.iterator();//注意在构建迭代器的时候,指定类型(此处为<String>),否则运算会出错,仅打印没问题
//输出集合c中的所有元素
while(it.hasNext()){
System.out.print(it.next()+"\t");//注意,建议判断一次仅调用一次next()方法,由于next()在输出的时候也会使指针向前移动,容易发生"NoSuchElementException"
//System.out.println("i like"+it.next());//java.util.NoSuchElementException
}
}
}代码2://需求:删除元素
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class IteratorDemo{
public static void main(String[] args){
//通过子类实例化对象实例化Collection对象
Collection<String> c = new ArrayList<String>();
//向集合c中添加元素
c.add("Green");
c.add("Smith8");
c.add("Philip");
//foreach迭代
for(String s : c){
System.out.print(s+"\t")//Green Smith8 Philip
}
System.out.println("====================")
//通过Collection的iterator方法,创建iterator对象
Iterator<String> it =c.iterator();//注意在构建迭代器的时候,指定类型(此处为<String>),否则运算会出错,仅打印没问题
//输出集合c中的所有元素
while(it.hasNext()){
//取出集合中的元素
String str = it.next();
//判断是否含有数字--正则(字符串最后一位是数字的)
if(str.matches("\\w+\\d")){
it.remove();
}else{
System.out.print(str+"\t");// Green Philip
}
}
System.out.print("删除带数字的名称后为:"+c+"\t");//删除带数字的名称后为:[Green, Philip]
}
}三.for--each
1.作用:增强for是JDK1.5之后出现的新特性,可以用于迭代(遍历/循环)集合或数组!可以使用增强for替代迭代器,获取集合的元素内容!
2.格式:
for(数据类型 变量名 : 对象名或数组名){
集合或数组中的每一个元素!
}
3.代码:见二.Iterator代码2
四.泛型(Generic)
1.定义:一种特殊的变量,保存的是引用变量的类型
2.好处:避免数据类型的转换;将运行时期ClassCastException提前到编译时期
3.自定义带泛型的类:
public class A<泛型名>{
}
注:类中凡是使用到数据类型的地方,都可以使用泛型名代替;
泛型名自定义,但是将来使用者只能传递引用数据类型;
代码实现:
//自定义泛型类和泛型方法:
class A<MM>{
private MM name;
private int age;
public MM getName(){
return name;
}
public void setName(MM name){
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public void say(){
System.out.println(this.name+"\t"+this.age);
}
//定义一个带泛型的方法,传入一个QQ类型的值,返回一个QQ类型的值
public <QQ> QQ show(QQ m){
System.out.println(m);
return m;
}
}
public class MmDemo{
public static void main(String[] args){
//MM此处开始确定为String类型
A<String> a = new A<>();
a.setName("baobao");
a.setAge(24);
a.say();
//带泛型的show方法QQ此处定为String类型
a.show("xiaobao");//xiaobao
//带泛型的show方法QQ此处定为int类型
a.show(123);//123
A<String> b = new A<>();
b.setName("rongrong");
b.setAge(12);
b.say();
}
}4.自定义带泛型的方法:
public <泛型名>泛型 getName(){
return name;
}
代码:见3.代码实现
5.自定义带泛型的接口:
public interface B<泛型名>{
}
注:接口中凡是使用到数据类型的地方都可以使用泛型名代替;
代码实现:
给泛型赋值的格式有两种形式:
(1)在定义子类的时候,直接给接口的泛型传递固定的数据类型;
public class 类名 implements 接口名<具体的数据类型>{
在类中但凡是使用到数据类型的地方,都可以使用泛型名代替;
}
(2)在定义子类的时候也不确定数据类型,在创建子类对象的时候,确定数据类型
public class 类名<泛型名B> implements 接口名<泛型名B>{
在类中但凡是使用到数据类型的地方,都可以使用泛型名代替;
}
//定义一个带泛型的接口
interface A<W>{
//带泛型参数的show方法,抽象方法
public abstract void show(W w);
}
//定义一个实现类--带泛型的实现类
class BImpl<W> implements A<W>{//类名后需加上与接口一致的泛型名
@Override
public void show(W w){//重写了带泛型的方法
System.out.println(w);
}
public static void main(String[] args){
BImpl<String> b = new BImpl<>();
b.show("baobao");//baobao
BImpl<Integer> a = new BImpl<>();
a.show(12345);//12345
}
}
6.泛型通配符:?
创建带泛型的类的对象的时候,泛型不能使用多态;只能使用通配符的形式,来达到这样的效果;
具体的通配符的符号:? 代表任意数据类型
对通配符的范围进行限定:
? extends 具体的数据类型A 此时是限定了上限;A类或A类的子类符合要求,其他数据类型不能传递;
? super 具体的数据类型A 此时是限定了下限;A类或A类的父类符合要求,其他数据类型不能传递;
代码实现:
import java.util.List;
import java.util.ArrayList;
//定义一个父类
class Father{
}
//定义一个子类
class Son extends Father{
}
//定义一个测试类
public class FsDemo{
public static void main(String[] args){
//分别使用Object Father Son作为泛型,定义list集合
List<Object> Biggest = new ArrayList<>();
List<Father> Bigger = new ArrayList<>();
List<Son> Big = new ArrayList<>();
//method1(Biggest);//错误: 不兼容的类型: List<Object>无法转换为List<? extends Father>
method1(Bigger);//safe extends
method1(Big);//safe extends
method2(Biggest);//safe super
method2(Bigger);//safe super
//method2(Big);//错误: 不兼容的类型: List<Son>无法转换为List<? super Father>
}
//定义带泛型的method1方法,上限为Father--? extends Father
public static void method1(List<? extends Father> list){
System.out.println("safe extends");
}
//定义带泛型的method2方法,下限为Father--? super Father
public static void method2(List<? super Father> list){
System.out.println("safe super");
}
}Collection-Iterator-foreach-泛型(Generic)
标签：java collection iterator foreach 泛型(generic)
原文地址：http://huguangqin2015.blog.51cto.com/10856722/1939526
