Collection接口和迭代器

Collection接口:

定义的是所有单列集合中共性的方法
所有的单列集合都可以使用这些共性的方法
没有带索引的方法(不能用for循环遍历)

List接口:
1.有序的集合(存储和取出元素的顺序是相同的)
2.允许存储重复的元素
3.有索引，可以用普通的for循环进行遍历

Set接口:
1.不允许存储重复的元素
2.没有索引，不能使用普通的for循环
参考文档

学习集合的目标:
1.会使用集合存储数据
2.会遍历结合，把数据取出来
3.掌握每种集合的特性

/Collection常用方法
public class CollTest01 {
    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();
        //使用方法，add
       coll.add("迪丽热巴");
        coll.add("古力拉扎");
        coll.add("马尔扎哈");
        coll.add("赵丽颖");
        System.out.println(coll);
        System.out.println(coll.contains("赵丽颖"));
        System.out.println(coll.size());
        //toArray输出后foreach循环
        for (Object o : coll) {
            System.out.print(o+" ");
        }
        System.out.println("++++++++");
        //创建迭代器
        /*1.使用集合中的方法: Iterator<E> iterator(), 获取迭代器的对象
        注意:迭代器接口的泛型类型Iollection接口的泛型类型要保持- -致
        */
        Iterator<String> it = coll.iterator();
        /*2. boolean hasNext( )
        E next()返回迭代中的下一一个元素。
        启始是-1
        */
        while (it.hasNext()){
            String next = it.next();
            System.out.println(next);
        }
        coll.clear();
        System.out.println();
        System.out.println(coll.isEmpty());
    }
}

使用泛型与不使用泛型的区别

使用泛型:
弊端: .泛型是什么类型，只能存储什么类型
好处:1)把运行时期的异常，提升到J编译时期(写代码的时候就会保存， 可以及时修改)
好处2）：元素类型统一，避免了元素类型转换的麻烦

不使用泛型:
弊端:不安全，会发生异常
好处:集合不使用泛型，默认存储类型是object类型，就可以存储任意数据类型

iterator迭代器的使用

public class CollTest02 {
    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();
        //使用方法，add
       coll.add("迪丽热巴");
        coll.add("古力拉扎");
        coll.add("马尔扎哈");
        coll.add("赵丽颖");
//        System.out.println(coll);
        Iterator<String> it = coll.iterator();
        while (it.hasNext()){
            String next = it.next();
            System.out.println(next);
        }
       /* while (coll.iterator().hasNext()){
            System.out.println( coll.iterator().next());
        }*/
    }
}

增强for循环

//增强for循环的使用方法
public class CollTest02 {
    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();
        //使用方法，一般用于数组和集合
       coll.add("迪丽热巴");
        coll.add("古力拉扎");
        coll.add("马尔扎哈");
        coll.add("赵丽颖");
        for (String s : coll) {
            System.out.println(s);
        }
    }
}

定义和使用含有泛型的类

package demo02;
/*/*
自定义泛型类: ( 模拟ArrayList<E>)
public cLass ArrayList<E>{
public booLean add(E e) {}
}
泛型是一- 个未知的数据类型，当我们不知道用什么数据类型的时候，可以使用泛型
泛型可以接收任意数据类型，Integer, string , Student....
自定义的泛型类，在创建对象的时候确定泛型类型即可
*/
public class GeTest01<E> {
    E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}
public class GeTest02 {
    public static void main(String[] args) {
        GeTest01<String> g= new GeTest01<>();
        g.setName("张三");
        System.out.println(g.getName());
    }

}

自定义泛型方法

自定义泛型方法:泛型要定义在修饰符和返回值类型之间
格式:
修饰符<代表泛型的变量>返回值类型方法名(参数列表(使用泛型) ){ }
z注:含有泛型的方法，是在方法被调用的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型

public class GenericMethod {
    public <M> void method(M m){
        System.out.println(m);
    }
}
public class Test {
    public static void main(String[] args) {
        GenericMethod g = new GenericMethod();
        g.method(1);
        g.method("什么鬼");
        g.method(1.3);
    }
}

自定义泛型接口

含有泛型接口，第一-种使用方式:
定义接口实现类，实现接口，直接指定接口的泛型
public interface Iterator {
}
public final class Scanner implements Iterator{
public String next() {}
}

含有泛型接口，第二种使用方式:
接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
public interface List {
boolean add(E e);
public E get(int index) {}
public class ArrayList implements List{
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increme
eLementData[size++] = e;
return true;
}
public E get(int index) {
rangeCheck(index);
return elementData( index);
}
}

泛型的通配符: .

? :表示任意的数据类型
使用方式:
不能创建对象使用
只能作为方法的参数使用

定义一一个方法能遍历所有类型的ArrayList集合
此时我们不知道ArrayList集合泛型中放的是什么数据类型,
我们就可以用泛型通配符?来接收这个数据类型

package demo03;

import java.util.ArrayList;
import java.util.Iterator;

public class FanTest01 {
    public static void main(String[] args) {
        ArrayList<String> str1=new ArrayList<>();
        str1.add("金");
        str1.add("木");
        str1.add("水");
        str1.add("火");
        str1.add("土");
        ArrayList<Integer> str2=new ArrayList<>();
        str2.add(1);
        str2.add(2);
        str2.add(3);
        printArray(str1);
        printArray(str2);
    }
    public static void printArray(ArrayList<?> list){
        Iterator<?> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}