欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

JAVA基础之集合、Iterator迭代器、泛型及增强for循环

程序员文章站 2022-06-22 12:48:11
个人理解: 对于集合,首先要明确的是最顶层的接口是Collection接口类,其包含一些基本的方法以便子类调用,不过在定义的时候最好定义好数据类型,以免遍历时还得必须进行向上转型;特别注意的是其没有关于下标的方法。同时为了方便遍历其元素,建立了一个Iterable类由Collection进行实现其独 ......

个人理解:

  对于集合,首先要明确的是最顶层的接口是collection接口类,其包含一些基本的方法以便子类调用,不过在定义的时候最好定义好数据类型,以免遍历时还得必须进行向上转型;特别注意的是其没有关于下标的方法。同时为了方便遍历其元素,建立了一个iterable类由collection进行实现其独有的返回迭代器的方法,以便下面的子类进行迭代的实现。

关于泛型:

  (泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?
顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。
  泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。)
  个人认为就像个形参一样的,最好前期定义好,以免再出现转换类型。了解下通配符?,上限需要extends,下限需要super。不过泛型里面没有继承的概念。
增强for循环极大的减少的for循环的代码量,当不要进行操作而只是进行遍历时,建议还是使用增强版的。
 

一、集合:

1、介绍:

集合是java中提供的一种容器,可以存储多个数据;集合的长度是可变的,存储的必须是引用数据类型(数组长度是固定的)。

2、arraylist集合存储元素及遍历:

public static void main(string[] args) {
arraylist<integer> list = new arraylist<integer>();
    list.add(111);
    list.add(222);
    list.add(333);
    list.add(444);
    list.add(555);
    for(int i=0; i<list.size(); i++){
system.out.println(list.get(i));
}
}


public static void main(string[] args) {
arraylist<person> list = new arraylist<person>();
    list.add(new person("小强"));
    list.add(new person("老王"));
    list.add(new person("小虎"));
    list.add(new person("小泽"));
    list.add(new person("小红"));
    for(int i=0; i<list.size(); i++){
        person p = list.get(i);
system.out.println(p);
}
}

3、集合的继承实现关系:

JAVA基础之集合、Iterator迭代器、泛型及增强for循环

其中list允许出现重复的元素,是有序的;而set是不允许的,无序的。

4、collection类:

其是集合中的顶层接口,创建方法如下:

collection<元素类型> 变量名 =new arraylist<元素类型>();
//只能存储指定的类型(最好采用这种方法)


collection 变量名 = new arraylist();
//默认类型为object,即任何类型的元素都可以存储

5、collection部分基本方法如下:(没有关于下标的方法)

import java.util.arraylist;
import java.util.collection;

public class demo02 {
    public static void main(string[] args) {
        collection<integer> col=new arraylist<integer>();
        col.add(10);
        col.add(20);
        //清空集合
//        col.clear();
        //判断集合中是否包含该元素;
        boolean flag=col.contains(20);
        system.out.println(flag);
        //根据值删除元素
        col.remove(10);
        //遍历
        if(col instanceof arraylist){
            arraylist<integer> arr=(arraylist<integer>)col;
            for(int i=0;i<arr.size();i++){
                system.out.println(arr.get(i));
            }
        }
        //集合转数组
        object[] obj=col.toarray();
        for(int i=0;i<obj.length;i++){
            system.out.println(obj[i]);
        }
    }
}

二、iterator迭代器:

1、概述:

  collection集合元素的通用获取方式:在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续在判断,如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

2、常用方法:

hasnext():   如果仍有元素可以迭代,则返回true;(返回一个boolean值)

next():返回迭代的下一个元素,并把指针向后移动下一位。

3、迭代方式的代码体现:

(iterable接口 (java.lang.iterable) 是java集合的*接口之一。collection接口继承iterable,所以collection的所有子类也实现了iterable接口。)

iterable的方法:

iterator():

     返回在此collection的元素上进行迭代的迭代器。

import java.util.arraylist;
import java.util.collection;
import java.util.iterator;

