Java Day_6(数组，JVM内存，递归算法(冒泡，快排))

Java Day_6(数组，JVM内存，递归算法(冒泡，快排))

数组

1.定义：

* 数组是存储相同类型的多个元素的连续空间

2.分类：

 * 类型：基本类型数组	 ;   引用类型数组
 * 维度：一维；二维；三维…

3.特点：

*  	数组所储存的元素的类型必须是同种类型
*  	数组的长度是有限的 是固定的  一旦声明 则不能修改
*  数组的 空间是连续的

4.数组的声明和初始化：

public static void main(String[] args) {
    //声明数组  数据类型[]   数组的名称（标识符） = new 数据类型[数组的长度];;
    //        数据类型[]  数组的名称  = {数组中的元素，元素和元素之间使用逗号分割}
    //数组的动态初始化
    //此时  该数组只是分配了空间
    int[]  arr1 = new int[5];// 声明了一个长度为5的整型数组  数组的名称为arr1
    //数组中元素的引用
    System.out.println(arr1[0]);
    System.out.println(arr1[1]);
    System.out.println(arr1[2]);
    System.out.println(arr1[3]);
    System.out.println(arr1[4]);
}

数组中的元素的操作是 通过索引/角标来完成 索引或角标是 从0开始的

5.数组的元素的初始化：

 *  静态初始化：

public static void main(String[] args) {	
	int[] arr1 = new int[5];
    // 数组的静态初始化方式1   在数组声明的同时 就初始化了数组
    int[] arr2 = {10,20,30,40,22,36};
    // 数组的静态初始化方式2
    int[] arr3 = new int[]{21,11,31,41,51};
}

6.数组的默认值：

数组元素类型	元素默认初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0 或写为:’\u0000’(表现为空)
boolean	false
引用类型	null

7.数组的常用操作：

• 数组的遍历：

public static void main(String[] args) {
    int[] arr = new int[]{32,12,42,53,65};
    //使用普通for循环 + 数组的 length属性
    for (int i= 0 ; i < arr.length;i++){
        if(i % 2 != 0){
            System.out.println(arr[i]);
        }
    }
    System.out.println("----------------------------");
    // 使用增强for循环  （foreach） 从jdk1.5.开始引入
    // int  表示遍历的目标数据为int类型   j 表示遍历得到的 每一个元素的 暂存区域  arr  表示待遍历的对象容器/集合
    for(int j : arr){
        System.out.println(j);
    }
    /*
    这两种循环的区别：
        普通for循环可以精确的去控制 每一个元素
        增强for没法去精确的控制每一个元素  只能遍历所有元素
     */
}

• 数组的拷贝：

public class ArrayDemo_04 {
    public static void main(String[] args) {
        int[] arr1 = {56,65,69,68,58,24,35};
        //将arr1中的元素拷贝到另一个数组中
        // 1 创建 一个新的数组
        int[] arr2 = new int[arr1.length];
        for(int i = 0 ; i < arr1.length;i++){
            arr2[i] = arr1[i];
        }
        for (int j: arr2) {
            System.out.println(j);
        }
        // 将arr1 中的 元素逆序拷贝到arr3中
        System.out.println("-----------------------------");
        //1 创建一个 新的数组
        int[] arr3 = new  int[arr1.length];
        for (int i = 0,j= arr2.length -1  ; i < arr1.length && j >= 0;i++,j--){
            arr3[j] = arr1[i];
        }
        for (int j: arr3) {
            System.out.println(j);
        }
    }
}

• 数组中获取最值：

// 获取数组中元素的最大值
public static void main(String[] args) {
    int [] arr = new int[]{65,89,69,68,32,57};
    // 1 设定一个变量
    // 2 假设数组中的第一元素为 最大者
    //3 将最大的元素保存在变量中
    //4 使用当前的最大元素 依次和后边的 元素进行比较  如果后边的元素比他大 则替换 否则就继续比较
    int  maxEle;
    maxEle = arr[0];
    for (int i = 1 ; i < arr.length;i++){
        if(maxEle < arr[i]){
            maxEle = arr[i];
        }
    }
    System.out.println(maxEle);
}

JVM内存

