Java总结05 Java集合体系.最高集合接口Collection和其迭代器/一般集合接口List和其迭代器/增强版For循环的应用

Collection - 集合 Iterator - 迭代器 Revise — 修改(rɪˈvaɪz)

**

1. 一/Collection集合的创建与应用

Collection本身是个接口,那么如果要把它以集合形式去应用,那么就需要用到多态.而子类则必须是个集合实现类,比如ArrayList.
格式:Collection<E泛型> 多态集合对象自定义名 = new ArrayList<E>();
如:Collection<String> collectionListObj = new ArrayList<String>();

常用方法:
1/对象名.add(); 添加元素
2/对象名.remove(); 删除指定元素,因为没有索引值,所以如果存在多个相同元素,则删除最靠前的.
3/对象名.isEmpty(); 判断集合中的元素是否全部为空内容元素,如果是则True,不是则False
4/对象名.contains(); 判断指定元素是否存在集合中
5/对象名.clear(); 清空所有元素(即将所有元素内容清空)
6/对象名.size(); 取集合长度

public static void main(String[] args) {

        Collection<String> collectionListObj = new ArrayList<String>();

        //元素添加,注意要用重写了接口的'add'方法,而不是ArrayList独有的'add'方法.
        collectionListObj.add("世界大同");
        collectionListObj.add("华夏归真"); //最靠前
        collectionListObj.add("炎黄子孙");
        collectionListObj.add("华夏归真");
        collectionListObj.add("华夏归真");
        System.out.println(collectionListObj);//此处说明ArrayList自身或者它所继承直接/间接父类重写了Object的'toString'方法.

        //从集合中删除元素,如果有同该元素相同的,则删除最靠前的元素.
        collectionListObj.remove("华夏归真");
        System.out.println(collectionListObj);
        System.out.println("========================");
        //判断集合中是否存在指定元素
        System.out.println(collectionListObj.contains("世界大同") );//存在则返回True,不存在返回False
        System.out.println("========================");

        //判断集合中的元素是否为空
        System.out.println(collectionListObj.isEmpty()); //是则True,不是则False
        System.out.println("========================");

        //取集合元素长度
        System.out.println(collectionListObj.size());
        System.out.println("========================");

        //清空集合中的所有元素
        collectionListObj.clear();
        System.out.println(collectionListObj);
        System.out.println("========================");
}

2. 二/Collection迭代器 Iterator 的应用:

 格式:`terator<E泛型> Iterator迭代器对象名 = 多态集合对象自定义名.iterator();`
 如: `Iterator<String> it = collectionListObj.iterator();`
     此处左侧'Iterator'的泛型,必须同多态集合对象的泛型一致.

2.2. 应用1/历遍元素内容:

1/调用元素内容格式:Iterator迭代器对象名.next()
    规则:尽管多态集合没有索引值,但也会依照{隐性的}元素索引值从0到末尾.但正因为没有索引值,所以每调用一次,都会依照顺序从0到末尾调用.
         所以假如这里头有4个元素,那么就需要对这个方法调用4次.
         如果调用次数超过了元素数量,那么就会报错
  2/判断是否调用次数超过了元素数量之格式:Iterator迭代器对象名.haxNext()

public static void main(String[] args) {
Collection<String> collectionListObj = new ArrayList<String>();

        collectionListObj.add("世界大同");
        collectionListObj.add("华夏归真");
        collectionListObj.add("炎黄子孙");
        collectionListObj.add("华夏归真");
        collectionListObj.add("华夏归真");

        //通过collectionList的多态对象的发给发'iterator()'来创建迭代器'Iterator'.
        Iterator<String> it = collectionListObj.iterator();

        System.out.println(it.next());//世界大同
        System.out.println("========================");
        while (it.hasNext()){ //判断是否历遍到了末尾.
            String stringParam = it.next();  //必须保证循环历遍体内,其元素调用方法只能是一个.
            //  华夏归真
            //     炎黄子孙
            //      华夏归真
            //      华夏归真
            System.out.println(stringParam);
        }

        System.out.println("========================");
        }

