Java基础 -----数组、数组中的常见的算法、Arrays，Math工具类的使用

1、数组的定义与特点

定义

• 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

特点

• 数组属于引用类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。
• 创建数组对象会在内存中开辟一整块连续的空间；
• 数组的长度一旦确定，就不能修改;
• 数组是有序排列的。（按照索引位置排序)

分类

按照维度分：

• 一维数组
• 二维数组
• …
  按照数据类型分：
• 基本数据类型元素的数组
• 引用数据类型元素的数组

2、数组的初始化、赋值、遍历

        //数组的初始化
        //静态初始化:数组的初始化和数组元素的赋值操作同时进行
        int[] arr1 = new int[]{1, 2, 3, 4, 5};
        //动态初始化：数组的初始化和数组元素的赋值操作分开进行
        String[] arr2 = new String[5];

        //数组的赋值
        //方式1：执行静态初始化赋值操作
        //方式2：如下赋值操作： 
        //将arr2数组索引位置为1，3的位置赋上对应的值（起始索引位置为0）
        arr2[1] = "Tom";
        arr2[3] = "Jack";

        //数组的遍历
        //方式1：
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
        //方式2：
        for (int i : arr1) {
            System.out.println(i);
        }

数组的默认初始值

• 整型 ： 0
• 浮点型： 0.0
• char型： 0（非 ‘ 0 ’）
• boolean型： false
• 引用数据类型：null

3、一维数组的内存解析

int[] arr = new int[]{1,2,3};
String[] arr1 = new String[4];
arr1[1] = “刘德华”;
arr1[2] = “张学友”;
arr1 = new String[3];
System.out.println(arr1[1]);//null

4、二维数组的内存解析

int[][] arr1 = new int[4][];
arr1[1] = new int[]{1,2,3};
arr1[2] = new int[4];
arr1[2][1] = 30;

5、数组的常见算法

5.1、数组的复制

 //数组的复制
        int[] arr =new int[]{1,2,3,4,5};
        int[] array=new int[5];

        for(int i=0;i<arr.length;i++){
            array[i]=arr[i];
            System.out.println(array[i]);
        }

5.2、数组的反转

//数组的反转
        int[] arr =new int[]{1,2,3,4,5};
        int tem;

        for(int i=0;i< arr.length/2;i++){
            tem=arr[i];
            arr[i]=arr[arr.length-i-1];
            arr[arr.length-i-1]=tem;
            
        }

        for(int i=0;i<arr.length;i++) {
            System.out.println(arr[i]);
        }

5.3、数组的查找

5.3.1、线性查找

  //线性查找
        String[] arr=new String[]{"Tom","Jack","James","Curry"};

        for(int i=0 ; i<arr.length ; i++){
            if("Tom1".equals(arr[i])){
                System.out.println("索引位置为"+i);
                return;
            }

        }
        System.out.println("未找到该元素");

5.3.2、二分查找

int[] arr=new int[]{15,15,24,44,121,144,155,1111};

        int high=arr.length-1,low=0,mid;
        int key=11;//flag为要查找的元素
        boolean flag=true;


        while(high>=low){
            mid=(high+low)/2;
            if(arr[mid]==key){
                System.out.println("元素索引位置为："+mid);
                flag=false;
                break;

            }else if(arr[mid]>key){
                high=mid-1;
            }else
                low=mid+1;
        }

        if(flag){
            System.out.println("未找到该元素");
        }

5.4、数组的排序

5.4.1、排序算法的衡量标准

衡量排序算法的优劣：

1. 时间复杂度：分析关键字的比较次数和记录的移动次数
2. 空间复杂度：分析排序算法中需要多少辅助内存
3. 稳定性：若两个记录 A 和 B 的关键字值相等，但排序后 A、B 的先后次序保持不变，则称这种排序算法是稳定的。

5.4.2、排序算法的划分

排序算法分为以下两大类：

• 内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
• 外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

内部排序详细分位以下几类：

• 选择排序
  • 直接选择排序
  • 堆排序
• 交换排序
  • 冒泡排序
  • 快速排序
• 插入排序
  • 直接插入排序
  • 折半插入排序
  • Shell 排序
• 归并排序
• 桶式排序
• 基数排序

5.4.3、算法的五大特征

5.4.2、冒泡排序

//冒泡排序
        int[] arr=new int[]{15,55,41,1,5,65,44,15,45};
        int tem;

        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    tem=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tem;
                }
            }
        }

        for(int i=0;i< arr.length;i++){
            System.out.println(arr[i]);
        }

5.4.3、快速排序

快排思想：

先在数组中挑出一个作为“ 基准 ”（一般是第一个数）,然后把比基准大的数都放在它的右边，比基准小的数都放在左边，这样就划分出左右两块区域，再在这两块区域中分别使用上述方法，最终得到一个有序序列

public class QuickcSort {
    public static void main(String[] args) {
        int[] arr = {9, -16, 30, 23, -30, -49, 25, 21, 30};

        new QuickcSort().Quick(arr, 0, 8);

        for(int i:arr){
            System.out.println(i);
        }
    }

    public void Quick(int[] arr, int left, int right) {

        if(arr ==null || arr.length==0)
            return;
        if(left>right)
            return;

        int l = left;  //左指针
        int r = right;  //右指针
        int key = arr[left];

        while (l != r) {

            while (arr[l] <= key && l < r) {
                l++;
            }
            while (arr[r] >= key && l < r) {
                r--;
            }

            if (l < r) {
                int tem = arr[l];
                arr[l] = arr[r];
                arr[r] = tem;
            }

        }

        arr[left] = arr[l];
        arr[l] = key;

        Quick(arr, l + 1, right);  //操作key右边的数
        Quick(arr, left, r - 1);   //操作key左边的数


    }
}

6、排序算法的性能对比

• 从平均时间而言：快速排序最佳。但在最坏情况下时间性能不如堆排序和归并排序。
• 从算法简单性看：由于直接选择排序、直接插入排序和冒泡排序的算法比较简单，将其认为是简单算法。对于Shell排序、堆排序、快速排序和归并排序算法，其算法比较复杂，认为是复杂排序。
• 从稳定性看：直接插入排序、冒泡排序和归并排序是稳定的；而直接选择排序、快速排序、Shell排序和堆排序是不稳定排序。

7、Arrays工具类的使用

• fill（）是将数组中所有元素的值都更改为val。

8、Math工具类的使用

name	use
double Random()	随机生成一个[ 0 ,1 ]之间的小数
double sqrt(double num)	返回num的根号数值
double cbrt(double num)	返回num的立方根数值
double pow( double a , double b)	返回a的b次方
double max（double a, double b）	返回a，b之间较大那个
double min (double a , double b)	返回a，b之间较小那个
double abs（double a）	返回a的绝对值

随机生成一个 [ m , n ] 之间的整数

int num= (int)(Math.Random()*(n-m+1)+m);