java日常学习总结day02（Collection集合,Iterator迭代器,泛型）

一：Collection集合
集合：集合是java中提供的一种容器，可以用来存储多个数据
数组中存储的是同一类型的元素，可以寻出基本数据库类型值。集合存储的都是对象。而且对象的额类型可以不一致，在开发中一般当对象多的时候，使用集合进行存储
1，集合框架
2，Collection 常用的功能
Collection是所有蛋类及和的父接口，因此在Collction中定义了单列集合（Listhe Set通用的一些方法
public boolean add(E e):把给定的对象添加到当前集合中，
public void clear () 清空集合所有的元素
public bolean remove(E e)把给定的对象在当前集合中删除
public boolean isEmpty() 判断但其概念集合是否为空
public int size() 返回集合中的个数
public Object[] toArray():把集合中的元素，存储到数组中

public class Demo06Collection {
    public static void main(String[] args) {
        //创建集合对象,可以使用多态
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);//重写toString方法


        boolean b1 = coll.add("张三");
        System.out.println("b1" + b1);
        System.out.println(coll);

        coll.add("王五");
        coll.add("老李");
        coll.add("老王");
        coll.add("小张");
        System.out.println(coll);

        /*public boolean remove(E e):把给定的对象在当前集合中删除
        返回值是一个boolean值,集合中存在元素,返回ture
                              集合中不存在元素,返回false
        * */

        boolean b2 = coll.remove("小张");
        System.out.println("b2" + b2);
        boolean b3 = coll.remove("张亮");
        System.out.println("b3" + b3);
        System.out.println(coll);

        /*public boolean contains(E e):判断集合中是否包含给定的对象
        * 包含返回true   不包含返回false
        *
        * */
        boolean b4 = coll.contains("王五");
        System.out.println("b4" + b4);
        boolean b5 = coll.contains("张亮");
        System.out.println("b5" + b5);
        System.out.println(coll);


        /*public int size（）：返回集合中的个数*/
        int size = coll.size();
        System.out.println("size" + size);

        /*public Object[] toArrary() : 把集合中的元素，存储到数组中*/

        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

二：Iterator迭代器
1.Iterator接口
迭代：即Collection集合元素的通用获取方式，在取元素之前先要判断集合中有没有元素，如果有，九八这个元素取出来,继续在判断，如果还有酒再取出来，一直把集合中的所有元素全部取出来，这种取出方式专业术语为迭代
Iterator接口的常用方法如下：
public E next():返回迭代的下一个元素
public boolean hasNext():如果仍有元素可以迭代则返回true

//Itearator迭代器是一个接口，是一个接口，我们无法直接使用，需要使用Iterator'接口实现对象，获取实现类的方式比较特殊
    //Collection 接口中有一个方法，叫做iterator（），这个方法返回的就是迭代器的而实现类对象
    //Iterator<E> iterator() 返回在此collection的元素上进行迭代的迭代器


    //迭代器的使用步骤
    /*1，使用集中的方法iterator() 获取迭代器得到实现类对象，使用Iterator接口接收（多态）
    * 2，使用Iterator接口中的方法hasNext判断还有没有下一个元素
    * 3，使用Iterator接口中的方法取出元素中的下一个元素*/
public class Demo07Iterator{

    public static void main(String[] args) {
        //创建一个集合对象
        Collection<String> coll = new ArrayList<>();

        coll.add("张");
        coll.add("网");
        coll.add("小");
        coll.add("打");
        coll.add("就");
        /*使用集合的方法iterator()获取迭代器的实现对象,使用Iterator接口接收(多态)
        * 注意:Iterator<E> 接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型  迭代器就是什么泛型
        * */
        //1多态    接口        实现类对象
        Iterator<String> it = coll.iterator();
      /*  boolean b = it.hasNext();
        System.out.println(b);
        //2
        String s = it.next();
        System.out.println(s);
        //3
        b = it.hasNext();
        System.out.println(b);
        s =it.next();
        System.out.println(s);*/


        //优化  使用while循环 循环结束的田间  hasnext方法返回folse
        while (it.hasNext()){
            String e = it.next();
            System.out.println(e);
        }

    }
}

三:泛型(是一种未知的数据类型,不知道什么数据类型可以使用泛型)

public class Demo01Generic {

