Java箱与泛型

最新推荐文章于 2024-11-07 22:55:42 发布

三个月带上银铐子

最新推荐文章于 2024-11-07 22:55:42 发布

阅读量1k

点赞数 20

文章标签：数据结构算法

本文链接：https://blog.csdn.net/2301_80873677/article/details/141824276

版权

大O的渐进表示法

大 O 的渐进表示法 去掉了那些对结果影响不大的项 ，简洁明了的表示出了执行次数。

void func1(int N){
int count = 0;
for (int i = 0; i < N ; i++) {
for (int j = 0; j < N ; j++) {
count++;
}
}
for (int k = 0; k < 2 * N ; k++) {
count++;
}
int M = 10;
while ((M--) > 0) {
count++;
}
System.out.println(count);
}

程序运行次数是N^2+2*N+10

选大头就是N^2

// 计算阶乘递归factorial的时间复杂度？
long factorial(int N) {
return N < 2 ? N : factorial(N-1) * N;
}
// 计算斐波那契递归fibonacci的时间复杂度？
int fibonacci(int N) {
return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}
//factorial:::::通过计算分析发现基本操作递归了N次，时间复杂度为O(N)。
//fibonacci:::::通过计算分析发现基本操作递归了N^2次，时间复杂度为O( N^2)

基本操作执行了2N+10次，通过推导大O阶方法知道，时间复杂度为 O(N)
基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M)
基本操作执行了100次，通过推导大O阶方法，时间复杂度为 O(1)
基本操作执行最好N次，最坏执行了(N*(N-1))/2次，通过推导大O阶方法+时间复杂度一般看最坏，时间复杂度为 O(N^2)
基本操作执行最好1次，最坏lgN次，时间复杂度为 O(lgN) ps：找每次排除掉一半的不适合值,一次二分剩下：n/2 两次二分剩下：n/2/2 = n/4)

1. 包装类

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

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

基本数据类型 包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

1.2 装箱和拆箱

装箱：基本类型->包装类型

拆箱：包装类型->基本类型

int i = 10;
// 装箱操作，新建一个 Integer 类型对象
Integer ii = Integer.valueOf(i);//显式装箱
Integer ij = new Integer(i);
// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中
int j = ii.intValue();

1.3 自动装箱和自动拆箱

装箱和拆箱带来不少的代码量，所以为了减少开发者的负担， java 提供了自动机制。

int i = 10;
Integer ii = i; // 自动装箱
Integer ij = (Integer)i; // 自动装箱
int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱

public static void main(String[] args) {
Integer a = 100;
Integer b = 100;
Integer c = 200;
Integer d = 200;
System.out.println(a == b);
System.out.println(c == d);

System.out.println(a - b);
System.out.println(c + d);
}
//true
//false
//0
//400

valueOf有数据限制，即256个数据，超出-128-127的将给出一个新的地址，所以上式才会出现true和false

2. 泛型类

泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译 器去做检查。 此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

语法格式：

class 泛型类名称 < 类型形参列表 > {

//

}

class ClassName < T1 , T2 , ..., Tn > {

//

}

class 泛型类名称 < 类型形参列表 > extends 继承类 {

//

}

class ClassName < T1 , T2 , ..., Tn > extends ParentClass < T1 > {

// 可以只使用部分类型参数

}

class MyArray<T> {
public Object[] array = new Object[5];

public T getPos(int pos) {
return (T)this.array[pos];
}
public void setVal(int pos,T val) {
this.array[pos] = val;
}

}
public class TestDemo {

public static void main(String[] args) {

MyArray<Integer> myArray = new MyArray<Integer>();//MyArray<Integer> myArray = new MyArray<>();
myArray.setVal(0,10);
myArray.setVal(1,12);
Integer ret = myArray.getPos(1);//int ret = myArray.getPos(1);
System.out.println(ret);
myArray.setVal(2,"bit");//报错，只能传入Integer
}
}

<>中一定是包装类型
类名后的 <T> 代表占位符，表示当前类是一个泛型类
【规范】类型形参一般使用一个大写字母表示，常用的名称有：

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

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

那么，泛型到底是怎么编译的？这个问题，也是曾经的一个面试问题。泛型本质是一个非常难的语法，要理解好他还是需要一定的时间打磨。

在编译的过程当中，将所有的 T 替换为 Object 这种机制，我们称为： 擦除机制 。

Java 的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。

JVM中不存在泛型！！！！

运行时也没有泛型！！！！

泛型擦除机制文章介绍： https://zhuanlan.zhihu.com/p/51452375

2.1泛型的上界

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

class 泛型类名称<类型形参 extends 类型边界> {
//
}
//示例
public class MyArray<E extends Number> {
//
}
//只接受 Number 的子类型作为 E 的类型实参

MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型0

class Alge<T extends Comparable> {
        public T findMax(T[] array) {
            T max = array[0];
            for (int i = 0; i < array.length; i++) {
                if( max.compareTo(array[i]) < 0 ) {
                    max = array[i];
                }
            }
            return max;
        }
}
class Student implements Comparable{
    @Override
    public int compareTo(Object o) {
        return 0;
    }
}
class test1{
    public static void main(String[] args) {
        Integer array[]= {1,2,3,4,5};
            Alge<Integer> newr =new Alge();
        int a = newr.findMax(array);
        System.out.println(a);
        Student[] students = new Student[3];
        Alge<Student> Alge2 = new Alge<>();
        Student AD = Alge2.findMax(students);
    }
}

2.2泛型方法

2.3.1 定义语法

方法限定符 <类型形参列表> 返回值类型方法名称(形参列表) { ... }

泛型方法的简单使用：

class Alge<T extends Comparable> {
        public<T extends Comparable> T findMax(T[] array) {
            T max = array[0];
            for (int i = 0; i < array.length; i++) {
                if( max.compareTo(array[i]) < 0 ) {
                    max = array[i];
                }
            }
            return max;
        }
}

class test1{
    public static void main(String[] args) {
        Integer array[]= {1,2,3,4,5};
            Alge alg1 =new Alge();
        Integer  x = (Integer) alg1.<Integer>findMax(array);
        System.out.println(x);

    }
}

public class Util {
//静态的泛型方法 需要在static后用<>声明泛型类型参数
public static <E> void swap(E[] array, int i, int j) {
E t = array[i];
array[i] = array[j];
array[j] = t;
}
}
//
Integer[] a = { ... };
swap(a, 0, 9);
String[] b = { ... };
swap(b, 0, 9);
//
Integer[] a = { ... };
Util.<Integer>swap(a, 0, 9);
String[] b = { ... };
Util.<String>swap(b, 0, 9);