注意:1/如果想要用while等循环以历遍的形式完成某些操作的话,必须要保证在循环体内,历遍方法(如next())只能被使用一次,否则将会造成调用顺序出错.
因此强烈建议以 '类型 变量名 = it.next()'的形式进行左侧赋值调用,以此来保证循环体对其历遍方法只调用一次.
2/在历遍循环体内,不允许改变数组长度(如add方法的增加元素,和remove的删除元素),否则报错.
3/在同一个方法下,那么其历遍顺序不会被初始化,也就是说,
如果在同一个方法内的循环体外用next调用了一次元素内容,那么在同一个方法的遍历循环体内又一次调用元素内容时,则直接从上一次的隐性索引值开始调用.
4/因为在JDK5之后有了增强版For循环,如果仅仅只是想要用历遍功能,那完全可以替代本迭代器.

3. 三/List的讲解与应用:

格式:List<泛型> List集合自定义多态对象名 = new ArrayList<>();
列如:List<String> listStringObj = new ArrayList<>();
意义:List的方法用法同Arraylist差不多,但List是一个接口,并且继承了集合父类的’Collection’接口,
因此需要以多态形式创建,子类大多为实现了它的实现类,比如ArrayList.

public class newList {
    public static void main(String[] args) {
//===============================================默认迭代器的应用=========================================
        List<Student> ListStudentObj = new ArrayList<>();

        Student studentObj = new Student("赵丽颖-", 23);
        Student studentObjTwo = new Student("张天爱-2", 25);
        Student studentObjThree = new Student("迪丽热巴-3", 22);


        ListStudentObj.add(studentObj);
        ListStudentObj.add(studentObjTwo);
        ListStudentObj.add(studentObjThree);
 }
 //创建内部学生类,并重写toString.

class Student {
    private String name;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    private int age;


}

4. 四/List迭代器 Listiterator 的应用

创建:以多态形式创建,其中的泛型要与List集合对象的多态泛型要一致.

 格式:ListIterator<泛型> 自定义List迭代器对象名 = List集合自定义多态对象名.listIterator();

 列如:ListIterator<String> listIteratorObj = listStringObj.listIterator();

意义:与Collection的迭代器不同, List的迭代器’ListIterator’可以在遍历的集合的过程中去通过’add’或’remove’方法来改变集合的长度,并且不会报错.
但是这个’add’或’remove’方法必须通过List的迭代器’ListIterator’来调用.

4.1. 应用1/正向遍历集合内容,并中改变集合长度

方法:listIteratorObj.hasNext() listIteratorObj.next()

 格式: 

while(自定义List迭代器对象名.hasNext()) {
            自定义List迭代器对象名.add/remove(元素);
            System.out.println(自定义List迭代器对象名.next());
        }