    public static void main(String[] args) {
     /*   show01();*/

        show02();

        /*创建集合 使用泛型的好处
        * 避免了类型转换麻烦,存储的是什么类型  取出的就是什么类型
        * 吧运行期异常,提升到了编译期
        * */
        
    }

    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s+"->"+s.length());
        }
    }


    /*不使用泛型好处":
    * 集合不使用泛型 m默认的类型就是Object类型,可以存储任意类型的数据
    * 弊端:
    * 不安全,会引发异常
    * */
   /* private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);

        //使用迭代器便利list集合
        //获取迭代器
        Iterator it =list.iterator();
        while (it.hasNext()){
            //取出元素也是Object类型
            Object obj = it.next();
            System.out.println(obj);


            //想要使用String类特有的方法,length获取字符串的长度,不能使用多台Object obj ="abc"
            //需要向下转型
            //会抛出calsscastexceotion类型转换异常
            String s = (String)obj;
            System.out.println(s.length());

        }

    }*/
}

1,泛型的定义和使用
定义格式:
修饰符 class 类名 <代表泛型的变量>{}

如不使用泛型:

ublic class GenericClass {

    private  String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
.................................
public class Demo02GenericClass {
    public static void main(String[] args) {
        GenericClass gc =new GenericClass();
        gc.setName("只能是字符串");
        String name = gc.getName();
        System.out.println(name);

    }
}

使用泛型

/*定义一个含有泛型的类,模拟ArrayList集合
* 泛型是一个位置的数据类型,当我们不确定什么数据类型的时候  可以使用泛型
* 泛型可以接收任意的数据类型,可以使用Integer,string,student
*创建的时候确定泛型的数据类型
* */
public class GenericClass<E> {

    private  E name;

    public E getName() {
        return name;
    }

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


public class Demo02GenericClass {
    public static void main(String[] args) {
        //不写泛型默认为Object类型
        GenericClass gc =new GenericClass();
        gc.setName("只能是字符串");
        Object obj = gc.getName();

        //创建GenericClass对象,泛型使用Integer类型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1);

        Integer name = gc2.getName();
        System.out.println(name);
        //创建GenericClass对象,泛型使用String类型

        GenericClass<String> gc3 = new GenericClass<>();
        gc3.setName("小明");

        String name1 = gc3.getName();
        System.out.println(name1);
    }
}

public class Demo02GenericClass {
    public static void main(String[] args) {
        //不写泛型默认为Object类型
        GenericClass gc =new GenericClass();
        gc.setName("只能是字符串");
        Object obj = gc.getName();

        //创建GenericClass对象,泛型使用Integer类型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1);

        Integer name = gc2.getName();
        System.out.println(name);
        //创建GenericClass对象,泛型使用String类型

        GenericClass<String> gc3 = new GenericClass<>();
        gc3.setName("小明");

        String name1 = gc3.getName();
        System.out.println(name1);
    }
}

定义泛型的方法

/* 定义含有泛型的方法:泛型定义在方法的修饰符合返回值类型之间
 *
 *格式
 * 修饰符  <泛型>  返回值类型  方法名(参数类表(使用泛型)){
 *    方法体
 * }
 * 含有泛型的方法,在调用方法的时候确定泛型的数据类型
 * 传递什么类型的参数,泛型就是什么类型
 */

public class GenericMethod {


    public <M> void method01(M m) {
        System.out.println(m);

    }
    public static <S> void method02(S s){
        System.out.println(s);
    }
}



....................
public class Demo03GenericMethod {
    public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();

        gm.method01(10);
        gm.method01("abc");
        gm.method01(8.8);


        gm.method02("静态方法不建议创建对象使用");

        //静态方法通过类名.方法名(参数)可以直接使用
        GenericMethod.method02("静态方法");
        GenericMethod.method02(1);
    }
}

含有泛型的接口

public interface GenericInterface<I> {

    public abstract void  method(I i);

}
.....................
//含有泛型的接口第一种使用方式：定义接口的实现方式，实现接口，指定接口的泛型
    //
public class GenericInterfaceImpl implements GenericInterface<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}
...................
//
//第二种使用的方式:接口使用什么泛型   实现类就使用什么泛型
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{

    @Override
    public void method(I i) {
        System.out.println(i);
    }
}
......................
public class Demo04GenericInterfaceImpl {

    //创建GenericInterfaceImpl对象
    public static void main(String[] args) {
        GenericInterface gi1 = new GenericInterfaceImpl();
        gi1.method("字符串");


        /* 创建GenericInterfaceImpl2对象 */
        GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
        gi2.method(10);


    }


}

泛型的通配符
:?

public class Generic {
    /*通配符:?
    * 代表任意的数据类型
    * 使用方式:
    * 不能作为方法的参数使用
    * */
    public static void main(String[] args) {

        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("c");
        printArray(list01);
        printArray(list02);

    }
        //定义一个方法能便利所有类型 的ArrayLiat集合

        public static void printArray(ArrayList<?> list){
            //使用迭代器遍历
            Iterator<?> it = list.iterator();
            while (it.hasNext()){
                //it.next()方法取出的元素是Object,可以接收任意的数据类型
             Object o =it.next();
                System.out.println(o);
            }
        }

}