public class demo05 {
    public static void main(string[] args) {
        collection col=new arraylist();
        col.add("abc");
        col.add("add");
        col.add("edf");
        //获取迭代器对象
        iterator it=col.iterator();
        //判断是否有元素
        while(it.hasnext()){
            //获取每个元素
            object s=it.next();
            //判断是否是string类型
            if(s instanceof string){
                //向下转型
                string str=(string)s;
                //调用子类独有的方法
                system.out.println(str.length());
            }
        }
    }
}

(由于元素被存进集合后全部都被提升为object类型,所以需要向下转型)

三、泛型:

  泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

1、含有泛型的类:

定义格式:

  修饰符 class 类名<代表泛型的变量>{   }

使用格式:

  创建对象时,确定泛型的类型。

2、含有泛型的接口:

    修饰符 interface 接口名<代表泛型的变量>{   }

使用格式:

  定义时确定泛型的类型(实现接口的时候明确);

  或者:

  知道创建对象时,确定泛型的类型;

3、使用泛型的好处:

 

  将运行时期的classcastexception,转移到了编译时期变成了编译失败。避免了类型强转的麻烦。

import java.util.arraylist;
import java.util.collection;
import java.util.hashset;
import java.util.iterator;

public class demo01 {
    public static void main(string[] args) {
        arraylist<string> arr=new arraylist<string>();
        arr.add("a");
        arr.add("b");
        hashset<integer> set=new hashset<integer>();
        set.add(123);
        set.add(456);
        get(arr);
        get(set);
    }
    //写一个方法遍历两个集合
    public static void get(collection<?> col){
        //获取迭代器对象
        iterator<?> it=col.iterator();
        //判断是否存在
        while(it.hasnext()){
            system.out.println(it.next());
        }
    }
}

4、泛型通配符:

  为了解决这个"无法确定具体集合中的元素类型"问题,java中,为我们提供了泛型的通配符<?>。当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用object类中的共性方法,集合中元素自身方法无法使用。

5、泛型限定:

限定泛型的上限:

  格式:? extends e

? 代表接收e类型或者e的子类型的元素

 

限定泛型的下限:

格式:? super e

? 代表接收e类型或者e的父类型的元素

import java.util.arraylist;
import java.util.iterator;

public class demo02 {
    public static void main(string[] args) {
        arraylist<cooker> arr1=new arraylist<cooker>();
        arr1.add(new cooker());
        arr1.add(new cooker());
        arraylist<waiter> arr2=new arraylist<waiter>();
        arr2.add(new waiter());
        arr2.add(new waiter());
        get(arr1);
        get(arr2);
    }
    
    //写一个方法来遍历容器
    public static void get(arraylist<? extends emp> arr){
        iterator<? extends emp> it=arr.iterator();
        while(it.hasnext()){
            /*object obj=it.next();
            if(obj instanceof cooker){
                cooker c=(cooker)obj;
                c.work();
            }
            if(obj instanceof waiter){
                waiter c=(waiter)obj;
                c.work();
            }*/
            it.next().work();
        }
    }
}

四、增强for循环:

  增强for循环是jdk1.5以后出来的一个高级for循环,专门用来遍历数组和集合的。它的内部原理其实是个iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。(也没有下标的概念)

格式:

for(元素的数据类型 变量 : collection集合or数组){

}

import java.util.arraylist;
import java.util.collection;

public class demo06 {
    public static void main(string[] args) {
        /*for(你容器中存放的数据类型  变量名:你要遍历的容器的名字){
            system.out.println(变量名);
        }*/
        
        collection<string> col=new arraylist<string>();
        col.add("abc");
        col.add("bcd");
        col.add("edg");
        for(string s:col){
            system.out.println(s);
        }
    }
}

增强for循环和老式的for循环有什么区别?

注意:新for循环必须有被遍历的目标。目标只能是collection或者是数组。

建议:遍历数组时,如果仅为遍历,可以使用增强for如果要对数组的元素进行 操作,使用老式for循环可以通过角标操作。