木舟0基础学习Java的第十四天(集合(转数组，转集合)，泛型，可变参数)

泛型（约束<数据类型，对象，E，T，K，V，N，?>）

//<不要放Object>

 public static void main(String[] args) {
        //
        ArrayList<String> l=new ArrayList();
        l.add("a");
        l.add("abc");
        //l.add(1); 报错
        l.add("你好");
        //l.add(25.4);报错
        Iterator i=l.iterator();
        while(i.hasNext()){
            Object next = i.next();
            System.out.println(next);
        }
    }

<E,T,K,V,N,?>

E:element 容器的元素

T:type 普通的java类

K:ker 键

V:value 值

N:number 数值类型

?:不确定的java类

泛型类:

方法的泛型最好与类的泛型一致 如果不一致需要在方法上声明该泛型(public<Q>)

静态方法必须声明自己的泛型(static<Q>)

非静态方法是在类加载时初始化赋值  静态方法是在调用时初始化赋值

public class Tool_02<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
    public void show(T t){
        System.out.println(t);
    }
}

   public static void main(String[] args) {
        Tool_02<String> t=new Tool_02();
        t.show("木舟");
    }

通配符？(Generic)：可以传入的具体类型不确定时用它

public class Generic<T>{
    public T getMsg() {
        return msg;
    }

    public void setMsg(T msg) {
        this.msg = msg;
    }

    //Generic<?> g
    private T msg;


}

public class ShowMsg {
    //不确定括号中放什么
    public void show(Generic<?> generic){//可以传入的具体类型不确定
        System.out.println(generic.getMsg());
    }
}

public class Demo_Generic {
    public static void main(String[] args) {
        Generic<String> g=new Generic<>();
        g.setMsg("懵");
        ShowMsg s=new ShowMsg();
        s.show(g);
    }
}

泛型总结：

基本类型不能用于泛型//Test<Integer> t

不能通过类型参数创建对象//T elm=new T() 运行时参数T会被替换成Object 无法创建T类型对象

可变参数：其实就是数组

public class Demo01 {
    public static void main(String[] args) {
       // int[] arr={11,22,33,44,55};
        print(11,22,33,44,55,66,77,88);

    }
  /*  public static void print(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);//11 22 33 44 55
        }
    }*/
 /* public static void print(int... arr){
      for(int i=0;i<arr.length;i++){
          System.out.println(arr[i]);//11 22 33 44 55
      }
  }*/
    public static void print(int x,int... arr){//int x不可以放在后面
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);//22 33 44 55 66 77 88
        }
    }
}

开发中数组转集合

 public static void main(String[] args) {
      /*  int[] arr={11,22,33,44,55};
        List l=new ArrayList();
        l.add(arr);
        System.out.println(l);//[[I@1b6d3586] 二维数组地址值 数组中存储的是基本数据类型
        集合只能存引用数据类型 所以它将arr当作一个对象存储的 出来的是地址值*/

       /* List<Integer> l= Arrays.asList(1,2,3,4,5,6);
        for(int i=0;i<l.size();i++){
           // l.add(7);
           // l.remove(3);//方法转成集合是一个集体 不能往里面添加或删除新元素
            System.out.println(l.get(i));//123456
        }*/
        //-----------------------------------------------------------------------------------------
        //开发中将数组转为集合
        int[] arr={3,4,5,6,7,8};
        ArrayList<Integer> list=new ArrayList();
        for (int i: arr) {
            list.add(i);
        }
        System.out.println("list中的值"+list);
        list.add(10);
        System.out.println("添加后的值"+list);
        list.remove(4);
        System.out.println("删除后的值"+list);
    }

Collection集合转数组

public static void main(String[] args) {
        //Collection集合转数组
        ArrayList<String> list=new ArrayList();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        String[] s=list.toArray(new String[10]);
        for (String ss:s ) {
            //以null补全 如果超过了默认是10个长度
            System.out.print(ss);//张三李四王五nullnullnullnullnullnullnull
        }
        System.out.println(s.length);
    }//集合转成的数组可以当作普通数组操作

注意：it.next() 只能调用一次 调用多次指针会向后多次移动

约束后不用强转 存取数据类型没有发生自动提升为Object