 列如:   

while (listIteratorObj.hasNext()) {
            if (num == 2) {
                listIteratorObj.add("中国人");
                num = 0;
            }
            System.out.println(listIteratorObj.next());
        }
        

public class newList {
    public static void main(String[] args) {
 List<String> listStringObj = new ArrayList<>();
        listStringObj.add("你好");
        listStringObj.add("世界!");
        listStringObj.add("团结");
        listStringObj.add("博爱");
        ListIterator<String> listIteratorObj = listStringObj.listIterator();
         //遍历元素内容
        //正向遍历对象内容
        //与Collection的迭代器不同,    List的迭代器'ListIterator'可以在遍历的集合的过程中去通过'add'或'remove'方法来改变集合的长度,并且不会报错.
        //但是这个'add'或'remove'方法必须通过List的迭代器'ListIterator'来调用.
        int num = 2;
        while (listIteratorObj.hasNext()) {
            if (num == 2) {
                listIteratorObj.add("中国人");  //中途可以改变长度
                num = 0;
            }
            System.out.println(listIteratorObj.next());
        }
      }
   }   
        class Student {
    private String name;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    private int age;


}

4.2. 应用2/逆向历遍集合内容(也可以中途改变集合长度)

注意:无论是在Collection集合的迭代器,还是在List集合的迭代器中,初始的迭代指针都是默认指向第一个隐性索引值.
也因为不存在显性索引值,直接从从最后一个元素开始逆行遍历.所以在这种情况下**,需要先通过正向遍历,使其指向最后一个索引值,进而才能逆向遍历.**
格式:

while(自定义List迭代器对象名.hasPrevious()){
             System.out.println(自定义List迭代器对象名.previous())
           }
           

列如:

while (listIteratorObj.hasPrevious()) {
        System.out.println(listIteratorObj.previous());
    }

public class newList {
    public static void main(String[] args) {
 List<String> listStringObj = new ArrayList<>();
        listStringObj.add("你好");
        listStringObj.add("世界!");
        listStringObj.add("团结");
        listStringObj.add("博爱");
        ListIterator<String> listIteratorObj = listStringObj.listIterator();
     
       
        //正向遍历对象内容
        int num = 2;
        while (listIteratorObj.hasNext()) {
            if (num == 2) {
                listIteratorObj.add("中国人");  //中途可以改变长度
                num = 0;
            }
            System.out.println(listIteratorObj.next());
        }
     //[逆向历遍

        while (listIteratorObj.hasPrevious()) {
            System.out.println(listIteratorObj.previous());
        }
      }
   }   
        class Student {
    private String name;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    private int age;


}

注意2:因为在JDK5之后有了增强版For循环,如果仅仅只是想要用历遍功能,那完全可以替代本迭代器.

5. 五/增强For{多用}

增强for循环.
它的本质其实还是一个Collection的iterator迭代器(并非是list的iterator的迭代器),这意味这并不能在遍历时改变长度,
只是因为声明定义一个iterator的过程较为繁琐,因此在jdk5之后,出现了一个"增强For"来优化过程繁琐的问题.
它在日后的开发过程中使用频率极高. 同时正因为它的内核是一个iterator迭代器,所以它可以对任何数据或集合进行循环.
使用快捷键:iter+回车

格式:

 for (数组类型/集合泛型 进步表达式变量 : 要被循环的数据/集合){

        //循环体

   }

注意:因为在JDK5之后有了增强版For循环,如果仅仅只是想要用历遍功能,那完全可以只用这个即可.

public class newList {
    public static void main(String[] args) {
   ArrayList<String> stringArrayList = new ArrayList<>();
        stringArrayList.add("中华");
        stringArrayList.add("炎黄");
        stringArrayList.add("春秋");
        stringArrayList.add("复兴");
        //遍历String集合
        for (String s : stringArrayList) {
            System.out.println(s);
        }
        System.out.println("======================");
        //遍历String数组
        String[] stringArray = {"爱国", "敬业", "*", "奋斗"};
        for (String s : stringArray) {
            System.out.println(s);
        }
        System.out.println("======================");
        //遍历int数组
        int[] intArray = {12, 214, 4323, 121, 213};
        for (int i : intArray) {
            System.out.println(i);
        }
        System.out.println("======================");
        }
  }      

6. 三种遍历的应用

public class newList {
    public static void main(String[] args) {
     String[] ergodic = {"あ", "い", "う", "え", "お"};

        //索引值遍历
        for (int i = 0; i < ergodic.length; i++) {
            System.out.println(ergodic[i]);
        }
        System.out.println("======================");

        //迭代器遍历 ListIterator或Iterator
        List<String> listStringergodic = new ArrayList<>();
        listStringergodic.add("あ");
        listStringergodic.add("い");
        listStringergodic.add("う");
        listStringergodic.add("え");
        listStringergodic.add("お");
        ListIterator<String> listIteratorErgodic = listStringergodic.listIterator();

        while (listIteratorErgodic.hasNext()) {
            System.out.println(listIteratorErgodic.next());
        }
        System.out.println("======================");

        //增强版For遍历{多用}
        for (String s : ergodic) {
            System.out.println(s);
        }
        System.out.println("======================");
        }
   }     

7. List集合的两大分支ArrayList和LinkedList(了解下就行)