JAVA(集合框架 泛型 复杂度)

1.泛型

泛型:适用于许多许多类型,对类型实现了参数化

package demo1;
class  MyArray{
    //任何类型 Object
    //数组中可以存放任何类型的数据,也可以根据成员方法返回数组中某个下标的值
    public  Object[] array=new  Object[10];
    public  Object getPos(int pos){
        return this.array[pos];
    }
    public void setVal(int pos,Object Val){
        this.array[pos]=Val;
    }
    }
public class Test2 {
    public static void main(String[] args) {
        MyArray myArray=new MyArray();
        //当前数组任何数据都可以存放
        myArray.setVal(0,10);
        myArray.setVal(1,"hello");
        //编译报错,需要强制类型转换
        String str=(String) myArray.getPos(1);
        System.out.println(str);
    }

}

 多数情况下,希望它持有一种数据类型

主要目的:指定当前的容器,要持有什么类型的对象,需要什么类型,就传入什么类型 优点:编译时自动进行类型检查和转换

<T>:代表当前类是一个泛型类,不需要强转了

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

}

//不允许实例化一个泛型数组

public T[] array=new T[10](擦除机制)

package demo1;
class  MyArray<T>{
    //<T>:代表当前类是一个泛型类
    public  Object[] array=new Object[10];
    public  T getPos(int pos){
        return (T) array[pos];
    }
    public void setVal(int pos,T Val){
        array[pos]=Val;
    }
    }
public class Test2 {
    public static void main(String[] args) {
        MyArray <String> myArray=new MyArray<>();
        myArray.setVal(0,"hello");
        //只能存放指定的类型了
       // myArray.setVal(1,99);
        String str=myArray.getPos(0);
        //不用强制类型转换
        System.out.println(str);
        MyArray <Integer> myArray2=new MyArray<>();
        myArray2.setVal(0,123);
        myArray2.setVal(1,10);
        int a=myArray2.getPos(0);
        Integer b=myArray2.getPos(1);
        System.out.println(a);
        System.out.println(b);



    }

}

泛型类使用

定义一个泛型类的引用=实例化一个泛型类对象

MyArray <Integer>list=new MyArray<>();

泛型的擦除机制(泛型是如何编译的)

在编译的过程中,将所有T替换为Object (擦除机制)

泛型的上界(extends)

泛型方法

例:public static<E> void Swap(E[] array,int i,int j){}v  

2.什么是集合框架

Java集合框架(Java Collection Framework) ,是定义在java.util包下的一组接口(interfaces)和其实现类(classes),集合框架里面含有许多集合类,每一个集合类背后是一个数据结构

3.时间复杂度和空间复杂度

如何衡量一个算法的好坏?

算法效率

1)时间效率:时间复杂度(数学函数),主要衡量一个算法的运行速度,算法中的基本操作的(大概)执行次数,为算法的时间复杂度

大O的渐进表示法:

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

2,修改后的运行次数函数中只保留最高阶项

3,如果最高阶项存在且不是1,则去除与这个项数相乘的常数

在实际中一般关注算法的最坏运行情况

大O阶+最坏情况

package demo1;

import com.sun.org.apache.bcel.internal.generic.SWAP;

public class Test {
    //时间复杂度 M+N
    //因为M,N是未知数
    void func1(int N,int M){
        int count=0;
        for(int k=0;k<M;k++){
            count++;
        }
        for(int k=0;k<N;k++){
            count++;
        }
        System.out.println(count);
    }


    //等差数列求和 首项加末项乘以项数除以2
    //最坏情况 N方
    //最好情况 N
    //是按复杂度N方
    void func2(int[]array) {
        for (int end = array.length; end > 0; end--) {
        boolean sorted=true;
            for (int i = 1; i <end ; i++) {
                if(array[i-1]>array[i]) {
                    Swap(array,i-1,i);

                    sorted=false;
                }
            }
            if(sorted==true){
                break;
            }
        }
    }
    public static void Swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
        //二分查找
    //2的x次方/n=1 x=log 2 n;
    int binarySearch(int[]array,int value){
        int begin=0;
        int end=array.length-1;
        while (begin<=end){
            int mid=(begin+(end-begin))/2;
            if(array[mid]<value){
                begin=mid+1;
            }
            else if(array[mid]>value){
                end=mid-1;
            }
            else{
                return  mid;
            }

        }
        return -1;
    }
//斐波那契递归
    //时间复杂度2的n次方
    int fibonacci(int N){
        return N<2?N:fibonacci(N-1)+fibonacci(N-2);
    }
    public static void main(String[] args) {

    }
}

递归的复杂度=递归的次数*每次递归执行的次数

2)空间效率:空间复杂度,主要衡量一个算法所需要的额外空间,是对一个算法在运行过程中临时占用存储空间大小的量度

递归调用了几次,就开辟了几个栈帧,每个栈帧使用常数个空间

4.包装类

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

基本数据类型变成了一个类

例:

基本数据类型	包装类
int	Integer
char	Character
float	Float
double	Double

 首字母变大写

装箱和拆箱

package demo1;

public class Test3 {
    public static void main(String[] args) {
        //装箱:把一个基本数据类型转化为包装类型的过程
        //自动装箱
        int a=10;
        Integer b=a;
        System.out.println(b);
        //显示装箱
        Integer c=Integer.valueOf(a);
        System.out.println(c);
        //自动拆箱
        Integer d=new Integer(5);
        int e=d;
        System.out.println(e);
        //显示拆箱 
        int f=d.intValue();
        System.out.println(f);
        double s=d.doubleValue();
        System.out.println(s);
    }
}

Integer 范围 -128-127;