集合框架

时间复杂度和空间复杂度

时间复杂度

算法中的基本操作的执行次数，为算法的 时间复杂度 

大O记法

1.用常数1取代运行时间中的所有加法常数

2.在修改后的运行次数函数中，只保留最高阶项。 

3.如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

public class mAIN {
    long factorial(int n){
        return n<2?n:factorial(n-1)*8;
    }
}

递归的时间复杂度=递归的次数*每次递归后执行的次数；

O（n）=n*1

斐波那契数

 int fibonacci(int N)
    {
        return N<2?N:fibonacci(N-1)+fibonacci(N-2);
    }

他们是1+2+4+8+2^n-1，由于是2的等比数列 等于2^2n/n所以O（2^n）

空间复杂度

是否用到临时变量(额外的空间)，占到空间，如果用到临时变量的时候，就会变成O（1）更大的空间复杂度

O(1)<O(long N)<O(N)<O(Nlong N)<O(N^2)

包装类

阿里巴巴面试题

public static void main2(String[] args) {
        Integer i1=100;
        Integer i2=100;
        System.out.println(i1==i2);
        Integer i3=200;
        Integer i4=200;
        System.out.println(i3==i4);
    }

 

 如果是200的情况下会出现他们两个不相等，因为他们两个在两个数组中，在-128和127中的100就可以相等。因为他们在同一个数组中。

泛型

 public static void main(String[] args) {
        MyArray myArray=new MyArray();//裸类型
        Object myArray1=new Object[10];
        myArray.setValue(0,1);
        myArray.setValue(1,19);
        myArray.setValue(2,"asd");
        String str=(String) myArray.getValue(2);
    }
class MyArray{
   // public Object[]array=new Object[10];
    public  Object[]array=new Object[10];
    public void setValue(int pos,Object val){
        array[pos]=val;
    }
    public Object getValue(int pos){
        return  array[pos];
    }

 需要强转相应的类型

不能实例化一个泛型类型 即不能new T

  public static void main(String[] args) {
        MyArray<String>myArray=new MyArray<>();
        myArray.setValue(0,"asd");
        myArray.setValue(1,"asdd");
    }
class MyArray<T>{
   // public ObTject[]array=new Object[10];
//    public  Object[]array=new Object[10];
    public T[] array=(T[])new Object[10];
    public void setValue(int pos,T val){
        array[pos]=val;
    }
    public T getValue(int pos){
        return  array[pos];
    }

 <>中的即是数据包装类型或者对象就可以进行任意应用

泛型的意义 就是
1.在编译的时候 检查数据类型是否正确

2.在编译的时候 帮助进行类型转化

class 中T可以有多个

java中自带擦除机制：将所有的T替换为Object的机制。

最优解代码。

class MyArray<T>{
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];
    }

 数组是一种单独的数据类型，数组之间有继承关系这样说法吗？

 泛型的上界

public class Main {

    public void main(String[] args) {
        MyArray<Integer> myArray=new MyArray<Integer>();
    }
   
}
 class MyArray<T extends Number>{
    public Object[]array=new Object[10];
    public void setArray(int pos,T val){
        array[pos]=val;
    }
    public T get(int pos){
        return (T)array[pos];
    }
}

 在代码中T extends number类 所以MyArray<>中的<>只能填写number或者number的子类；

class  Alg<T extends Comparable <T>>{
    public T findMaxVal(T[]array){
        T max=array[0];
        for(int i=1;i<array.length;i++){
            if(array[i].compareTo(max)>0){
                max=array[i];
            }
        }
        return max;
    }
}
 public static void main(String[] args) {
        Integer[]array={1,2,3,4,5};
        Alg<Integer> alg=new Alg<>();
        System.out.println(alg.findMaxVal(array));
    }

在比较的时候只能先继承Comparable的接口，才能用到CompareTo方法，由于T方法所以他们是不存在><的比较只能用compareTo方法，

class Person {

}
  Alg<Person> personAlg=new Alg<>();

如果用此方式的person就无法通过编译，由于person没有自己的Comparable

 

class Person implements Comparable<Person>{


    @Override
    public int compareTo(Person o) {
        return 0;
    }
}

只有Person继承了这个compareto方法后才能运行。

 public static void main(String[] args) {
        Alg2 alg2=new Alg2();
        Integer[]array={1,2,3,4,5,};
        alg2.findMaxVal(array);
        alg2.<Integer>findMaxVal(array);
        Alg3.findMaxVal(array);
    }
class Alg3{
    public static  <T extends Comparable <T>>T findMaxVal(T[]array){
        T max=array[0];
        for(int i=1;i<array.length;i++){
            if(array[i].compareTo(max)>0){
                max=array[i];
            }
        }
        return max;
    }
}
class Alg2{
    public <T extends Comparable <T>>T findMaxVal(T[]array){
        T max=array[0];
        for(int i=1;i<array.length;i++){
            if(array[i].compareTo(max)>0){
                max=array[i];
            }
        }
        return max;
    }
}