柘明Java笔记17

Collections

Collections是集合类的工具类，与数组的工具类Arrays类似

public class Collections1 {
    public static void main(String[] args) {        
        /*ArrayList<String> list = new ArrayList<>();
                            list.add("a");
           Collections.addAll(list, "a","b","c","d");
              System.out.println(list);*/                 
        ArrayList<Integer> list = new ArrayList<>();
                  list.add(5);
                  list.add(2);
                  list.add(3);
                  list.add(4);
                  list.add(1);
                  Collections.swap(list, 0, 2);//交换指定位置的元素
                  //Collections.sort(list);
                  //System.out.println(Collections.binarySearch(list,4));                 
            ArrayList<Integer> dlist = new ArrayList<>();
                      dlist.add(0);
                      dlist.add(0);
                      dlist.add(0);
                      dlist.add(0);
                      dlist.add(0);
                      dlist.add(0);
              Collections.copy(dlist, list);          
              //Collections.fill(list,1);         
              System.out.println(Collections.max(list));
               Collections.shuffle(list);         
             System.out.println(list);    
             System.out.println(dlist);          
         // List<Integer> list1 = Collections.emptyList();//返回的是一个内部类EmptyList,此集合不能操作使用,用于逻辑判断
  //test(10, 5,6,3,3,2);
    }
/*  int...a 可变长度的参数  本质是数组
               一个参数列表中,只能允许有一个可变长度参数
              如果有,必须放在参数列表的末尾      */
    public static void test(int b,int...a){
        System.out.println(b);
        System.out.println(Arrays.toString(a)); }}

泛型

早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。 泛型，即“参数化类型”。定义方法时有形参，然后调用此方法时传递实参。参数化类型，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式，然后在使用/调用时传入具体的类型。 Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，泛型的好处就是在编译的时候能够检查类型安全。 泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。 一个最普通的泛型类： public class Demo{ / /T可以为任意标识符，常见的如T、E、K、V等形式的参数常用于表示泛型 private T key; / /key这个成员变量的类型为T,T的类型由外部指定 public Demo(T key) { / /泛型构造方法形参key的类型也为T，T的类型由外部指定 this.key = key;} public T getKey(){ / /泛型方法getKey的返回值类型为T，T的类型由外部指定 return key;}} 传入的实参类型需与泛型的类型参数类型相同，即为Integer. Demo demo = new Demo(123456); 1.泛型的类型参数只能是类类型 2.泛型的类型参数可以有多个。 3.如果没有定义具体类型,默认为Object

泛型接口与泛型类的定义及使用基本相同。 public interface Demo { //定义一个泛型接口 } 子类也是泛型类，子类和父类的泛型类型要一致 class A implements Demo{ } 子类不是泛型类，父类要明确泛型的数据类型 public class A implements Demo { } 类型通配符一般是使用"？"代替具体的类型实参。 public void show(Demo obj){ // ?表示实际传入的参数类型可以是任意的 } Demo gInteger = new Demo(123); Demo gNumber = new Demo(456); show(gInteger); show(gNumber); 类型通配符上限 类/接口<？extends 实参类型> 要求该泛型的类型，只能是实参类型，或实参类型的子类类型。 类型通配符下限 类/接口<？super 实参类型> 要求该泛型的类型，只能是实参类型，或实参类型的父类类型。

泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好地和之前版本的代码兼容。那是因为，泛到信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为一类型擦除。泛型类被类型擦除后，相应的类型就被替换成 Object 类型或者上限类型

public class Demo<T> {
    private   T num;    //集合中如果不添加泛型,默认是可以添加任何类型(引用类型)
    public T getNum() {
        return num;
    }
    public void setNum(T num) {
        this.num = num;
    }   
    //? 表示实际传入的参数的泛型类型  ?表示可以是任意的    也称无界通配符
    public void show(Demo<?> obj){      
    }   
    /*
      Demo<? extends T> 类型通配符上限    实际传入的类型,只能是T(Number) 获者T的子类
     */
    public void show1(Demo<? extends T> obj){       
    }    
    /*
      Demo<? super T> 类型通配符下限    实际传入的类型,只能是T(Number) 获者T的父类
     */
    public void show2(Demo<? super T> obj){         }
      public static void main(String[] args) {
          //实际传入的参数类型必须是引用类型
          //可以有多个泛型
          //如果没有传入实际的类型,类型默认是Object
          Demo<Float> d = new Demo<>(); 
                       d.setNum(10.1f);                
           Demo  d1 =     new  Demo();
                 d1.setNum("1");
                 d1.setNum(2);               
                 MyArrayList<String> arrayList  =    new MyArrayList<>();   }}
​
// 子类和父类继续都是泛型类
//public class CDemo<T> extends Demo<T> {
//子类继承父类  父类类型明确了  子类可以不是泛型类
public class CDemo extends Demo<Integer>{   
    public static void main(String[] args) {
        /*CDemo<Integer> cd =  new CDemo();
                       cd.setNum(10);*/     
        CDemo cd =  new CDemo();
        cd.setNum(10);          }