区域名称	作用
程序计数器（寄存器）	给CPU使用，和我们开发无关。
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区	存储可以运行的class文件。
堆内存	存储对象或者数组，new来创建的，都存储在堆内存。当申请不到空间时会抛出OutOfMemoryError
虚拟机栈	栈里面是一个一个“栈帧”，每个栈帧对应一次方法调用。栈帧中存放了局部变量表（基本数据类型变量和对象引用）、操作数栈、方法出口等信息。当栈调用深度大于JVM所允许的范围，会抛出StackOverflowError的错误。

基本类型的内存分析:

数组的内存分析:

在使用数组时要注意防止产生：数组下标越界和空指针异常

递归算法：

public class Factorial {
    //递归的使用  计算1--5的和

    public static void main(String[] args) {
        int num = 5;
        int s = sum(500);
        System.out.println(s);
    }
	//方法的 声明  int/void 为方法的 返回值类型  如果方法不返回任何结果 则为void
	// sum 为方法 的 名称 只需要遵循小驼峰命名法的标识符都可以
	// (int num) 方法的参数  需要传递给方法的数据   
	// 一个程序的 入口 为main方法  所以其他方法要执行  必须在main方法中明确的调用
	// 方法的调用  通过方法名调用  同时需要根据方法的声明 传入方法所需的参数
	    
    public static int sum(int num) {
        if(num == 1){
           return   1;
        }else{
           return num + sum(--num);
        }
    }
}

• 阶乘

public class Factroial_1 {
    // 求一个数的阶乘
    public static void main(String[] args) {
        long result = cheng(10);
        System.out.println(result);
    }
    public static  long  cheng(int num){
        if(num == 1){
           return  1;//此处就是递归算法的出口
        }else{
            return  num * cheng(--num);//递归
        }
    }
}

常见的排序算法：

 1. 选择排序：
	  直接选择排序、 堆排序
 2. 交换排序
	  冒泡排序、 快速排序
 3.插入排序
	  直接插入排序、 折半插入排序、 Shell排序
 4.归并排序
 5.桶式排序
 6.基数排序

输入（ Input）	有0个或多个输入数据，这些输入必须有清楚的描述和定义
输出（ Output）	至少有1个或多个输出结果，不可以没有输出结果
有穷性（有限性， Finiteness）	算法在有限的步骤之后会自动结束而不会无限循环，并且每一个步骤可以在可接受的时间内完成
确定性（明确性， Definiteness）	算法中的每一步都有确定的含义，不会出现二义性
可行性（有效性，Effectiveness）	算法的每一步都是清楚且可行的，能让用户用纸笔计算而求出答案

算法讲解：https://visualgo.net/zh/sorting

冒泡排序：

原理：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {58,63,35,39,27,32,98,5,68};
        for(int x = arr.length - 1 ; x >= 0 ;x--){
            for(int i = 0 ; i < x ; i++){
                if(arr[i] > arr[i + 1]){// 元素两两比较  如果前者大于后者 则交换两个元素的 位置
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1 ] = temp;
                }
            }
        }
        // 进行数组的遍历
        for (int j  : arr){
            System.out.println(j);
        }
    }
}

快速排序：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {58,63,35,39,27,32,98,5,68};
        quick(arr);
        for(int x : arr){
            System.out.println(x);
        }
    }
    //快速排序的入口  该方法针对 数组排序 所以需要你传递给该方法一个数组
    public static void  quick(int[] arr){
        if(arr  == null || arr.length ==0 || arr.length == 1){
            return;
        }else{
            sort(arr,0,arr.length -1);
        }

    }
    // 快速排序的核心算法
    public static void sort(int[] arr,int left,int right){
        int len  = arr.length;
        if(left > right){
            return;
        }
        int base = arr[left];
        int i = left;
        int j = right;
        while(i != j ){
            // 从左开始  依次使用左边的元素和基准元素进行比较 直到找到比基准元素大的元素
            while(arr[i] < base && i < j){
                i++;
            }
            // 从右边开始  依次使用右边的元素和基准元素进行比较 直到找到比基准元素小的 元素
            while(arr[j] > base && i < j){
                j--;
            }
            if(i < j ){
                int temp = arr[i];
                arr[i]= arr[j];
                arr[j] = temp;
            }
        }
        sort(arr,left,i -1);
        sort(arr,i + 1 , right);

    }