Java包装类与泛型

---

前言

---

一、包装类

1.基本数据类型与包装类

基本数据类型对应的类类型–》包装类(类中必然有属性/方法)
byte—>Byte
short—>Short
long—>Long
float–>Float
double—>Double
boolean–>Boolean
int—>Integer
char—>Character
有包装类有以下好处：
1.使用比较方便
2.数据的转换（相当于数据类型也面向对象了）

2.装箱（装包）拆箱（拆包）

装箱：基本类型–》包装类型

 public static void main(String[] args) {
        int a=10;
        Integer b=a;//自动装箱
        Integer c=new Integer(a);//显示装箱
        Integer d=Integer.valueOf(a);//与前面一个意思，因为前面底层调用了valueOf。//显示装箱

    }

拆箱：包装类型–》基本类型

 public static void main(String[] args) {
        Integer a=99;
        int i=a.intValue();//显示拆箱
        Float b=9.9f;
        float c=b.floatValue();//拆小数
        
        int d=a;//自动拆箱
        
    }

3.例子

为啥127相等，128不等？

 Integer a=127;
        Integer b=127;

        Integer c=128;
        Integer d=128;
        System.out.println(a==b);//true
        System.out.println(c==d);//false

Integer底层是valueOf,下面是底层原理：

public static Integer valueOf(int i){
            if(i>=IntegerCache.low&&i<=IntergerCache.high)//i>=-128，i<=127
            {
                return IntegerCache.cache[i+(-IntegerCache.low)];
                
            }
            return new Integer(i);
            //若127，在范围内，127+128=255，下标为255，不用new新的空间
            //如128，不在范围内，要new新的空间。
        }

初级泛型

很抽象，要求看懂即可。
类和方法：具体类型，自定义类型。
泛型：适用于许多许多类型，对类型实现了参数化。传递类型！

1.引出泛型

实现一个类，类中包含一个数组成员，使数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。

class MyArray{
    public Object[] objects=new Object[10];
    public Object getPos(int pos){
        return objects[pos];
    }
    public void setVal(int pos ,Object val){
        objects[pos]=val;
    }
        }
public class Test02 {
    public static void main(String[] args) {
        MyArray myArray=new MyArray();
        myArray.setVal(0,377);
        myArray.setVal(1,"dhj");
        int val=(int)myArray.getPos(0);//Object必须强转为int类型
        System.out.println(val);//377
    }
}

必须强制类型转换。

2.泛型如何写

可以存任何类型数据，但是我指定存任何类型数据。

类名后的代表占位符，表示当前类是一个泛型类。<>里面一定是一个引用类型。

1.

第一种泛型方式：

class MyArray<T>{//<T>代表占位符，表示当前类是一个泛型类。
    //public Object[] objects=new Object[10];//正确写法
    public T[] objects=(T[]) new Object[10];//这样写，有缺陷
    public T getPos(int pos){
        return objects[pos];
    }
    public void setVal(int pos ,T val){
        objects[pos]=val;
    }
}
public class Test02 {
    public static void main(String[] args) {
        MyArray<Integer> myArray=new MyArray<Integer>();//指定当前传的是Integer类型
        myArray.setVal(0,377);
        myArray.setVal(1,77);
        int val=myArray.getPos(0);//不需要强转了！！
        System.out.println(val);//377

        MyArray<String> myArray1=new MyArray<>();//第二个<>里面的内容可以省略
        myArray1.setVal(0,"dhhs");
        myArray1.setVal(1,"jdjjd");
        String val2=myArray1.getPos(1);
        System.out.println(val2);//jdjjd
    }
}

第二种泛型方式（常用）

class MyArray<T>{//<T>代表占位符，表示当前类是一个泛型类。

    public Object[] objects=new Object[10];

    public T getPos(int pos){
        return (T)objects[pos];//强转T类型
    }
    public Object getArray() {
        return objects;
    }
    public void setVal(int pos ,T val){
        objects[pos]=val;
    }
}
public class Test02 {
    public static void main(String[] args) {
        MyArray<Integer> myArray=new MyArray<Integer>();//指定当前传的是Integer类型
        myArray.setVal(0,377);
        myArray.setVal(1,77);
        int val=myArray.getPos(0);//不需要强转了！！
        System.out.println(val);//377
    }
}

泛型存在意义：在编译的时候，帮我们进行类型检查
在编译的时候，帮我们进行类型转换
在运行的时候是没有泛型的概念。（JVM无泛型）
擦除机制：·编译过程中将所有的T都替换为Object。（编译时实现）

2.

如果根据上面的添加数组的返回值：不允许把object类型进行强制类型转换
因为object数组里面能放任意类型的数据，所以不能强转为单一类型

MyArray<T>类中：
 public T[] getArray(){
        return objects;
    }
 main方法里：
 Object obj=myArray1.getArray();//返回值只能用Object接收，而且不能够强转。//不允许把object类型进行强制类型转换

如果一定要进行转换，就实例化具体类型的数组（明确你的数组类型）

class MyArray<T>{//<T>代表占位符，表示当前类是一个泛型类。
    //public T[] objects=(T[]) new Object[10];//把这里覆盖了
    public T[] objects;
    public MyArray(){

    }

    public MyArray(Class<T>clazz,int capacity){
        objects=(T[]) Array.newInstance(clazz,capacity);
    }
    public T[] getArray() {
        return objects;
 }
 public static void main(String[] args) {
        MyArray<Integer> myArray1 = new MyArray<Integer>(Integer.class, 10);//指定当前数组传的是Integer类型
        Object obj = myArray1.getArray();

    }

3.泛型的上界

写泛型，求数组中的最大值。
引用类型不可以大于小于比较。Object是所有的父类，中无compareable与compareTo。擦除为一个实现了这个接口的类型。就可以了。

以下求数组最大值的题目为例子：

class Alg<T extends Comparable>{//设置边界，防止compar被擦除，只留下object//擦除为一个实现了这个接口的类型//上界
    public T findMax(T[] array){
        T max=array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i])<0){//引用类型不可以大于小于比较
                max=array[i];
            }
        }
        return max;
    }
}
public class Test03 {
    public static void main(String[] args) {
        Alg<Integer> alg=new Alg<>();//Integer,String等引用类型都实现了comparable接口。
        // 但是自定义类型中如果没有自己实现，那就不可以。
        Integer[] array={1,23,5,3,53,22,32};
        Integer max= alg.findMax(array);
        System.out.println(max);

    }
}

泛型的静态方法：

class Alg{
    public static<T extends Comparable> T findMax(T[] array){//T被盖住没有comparable重写。
        T max=array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i])<0){//引用类型不可以大于小于比较
                max=array[i];
            }
        }
        return max;
    }
}
public class Test03 {
    public static void main(String[] args) {

        Integer[] array={1,23,5,3,53,22,32};
        Integer max= Alg.<Integer>findMax(array);//静态，直接类名调用
        System.out.println(max);

    }
}

---

总结