【Java数据结构 -- 包装类和泛型】

本文主要是介绍【Java数据结构 -- 包装类和泛型】，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1. 包装类

在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。

1.1 基本数据类型和对应的包装类

基本数据类型 --> 包装类
byte --> Byte
short --> Short
int --> Integer
long --> Long
float --> Float
double --> Double
char --> Character
boolean --> Boolean
除了 Integer 和 Character， 其余基本类型的包装类都是首字母大写。

1.2 装箱和拆箱

装箱/装包：把一个基本类型转变为包装类型
拆箱/拆包：把一个包装类型转变为基本类型

1.3 自动装箱和自动拆箱

    public static void main(String[] args) {int a = 10;Integer ii = a; //自动装箱Integer ii2 = new Integer(10);int b = ii2; //自动拆箱System.out.println(ii);  // 10System.out.println(b);   // 10}

1.4 自动装箱实际上是调用了valueOf（）

    public static void main2(String[] args) {int a = 10;//Integer ii = a; //自动装箱Integer ii = Integer.valueOf(a);  // 手动装箱Integer ii2 = new Integer(10);//int b = ii2; //自动拆箱int b = ii2.intValue(); // 手动拆箱double d = ii2.intValue();System.out.println(ii);  // 10System.out.println(b);   // 10System.out.println(d);   // 10.0}

1.5 Integer包装类赋值注意点

    public static void main(String[] args) {//  i >= IntegerCache.low && i <= IntegerCache.high// 在 Integer  valueOf方法中  的int i取值范围是  -128~127// 在这个返回返回的是  -128 到 127 中 255 个地址 存放100// IntegerCache.cache[i + (-IntegerCache.low)] 即返回的地址为同一个地址// 而200不属于这个取值范围里面 返回的是 一个新的 值 new Integer(i)/*Integer ii = 100;Integer ii2 = 100;  //true */Integer ii = 200;Integer ii2 = 200;  //falseSystem.out.println(ii == ii2);}

2 什么是泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。
泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

3 引出泛型

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

class MyArray <T>{// <T> 占位符 是一个泛型类//  泛型的意义：1. 在编译的时候 检查数据类型是否正确 2.在编译的时候   帮助进行类型转化//public Object[] array = new Object[10];// 不能实例化一个泛型类型的数组// public T[] array = new T[10];//public T[] array = (T[])new Object[10];public Object[] array = new Object[10];public void setValue(int pos,T val) {array[pos] = val;}// 在java中不能将整个数组进行强转public T getValue(int pos) {return (T) array[pos];}}
class Person {}
public class Test {public static void main(String[] args) {MyArray<Integer> myArray = new MyArray<>();//MyArray<int> myArray = new MyArray<>(); //<>里面不能是基本数据类型myArray.setValue(1,90); // 直接放int 会发生自动装箱//裸类型  不加包装类型MyArray myArray1 = new MyArray<>();myArray1.setValue(0,1);}//目的：想存放指定的元素public static void main4(String[] args) {MyArray<String> myArray = new MyArray<>();myArray.setValue(0,"hello");MyArray<Integer> myArray2 = new MyArray<Integer>();//类型后加入<Integer> 指定当前类型myArray2.setValue(0,99);myArray2.setValue(1,20);MyArray<Person> myArray3 = new MyArray<>();}
}

1. 类名后的 代表占位符，表示当前类是一个泛型类
   了解： 【规范】类型形参一般使用一个大写字母表示，常用的名称有：

• E 表示 Element
• K 表示 Key
• V 表示 Value
• N 表示 Number
• T 表示 Type
• S, U, V 等等 - 第二、第三、第四个类型

2. 不能new泛型类型的数组
3. 类型后加入 指定当前类型
4. 不需要进行强制类型转换

4 泛型的使用

4.1 语法

//泛型类<类型实参> 变量名; // 定义一个泛型类引用
//new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象
MyArray<Integer> myArray = new MyArray<>();

泛型只能接受类，所有的基本数据类型必须使用包装类！

4.2 类型推导

MyArray<Integer> list = new MyArray<>(); // 可以推导出实例化需要的类型实参为 Integer

5 裸类型

        //裸类型  不加包装类型MyArray myArray1 = new MyArray<>();myArray1.setValue(0,1);

总结：

1. 泛型是将数据类型参数化，进行传递
2. 使用表示当前类是一个泛型类
3. 泛型的优点：数据类型参数化，编译时自动进行类型检查和转换

6 泛型如何编译

6.1 擦除机制

在终端通过命令：javap -c 查看字节码文件，所有的T都是Object。

在编译的过程，将所有的T替换为Object这种机制，称为：擦除机制。
即可以直接写成：

class MyArray <T>{//public T[] array = (T[])new Object[10];public Object[] array = new Object[10];public void setValue(int pos,T val) {array[pos] = val;}public T getValue(int pos) {return (T) array[pos]; //加(T) 转一下}public T[] getArray() {return (T[]) array;}}

7 泛型的上界

class MyArray <T extends Number>{  // T 一定是Number或者是Number的子类如Integerpublic Object[] array = new Object[10];public void setValue(int pos,T val) {array[pos] = val;}public T getValue(int pos) {return (T) array[pos];}
}public static void main(String[] args) {MyArray<String> myArray = new MyArray<>();  // 报错 String不是Number的子类// String[] ret = (String[])myArray.getArray();  //会报错 在java中不能将整个数组进行强转// 数组是一种单独的数据类型Object[] ret = myArray.getArray();}

写一个泛型类， 求一个数组当中的最大值

//写一个泛型类， 求一个数组当中的最大值
class Alg<T extends Comparable<T>> {  // 泛型的上界public T findMaxVal(T[] array) {T max = array[0];for (int i = 0; i < array.length; i++) {//if (array[i] > max) {  // 引用类型不能直接通过 大于等于号进行比较//这个时候就需要 写一个Comparable<T> 上界if (array[i].compareTo(max)>0){max = array[i];}}return max;}
}
public class Test {public static void main(String[] args) {Integer[] array = {1,2,8,5,3};Alg<Integer> alg = new Alg<>();System.out.println(alg.findMaxVal(array)); }
}

另一个类作为参数实例化时要引用它对应的接口和重写对应的方法

class Person implements Comparable<Person> {@Overridepublic int compareTo(Person o) {return 0;}
}//写一个泛型类， 求一个数组当中的最大值
class Alg<T extends Comparable<T>> {  // 泛型的上界public T findMaxVal(T[] array) {T max = array[0];for (int i = 0; i < array.length; i++) {//if (array[i] > max) {  // 引用类型不能直接通过 大于等于号进行比较//这个时候就需要 写一个Comparable<T> 上界if (array[i].compareTo(max)>0){max = array[i];}}return max;}
}
public class Test {public static void main(String[] args) {Integer[] array = {1,2,8,5,3};Alg<Integer> alg = new Alg<>();System.out.println(alg.findMaxVal(array));//如果定义一个类 作为Alg实例的话 这个类必须实现Comparable接口并且重写compareTo方法Alg<Person> alg1 = new Alg<Person>();}
}

8 泛型方法

在定义方法的时候加

class Alg2 {public<T extends Comparable> T findMaxVal(T[] array) {T max = array[0];for (int i = 0; i < array.length; i++) {if (array[i].compareTo(max)>0){max = array[i];}}return max;}
}public class Test {public static void main(String[] args) {Alg2 alg2 = new Alg2();Integer[] array = {1,2,8,5,3};alg2.<Integer>findMaxVal(array);  //可以不加<Integer>会通过实参的值自动推导alg2.findMaxVal(array);}
}

设为静态方法static

class Alg3 {public static <T extends Comparable> T findMaxVal(T[] array) {T max = array[0];for (int i = 0; i < array.length; i++) {if (array[i].compareTo(max)>0){max = array[i];}}return max;}
}public class Test {public static void main(String[] args) {Integer[] array = {1,2,8,5,3};Alg3.<Integer>findMaxVal(array);  //直接通过类名调用方法}
}

这篇关于【Java数据结构 -- 包装类和泛型】的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---