Java基础6

---

Java学习目录

概述

多个相同类型数据按照一定顺序排列的集合，并使用一个名字命名，并通过编号的方式进行统一管理。

1、概念
数组名
元素
角标、下标、索引
2、特点：
(1) 有序排列
(2) 数组属于引用数据类型变量。数组的元素既可以是基本数据类型，也可以是引用数据类型。
(3) 创建的数组对象内存中的空间是连续的
(4) 数组的长度确定后不可修改
3、分类
(1) 按照维数：一维、二维数组…
(2) 按照数组的元素类型：基本数据类型元素的数组、引用数据类型元素的数组

一维数组的使用

(1) 一维数组的声明和初始化
    int[] ids;  // 声明
    ids = new int[]{1001,1002,1003,1004};  //  静态初始化（数组的初始化和数组元素的赋值操作同时进行）
    int[] ids = {1001,1002,1003,1004};
    String[] names = new String[5]; // 动态初始化（数组的初始化和数组元素的赋值操作分开进行）
(2) 如何调用数组的指定位置元素
    （通过角标方式调用；从0开始，到数组长度减1结束）
    names[0] = "Aaa";  // charAt(0)：可以获取到'A'
    names[1] = "bbb";
    names[2] = "ccc";
    names[3] = "ddd";
    names[4] = "ccc";
(3) 如何获取数组的长度
    （属性：length）
    System.out.println(ids.length);
    System.out.println(names.length);
(4) 如何遍历数组
    for(int i = 0; i < names.length; i++){
            System.out.println(names[i]); }
(5) 数组元素的默认初始化值
    ① 数组元素为整型：默认初始化值均为0；
    ② 数组元素为浮点型：默认初始化值均为0.0
    ③ 数组元素为char型：默认初始化值均为0（不是'0'）
    ④ 数组元素为boolean型：默认初始化值均为false
    ⑤ 数组元素为引用数据类型：null
(6) 数组的内存解析
    栈（stark）：存放局部变量
    堆（heap）：new出来的结构（对象、数组）
    方法区：包括常量池、静态域

多维数组的使用

(1) 二维数组的声明和初始化
    int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}}; // 静态初始化
   String[][] arr2 = new String[3][2]; // 动态初始化
   String[][] arr3 = new String[3][]; 
   int arr4[][] = new int[][]{{1,2,3},{4,5},{6,7,8}};
   int[] arr5[] = new int[][]{{1,2,3},{4,5},{6,7,8}};
   int[] arr6[] = {{1,2,3},{4,5},{6,7,8}};
(2) 如何调用数组的指定位置元素
    System.out.println(arr1[0][1]);
(3) 如何获取数组的长度
    System.out.println(arr4.length);
    System.out.println(arr4[0].length);
(4) 如何遍历数组
    for(int i = 0; i < arr4.length; i++){
        for(int j = 0;j < arr4[i].length; j++){
            System.out.print(arr4[i][j] + " ");
        }    }
(5) 二维数组元素的默认初始化值
（二维数组分为外层数组的元素和内层数组的元素）
初始化方式为：int[][] arr = new int[4][3];
    外层元素初始化值为：地址值
    内层元素初始化值为：与一维数组初始化情况相同
初始化方式为：double[][] arr3 = new double[4][]；
    外层数组默认初始化值为：null
    内层元素的初始化值为：不能调用，否则报错
    
(6) 二维数组的内存解析

数组中涉及到的常见算法

数组元素的赋值

(1) 回形数
(2) 杨辉三角

数值型数组元素的操作

求数值型数组中元素的最大值、最小值、平均数、总和等

数组的复制、反转、查找（线性查找、二分查找）

(1) 数组的复制

array2 = new int[array1.length];
for(int i = 0;i < array2.length; i++){
    if( i % 2 == 0){
        array2[i] = arry1[i] ;    }    }

(2) 数组的反转

方法一：
for (int i = 0;i < arr.length / 2; i++){
    String temp = arr[i];
    arr[i] = arr[arr.length - i - 1];
    arr[arr.length - i - 1] = temp;  }
方法二：
 for (int i = 0, j = arr.length-1; i < j; i++, j--){
     String temp = arr[i];  
     arr[i] = arr[j];
     arr[j] = temp;  }

(3) 数组的查找（或搜索）
① 线性查找

for (int i = 0; i < arr.length; i++){
    if(dest.equals(arr[i])){
        System.out.println("find" + i );
        break;    }  }

② 二分法查找
前提：所查找的数组必须有序

 int[] arr2 = new int[]{-98,2,66,83,100};
 int dest1 = 2;
 int head = 0; // 初始的首索引
 int end = arr2.length - 1; //初始的末索引
 boolean isFlag1 = true;
 while(head <= end){
     int middle = (head +end) / 2;
     if (dest1 == arr2[middle]{
         System.out.println("find" + middel);
         isFlag1 = false;
         break;  }
     else if( arr2[middle] > dest1){
         end = middle - 1;  }
     else{ // arr2[middle] < dest1
         head = middle + 1;  }
 }

数组元素的排序

用时间复杂度、空间复杂度和稳定性衡量算法优劣。
分类：内部排序、外部排序
(1) 冒泡排序

        // 冒泡排序
        for (int  i = 0; i < arr.length - 1; i++){
            for (int j = 0; j < arr.length - 1 - i; j++){
                if(arr[j] > arr[j+1]{ 
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;  }  }  }

(2) 快速排序
时间复杂度为：O(nlog(n))

private static void subSort(int[] data, int start, int end){
    if (start < end){
        int base = data[start];
        int low = start;
        int high = end +1;
        while(true){
            while(low < end && data[++low] - base <= 0)
            ;
            while(high > start && data[--high] - base >= 0)
            ;
            if (low < high){
                swap(data,low,high);  }
            else{
                break;  }  }
        swap(data,start,high);
        subSort(data,start,high - 1); // 递归调用
        subSort(data,high + 1,end);  }  }

(3) 排序算法的横向对比

数组工具类的使用——Arrays

java.util.Arrays

boolean equals(int[] a, int[] b)    //判断两个数组是否相等
String toString(int[] a)  // 输出数组信息
void fill(int[] a,int val)  // 将指定值填充到数组之中
void sort(int[] a)  // 对数组进行排序
int binarySearch(int[] a, int key)  // 对排序后的数组进行二分法检索指定的值