大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 的子类型0class 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);