Java 集合框架及其数据结构

🚀 一、 介绍 Java 集合框架

Java 集合框架 ：Java collection Framwork ，又被称为容器，是定义在 java.util 包下的接口 interfaces 和其实现类 classes。

上面两张图片详细介绍了 Java 中数据结构的实现和继承关系，下面所有数据结构都将以这两张图片为基础学习。

🚀 二、 接口 interfaces

1. Collection ：用来存储管理一组对象 Objects 。

   1. Set：元素不重复的集合。
      • SortedSet ：在 Set 的基础上，数据有序。
   2. List：线性结构。
   3. Queue：队列。
   4. Deque：双端队列。

2. Map：键值对“key ： value” 模型。

🌟2.1 Collection 接口说明

2.1.1 常用方法说明

2.1.2 Collection 示例

public class Main {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("hello");
        list.add("word");
        System.out.println(list);

        System.out.println(list.isEmpty());
        System.out.println(list.size());
        
        Object[] arr = list.toArray();
        System.out.println(Arrays.toString(arr));
        for(String s : list){
            System.out.println(s);
        }
    }
}

🌟2.2 Map 接口说明

2.2.1 常用方法说明

2.2.2 Map 示例

public class Main {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        System.out.println(map.size());
        System.out.println(map.isEmpty());
        System.out.println(map.getOrDefault("作者","匿名"));
        System.out.println(map.containsKey("作者"));
        System.out.println(map.containsKey("匿名"));
        map.put("作者","鲁迅");
        map.put("标题","狂人日记");
        map.put("时间","1918");
        System.out.println(map.getOrDefault("作者","匿名"));
        System.out.println(map.containsKey("作者"));
        System.out.println(map.containsValue("匿名"));
        System.out.println(map.containsKey("作者"));
        for(Map.Entry<String,String> entry:map.entrySet()){
            System.out.println(entry.getKey() + "--->" + entry.getValue());
        }
    }
}

🚀 三、 时间复杂度和空间复杂度

🌟 3.1 算法效率

算法效率用来衡量一个算法的好坏。

算法效率分为两种：

1. 时间复杂度：主要衡量一个算法的运行速度。（主要关注）
2. 空间复杂度：主要衡量一个算法需要的额外空间。

🌟 3.2 时间复杂度

3.2.1 时间复杂度的概念

在计算机科学中，算法的时间复杂度是一个数学函数，它定量描述了一个算法的运行时间。但是一个算法的运行时间，理论上是很难测算出来的。科学家将算法中基本操作的执行次数，称为算法的时间复杂度。

3.2.2 大O的渐进表示法

// 求下面 fnnc1 的时间复杂度
public void func1(int n){
    int cnt = 0;
    for(int i = 0; i < n;i++){
        for(int j = 0 ;j < n; j++){
            cnt++;
        }
    }
    for(int k = 0; k < 2 * n; k++){
        cnt++;
    }
    int m = 10;
    while((m--) > 0){
        cnt++;
    }
}

上面函数的基本操作次数：F(N) = N^2 + 2*N + 10

实际计算时间复杂度时，不需要计算精准的执行次数，只需要知道大概的执行次数，这里使用大O的渐进表示法。

算法复杂度：O(N^2)

3.2.3 推导大 O 阶方法

1. 用常数 1 取代运行时间中所有的加法常数。
2. 修改后的运行次数中，只保留最高阶项。
3. 最高阶项存在且不是 1 ，则去除与这个项相乘的常数，保留 N。

F(N) = N^2 + 2*N + 10 表示为 ： O(N ^ 2)

3.2.4 常见时间复杂度举例

void func2(int n){
	int cnt = 0;
	for(int i = 0; i < n; i++){
		cnt++;
	}
	int m = 10;
	while((m--) > 0){
		cnt++;
	}
}

// O(N)

void func3(){
	int cnt = 0;
	for(int i = 0; i < 100; i++){
		cnt++;
	}
}

// O(1)

// 计算 bubblesort 的时间复杂度
void bubbleSort(int[] arr){
    for(int i = 0;i < arr.length;i++){
        int flag = 0;
        for(int j = 0;j < arr.length-i-1;j++){
            if(arr[j] > arr[j+1]){
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
                flag = 1;
            }
        }
        if(flag == 0){
            break;
        }
    }
}

// O( N^2 )

// 计算 bianrySearch 的时间复杂度
int binarySearch(int[] arr,int val){
	int begin = 0;
	int end = arr.length - 1;
	while(begin <= end){
		int mid = begin + ((end - begin)/2);
		if(arr[mid] == val){
			return mid;
		}else if(arr[mid] > val){
			end = mid - 1;
		}else{
			begin = mid + 1;		
		}
	} 
	return -1;
}

// O( logN )

// 计算斐波那契递归的时间复杂度
int fibonacci(int n){
	return n<2 ? fibonacci(n-1) + fibonacci(n-2);
}

// O( 2^N )

🌟 3.3 空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。空间复杂度算的是变量的个数。

// 计算 bubblesort 的空间复杂度
void bubbleSort(int[] arr){
    for(int i = 0;i < arr.length;i++){
        int flag = 0;
        for(int j = 0;j < arr.length-i-1;j++){
            if(arr[j] > arr[j+1]){
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
                flag = 1;
            }
        }
        if(flag == 0){
            break;
        }
    }
}

// O( 1 )

// 计算 fibonacci 的空间复杂度
int[] fiboancci(int n){
	long[] fibArr = new long[n+1];
	fibArr[0] = 0;
	fibArr[1] = 1;
	for(int i = 2;i <= n; i++){
		fibArr[i] = fibArr[i-1] + fibArr[i-2];
	}
	return fibArr;
}

// 动态开辟了 N 个空间
// O (N) 

// 计算递归 fibonacci 的空间复杂度
long fiboancci(int n){
	return n<2 ? fibonacci(n-1) + fibonacci(n-2);
}

// 递归调用了 n 次，开辟了 n 个栈帧，每个栈帧使用常数空间。
// O (N)