Java初学笔记APIday03--Iterator迭代器遍历集合、增强for循环、泛型介绍

目录

一、集合的遍历及新循环

1.集合的遍历

 2.新循环/增强for循环

 二、集合中的泛型

1.泛型：

2.集合的互转：

集合转为数组

数组转为集合：

---

一、集合的遍历及新循环

1.集合的遍历

• Collection接口提供了统一的遍历集合的方式：迭代器模式。通过iterator()方法可以获取一个用于遍历当前集合元素的迭代器(Iterator接口)

• java.util.lterator接口：定义了迭代器遍历集合的相关操作，不同的集合都实现了用于遍历自身元素的迭代器实现类。从多态的角度把他们看成lterator即可。

• 迭代器遍历遵循的步骤为：问（hasNext()）、取（next()）、删（remove()），但删除并不是必要操作。

  迭代器的常用方法：

  1)boolean hasNext()----------问(必要操作)

         询问集合是否还有"下一个"元素可供迭代

         注意：迭代器默认开始位置在集合第1个元素之前无论调用了多少次的hasNext()，迭代器的位置都不会改变

  2)Object next()--------------取(必要操作)

        迭代器向后移动一个位置来指向集合的下一个元素并将其获取

  3)void remove()--------------删(删除并非必要操作)

        删除next()方法所获取的元素

public class IteratorDemo {
         public static void main(String[] args) {
             Collection c = new ArrayList();
             c.add("one");
             c.add("#");
             c.add("two");
             c.add("#");
             c.add("three");
             c.add("#");
             c.add("four");
             c.add("#");
             c.add("five");
             System.out.println(c); //[one, #, two, #, three, #, four, #, five]
     
            
             Iterator it = c.iterator(); //获取集合c的迭代器
             while(it.hasNext()){ //若有下一个元素
                 String str = (String)it.next(); //获取下一个元素并强转为String类型
                 System.out.println(str);
                 if("#".equals(str)){
                     //c.remove(str); //迭代器遍历过程中不允许通过集合的方式来增删元素，否则会报异常
                     it.remove(); //删除next()方法所获取的元素
                 }
             }
             System.out.println(c);
         }
     }

 2.新循环/增强for循环

• jdk1.5时推出了一个特性：增强型for循环，也称为新循环，让我们使用相同的语法遍历集合和数组。

• 它的内部是通过Iterator实现的，所以不能动态的增删元素

• 语法：

  for(元素类型 变量名 : 集合或数组){
      循环体
  }

public class NewForDemo {
         public static void main(String[] args) {
             String[] array = {"one","two","three","four","five"};
             for(int i=0;i<array.length;i++){
                 System.out.println(array[i]);
             }
             for(String str : array){ //str表示的就是数组中的每个元素
                 System.out.println(str);
             }
     
             Collection c = new ArrayList();
             c.add("one");
             c.add("two");
             c.add("three");
             c.add("four");
             c.add("five");
             Iterator it = c.iterator();
             while(it.hasNext()){
                 String str = (String)it.next();
                 System.out.println(str);
             }
             for(Object obj : c){ //obj代表集合中的每个元素
                 String str = (String)obj;
                 System.out.println(str);
             }
     
         }
     }

 二、集合中的泛型

1.泛型：

• JDK1.5时推出了一个特性：泛型

• 泛型也称为参数化类型，允许我们在使用一个类时，传入某个类型来规定其内部的属性、方法参数或返回值类型，使得我们使用时更加方便。

• 泛型在集合中北广泛使用 用来指定集合中元素的类型

  1）若不指定泛型的具体类型，则默认为Object

  2）若指定了泛型的具体类型，则在获取泛型的值时，编译器会自动补充强转操作

public class GenericDemo {
         public static void main(String[] args) {
             Collection<Point> c = new ArrayList<>();
             c.add(new Point(1,2));
             c.add(new Point(3,4));
             c.add(new Point(5,6));
             c.add(new Point(7,8));
     
             Iterator<Point> it = c.iterator();
             while(it.hasNext()){
                 Point p = it.next();
                 System.out.println(p);
             }
     
             for(Point p : c){
                 System.out.println(p);
             }
     
             /*
             Collection<String> c = new ArrayList<>(); //泛型集合
             c.add("one");
             c.add("two");
             c.add("three");
             c.add("four");
             c.add("five");
             //c.add(123); //编译错误，123的类型违背了集合c所指向的泛型的实际类型String
     
             //迭代器所指定的泛型应当与其遍历的集合的泛型一致
             Iterator<String> it = c.iterator();
             while(it.hasNext()){
                 String str = it.next();
                 System.out.println(str);
             }
     
             for(String str : c){
                 System.out.println(str);
             }
              */
         }
     }

2.集合的互转：

集合转为数组

package collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/**
 * 集合转为数组
 */
public class CollectionToArray {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        System.out.println(c); //[one, two, three, four, five]

        //若参数数组元素个数==集合元素个数，那就正常转换
        //若参数数组元素个数<集合元素个数，那也正常转换(按照集合大小给数组)
        //若参数数组元素个数>集合元素个数，那也正常转换(在末尾补默认值)
        String[] array = c.toArray(new String[5]);
        System.out.println(Arrays.toString(array)); //[one, two, three, four, five]
    }
}

数组转为集合：

public class ArrayToList {
         public static void main(String[] args) {
             String[] array = {"one", "two", "three", "four", "five"};
             System.out.println("array:"+ Arrays.toString(array)); //[one, two, three, four, five]
     
             //asList()方法会返回内部的ArrayList，内部直接引用给定数组array
             List<String> list = Arrays.asList(array);
             System.out.println("list:"+list); //[one, two, three, four, five]
     
             //对数组操作后，集合也会相应的改变
             array[1] = "six";
             System.out.println("array:"+ Arrays.toString(array));
             System.out.println("list:"+list);
     
             //对集合操作后，数组也会做相应的改变
             list.set(2,"seven"); //将集合的第3个元素修改为seven
             System.out.println("array:"+ Arrays.toString(array));
             System.out.println("list:"+list);
     
             //给集合添加/删除元素相当于给数组添加/删除元素
             //而数组是定长的，不会自动扩容/缩容，因此发生不支持操作异常
             list.add("!!!!"); //运行时会发生不支持操作异常
         }
     }

---

新学java能力有限，如有错误欢迎指正哟