1. 数组

1.1 定义

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

1.2 分类

类型：基本类型数组  引用类型数组（对象数组）
维度：一维、二维、三维、多维

1.3特点

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

优缺点

数组的优缺点：

优点：
	1. 可以存储多个同类型元素
	2. 存储地址连续
缺点：
	1. 初始化之后，长度不可变
	2. 只能存储同种元素
	3. 数组存储数据有限

1.4声明

public class JavaSe {
    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]);
        
    }
}

1.5 元素的值

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

// 为数组中的元素赋值；
        arr1[0] = 10;
        arr1[1] = 20;
        arr1[2] = 30;
        arr1[3] = 40;
        arr1[4] = 50;
        System.out.print(arr1[0] + ";");
        System.out.print(arr1[1] + ";");
        System.out.print(arr1[2] + ";");
        System.out.print(arr1[3] + ";");
        System.out.println(arr1[4]);

1.6 数组的静态初始化

// 数组的静态初始化1，在数组声明的同时，就初始化了数组
        int[] arr2 = {10,20,30,40,50};
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        // 数组的静态初始化2
        int[] arr3 = new int[]{21,11,31,41,51};
        System.out.println(arr3[2]);
        System.out.println(arr3[3]);
        System.out.println(arr3[4]);

1.7 使用循环来操控数组

// 数组的循环赋值
        for (int i = 0;i < 5;i++){
            arr3[i] = i + 50;
        }
        // 数组的遍历
        for (int i = 0;i < 5;i++){
            System.out.println(arr3[i]);
        }

1.8 获取数组的长度

// 获取数组的长度  使用数组的length属性来获取
        System.out.println(arr1.length);
        System.out.println(arr2.length);
        System.out.println(arr3.length);
        
        for (int i =0 ; i < arr3.length ; i++){
            System.out.println(arr3[i]);
        }

1.9 数组的默认值

day_06 数组、递归1. 数组2. 算法

byte[] bytes = new byte[10];
        for (int i = 0;i < bytes.length;i++){
            System.out.println(bytes[i]);
        }
        System.out.println("==============================");
        char[] chars = new char[5];
        for (int i = 0;i < chars.length;i++){
            System.out.println(chars[i]);
        }
        System.out.println("==============================");
        float[] floats = new float[5];
        for (int i = 0;i < floats.length;i++){
            System.out.println(floats[i]);
        }
        System.out.println("==============================");
        boolean[] booleans = new boolean[5];
        for (int i = 0;i < booleans.length;i++){
            System.out.println(booleans[i]);
        }

1.10 jvm的内存

day_06 数组、递归1. 数组2. 算法

1.10.1 内存概述

我们编写的程序存放在硬盘中，在硬盘中不会运行，需要放进内存中才能运行，运行完毕后会清空内存

1.10.2 java中的内存分配

目前我们只需要记住两个内存，栈内存和堆内存

1.10.3 基本类型的内存分析

day_06 数组、递归1. 数组2. 算法

数组的内存分析（堆内存）

day_06 数组、递归1. 数组2. 算法

1.11 数组使用中的两个问题

1. 在进行数组元素获取时，数组下标越界
解决这类问题，关键在于获取数组元素时采用数组的length属性

day_06 数组、递归1. 数组2. 算法

2. 空指针异常；
这种问题产生原因为数组类型的变量为指向任何对象；
解决：让该变量指向一个明确的对象即可。

public static void main(String[] args) {

    int[] arr3 = new int[]{21,11,31,41,51};
    arr3 = null;
    System.out.println(arr3[2]);
    System.out.println(arr3[3]);
    System.out.println(arr3[4]);
   // System.out.println(arr3[5]);
    System.out.println("--------------------------");
}

day_06 数组、递归1. 数组2. 算法

// 解决方法;
public static void main (String[] args){
	int[] arr3 = new int[] {21,11,31,41,51};
	int[]  arr4 =null;
	arr4 = arr3;
        System.out.println(arr4[2]);
        System.out.println(arr4[3]);
        System.out.println(arr4[4]);
       // System.out.println(arr3[5]);
        System.out.println("--------------------------");
    }

}

1.12 数组的常见操作

数组的遍历

public static void main(String[] args) {
        int[] arr = new int[]{32,12,41,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 static void main(String[] args) {
        int[] arr1 = {54,95,65,12,48,65,21};
        // 将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[i] = arr1[j];
        }
        for (int j : arr3){
            System.out.println(j);
        }
    }

获取数组中的最值问题

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

    }

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

    }

作业：查找数组中最小的元素；

// 查找最小元素
int [] arr = new int[]{65,89,69,68,32,57};
int minEle;
minEle = arr[0];
	for (int i = 1 ; i < arr.length ; i++){
    	if (minEle > arr[i]){
        minEle = arr[i];
    }
}
System.out.println(minEle);

2. 算法

2.1 递归

递归算法计算1–5的和

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

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

    public static int sum(int num){
        if (num == 1){
            return 1;	// sum方法的出口
        }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);//递归
        }

    }
}

2.2 排序算法

1.常见排序算法

day_06 数组、递归1. 数组2. 算法

动画展示算法: https://visualgo.net/zh/sorting.

2.冒泡排序运作过程

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 i = 0 ; i < arr.length -2 ; i++){
            if(arr[i] > arr[i + 1]){// 元素两两比较  如果前者大于后者 则交换两个元素的 位置
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1 ] = temp;
            }
        }
        for(int i = 0 ; i < arr.length -3 ; i++){
            if(arr[i] > arr[i + 1]){// 元素两两比较  如果前者大于后者 则交换两个元素的 位置
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1 ] = temp;
            }
        }
        for(int i = 0 ; i < arr.length -4 ; 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);
        }
    }
}

3.快速排序

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,0,i -1);
        sort(arr,i + 1 , right);

    }
}

day_06 数组、递归1. 数组2. 算法

1. 数组

1.1 定义

1.2 分类

1.3特点

优缺点

1.4声明

1.5 元素的值

1.6 数组的静态初始化

1.7 使用循环来操控数组

1.8 获取数组的长度

1.9 数组的默认值

1.10 jvm的内存

1.11 数组使用中的两个问题

1.12 数组的常见操作

2. 算法

2.1 递归

2.2 排序算法

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method