菜鸡学习day13_01_Collecttion接口（List+Set）&Collection接口&Iterator接口&增强for&泛型

菜鸡学习day13_01

package day13;

import java.util.*;

/*
集合框架
1.使用集合存储数据
2.遍历集合
3.掌握每种集合特性
Collecttion接口（List接口/Set接口）
定义的是所有单列集合中共性的方法
没有带索引的方法

1.List接口（Vector/ArrayList/LinkedList）
有序的集合（存取顺序相同）
允许元素重复
有索引，可for遍历

2.Set接口（TreeSet/HashSet/LinkedHashSet）
T和H无序，L有序
不允许元素重复
无索引，不能使用for

Collection
所有单列集合的最顶层的接口，定义里所有单列集合共性的方法
层次结构中的根接口
共性方法
1.boolean add(E e)   添加元素，add一般都返回true，返回值可省略
2.boolean remove(E e) 删除元素，e存在就返回true
3.boolean coll.contains(E e) 查找元素，e存在就返回true
4.boolean isEmpty() 判断是否为空，返回true
5.int size() 返回元素个数
6.Object[] toArray() 将元素存放到数组中
7.void clear() 清空

Iterator接口（迭代器）
用于迭代访问（遍历）集合中的所有元素
是一个接口，无法直接使用，需要使用其实现类对象，获取实现类的方式较特殊
Collection接口中有一个方法iterator（），他返回的就是Iterator接口的实现类对象
Iterator<E> iterator()
迭代：Collection集合元素的通用获取方式。先判断集合中有没有元素
      若有则把元素取出，继续判断，直到集合为空
常用方法
bollean hasNext（）若仍有元素可迭代，返回true
E next（） 返回迭代的下一个元素

迭代器的使用步骤
1.使用iterator()获取实现类对象，使用Iterator接口接收，指针在-1位置
2.使用hasNext（）判断有没有下一个元素
3.使用next（） 取出下一个元素

迭代实现原理（指针）

增强for循环
底层是用的也是迭代器，简化了迭代器的书写
所有单列集合都可以使用增强for
必须有遍历的目标（集合/数组），只用作遍历
foreach？？
格式     for(数据类型 变量名 : 集合（数组）名){//增强for循环
            System.out.println(变量名);
        }

泛型
是一种未知的数据类型，也可当作时一个变量，来接受接收数据类型
E e;Element 元素
T t；Type 类型
如ArrayList<String> list = new ArayList<>()创建集合对象时
就是把数据类型作为参数传递给泛型

使用泛型的优点
1.避免类型转换的麻烦
2.把运行期异常提升到编译期异常
缺点：泛型是什么类型，就只能存储什么类型的数据
注：如果不使用泛型 ArrayList list = new ArrayList（）；默认Object类型
？？

泛型的定义和使用
1.定义含有泛型的类
public class 类名称<E> {}
类名称<E> fan1 = new 类名称<>();

2.定义含有泛型的方法
有两种

泛型通配符<?>
？代表任意的数据类型
使用方法：不能创建对象使用，只能作为方法的参数使用

通配符高级使用





 */
public class D1301 {
    public static void main(String[] args) {
        collection01();//Collection的7种共性方法
        iterator01();//使用迭代
        fanxing01();//泛型的定义和使用

        FanxingMethod fan = new FanxingMethod();
        fan.fanxingmethod01("aaa");
        //fan.fanxingmethod02("bbb");//静态方法，不建议创建对象使用
        FanxingMethod.fanxingmethod02("bbb");//可以这样直接使用

        Shiyong01 m1 = new Shiyong01();
        m1.method("第一种使用方法。");
        Shiyong02<Integer> in = new Shiyong02<>();
        in.method(100);

        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");list.add("bbb");
        tongpeifu(list);//泛型通配符作为参数
    }

    private static void collection01(){//Collection的7种共性方法
        Collection<String> coll = new ArrayList<>();//多态
        System.out.println(coll);//【】，返回内容，重写了toString
        //添加元素
        boolean b1 = coll.add("aa");//+aa
        System.out.println(b1);//add一般都返回true，可省略
        coll.add("bb");
        coll.add("cc");
        coll.add("dd");
        System.out.println(coll);//[aa, bb, cc, dd]
        //删除元素
        boolean b2 = coll.remove("aa");//-aa，存在，返回true
        boolean b3 = coll.remove("ee");//-ee，false
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(coll);//[bb, cc, dd]
        //查找元素
        boolean b4 = coll.contains("aa");//aa不存在，false
        System.out.println(b4);
        //判断是否为空
        boolean b5 = coll.isEmpty();
        System.out.println(b5);//false
        //返回元素个数
        int size = coll.size();
        System.out.println(size);
        //将元素存放到数组中
        Object[] array = coll.toArray();
        System.out.println(Arrays.toString(array));
        //清空
        coll.clear();
        System.out.println(coll);//[]
    }

    private static void iterator01(){//使用迭代
        Collection<String> coll = new ArrayList<>();
        coll.add("a");
        coll.add("b");
        coll.add("c");
        coll.add("d");
        Iterator<String> iter = coll.iterator();//获取实现类对象，使用Iterator接口接收
        while(iter.hasNext()){//迭代
            System.out.println(iter.next());
        }
        for(String str : coll){//增强for循环
            System.out.println(str);
        }
    }

    private static void fanxing01(){//泛型的定义和使用
        Fanxing<String> fan1 = new Fanxing<>();//String
        fan1.setName("小明");
        System.out.println(fan1.getName());
        Fanxing<Integer> fan2 = new Fanxing<>();//Integer
        fan2.setName(123);
        System.out.println(fan2.getName());
    }

    private static void tongpeifu(ArrayList<?> list){
        Iterator<?> iter = list.iterator();
        while(iter.hasNext()){
            System.out.println(iter.next());//取出的元素类型是Object
        }
    }

}

package day13;

public class Fanxing<E> {
    private E name;

    public Fanxing() {
    }

    public Fanxing(E name) {
        this.name = name;
    }

    public E getName() {
        return name;
    }

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


}

package day13;

public class FanxingMethod {
    public <F> void fanxingmethod01(F f){
        System.out.println(f);
    }

    public static <F> void fanxingmethod02(F f){//静态方法
        System.out.println(f);
    }
}

package day13;
/*
含有泛型的接口
第一种使用方式（定义接口的实现类，实现接口，指定接口的泛型）
如定义String
 */
public class Shiyong01 implements Jiekou <String> {

    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

package day13;
/*
第二种使用方法（接口使用什么泛型，实现类就用什么）
相当于定义了一个含有泛型的类，创建对象时才确定泛型
 */
public class Shiyong02<E> implements Jiekou<E>{

    @Override
    public void method(E e) {
        System.out.println(e);
        System.out.println("第二种使用方法。");
    }
}