数组

• 数组的概述

• 一维数组

• 二维数组

• 数组中常用的算法

• Arrays工具类的使用

• 数组总结案例

1　　数组的概述

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

• 数组常见的概念：

  数组名

  下标或者索引

  元素

  角标，下标，索引

  数组的长度：元素的个数

• 数组本身是引用数据类型，数组中可以是任何数据类型，包括基本数据类型和引用数据类型

• 创建数组对象会在内存中开辟一整块连续的空间，而数组名中应用的是这块连续空间的首地址

• 数组长度一旦确定，就不能修改

• 可以直接通过下标()或索引的方式调用指定位置的元素

• 数组的分类：

  按照维度：一维数组，二维数组......

  按照元素的类型分：基本数据类型元素的数组，应用数据类型元素的数组(即对象数组)

2　　一维数组

1.数组的声明：

　　静态：

　　　数据元素类型 [] 数组名 = {元素}；

　　<!--数组的初始化和数组元素的赋值操作同时进行-->

　　动态：数据元素类型 [] 数组名 = new 数据元素类型 [元素]；

　　<!--数组的初始化和数组元素的赋值操作分开进行-->

2.数组的赋值和调用

　　<!--数组的下标都是从0开始的到数组的长度-1结束-->

　　<!--除了跟数据库表打交道的时候是从1开始的-->

　　数组名 [下标] = 值；

3.遍历数组

 

public class ArrayTest {
    public static void main(String[] args) {
        int [] id = {1,2,6,8};
        for (int i = 0; i < id.length; i++) {
            System.out.println(id[i]);
        }
    }
}

4.数组元素的默认初始化值

　　数组元素是整型：0；

　　数组元素是浮点型：0.0；

　　数组元素是char类型：0或'u0000'

　　数组元素是boolean类型：false

　　数组元素是引用数据类型：null;

　　局部变量放在栈内，new对象在堆中

3-2-1 小案例

package 数组;

import java.util.Scanner;

/*
 * 2. 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
        成绩>=最高分-10    等级为’A’   
        成绩>=最高分-20    等级为’B’
        成绩>=最高分-30    等级为’C’   
        其余                               等级为’D’
        
        提示：先读入学生人数，根据人数创建int数组，存放学生成绩。

 * 
 */
public class ArrayDemo2 {
    public static void main(String[] args) {
        //1.使用Scanner，读取学生个数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生人数：");
        int number = scanner.nextInt();
        
        //2.创建数组，存储学生成绩：动态初始化
        int[] scores = new int[number];
        //3.给数组中的元素赋值
        System.out.println("请输入" + number + "个学生成绩：");
        int maxScore = 0;
        for(int i = 0;i < scores.length;i++){
            scores[i] = scanner.nextInt();
            //4.获取数组中的元素的最大值:最高分
            if(maxScore < scores[i]){
                maxScore = scores[i];
            }
        }
        //5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
        char level;
        for(int i = 0;i < scores.length;i++){
            if(maxScore - scores[i] <= 10){
                level = 'A';
            }else if(maxScore - scores[i] <= 20){
                level = 'B';
            }else if(maxScore - scores[i] <= 30){
                level = 'C';
            }else{
                level = 'D';
            }
            
            System.out.println("student " + i + 
                    " score is " + scores[i] + ",grade is " + level);
        }
        
    }
}

3 　　多维数组的使用

<!--一维数组array1又作为另一个一维数组array2的元素而存在。其实从数组底层的运行机制来看，没有多维数组-->

1.声明和初始化

int [][] arr1 = new int [][] {{1,2,3},{4,5,6}};//静态
    String [][] arr2 = new String[3][2];//动态1
    String [][] arr3 = new String[3][];//动态2
    String [][] arr3 =[3][];//动态3 

2.调用数组的指定位置的元素

int a = arr1[0][1];
        System.out.println(a);

3.获取数组的长度

System.out.println(arr2.length);
        System.out.println(arr2[0].length);

4.遍历数组

for(int i = 0;i<arr1.length;i++) {
    for(int j = 0;j<arr1[i].length;j++) {
        System.out.print(arr1[i][j] + "  ");
            }
            System.out.println();
        }

5.数组元素的默认初始化值

 针对于初始化方式一：
 比如：int[][] arr = new int[4][3];
 *      外层元素的初始化值为：地址值
 *      内层元素的初始化值为：与一维数组初始化情况相同
 *      
 针对于初始化方式二：比如：int[][] arr = new int[4][];
 *       外层元素的初始化值为：null
 *      内层元素的初始化值为：不能调用，否则报错。

4　　 数组中涉及到的常见算法

1.数组元素的赋值

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

public static void main(String[] args) {
        int [] arr = new int[10];
        int temp = arr[0] ;
        for (int i = 0; i < arr.length; i++) {
            arr[i] =(int) (Math.random()*90 + 10);
            System.out.print(arr[i] + "  ");
        }
        System.out.println();
        //最大值
        for (int i = 1; i < arr.length; i++) {
            if(temp < arr[i]) {
                temp = arr[i];
            }
        }
        //最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if( min >  arr[i]) {
                min = arr[i]   ;
            }
        }
        //总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        //平均数
        int avg = sum / arr.length;
        System.out.println("最大值是：" + temp);
        System.out.println("最小值是：" + min);
        System.out.println("总和是：" + sum);
        System.out.println("平均数是：" + avg);
    }

3.数组的复制，翻转，查找(线性查找，二分法查找)

　　复制

public static void main(String[] args) {
        int [] arr2;
        int [] arr1 = {2,3,5,7,11,13,17,19};
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + "  ");
        }
        System.out.println();
        //赋值arr2变量等于arr1
        //数组的复制
        arr2 = new int [arr1.length];
        for (int i = 0; i < arr2.length; i++) {
            arr2[i] = arr1[i];
        }
        
        //输出arr1
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + "  ");
        }
        System.out.println();
    }

　　查找

//查找
        //线性查找
String [] arr1 = {"AA","BB","CC","DD","EE"};
        String dest = "dd";
        boolean falge = true;
        for (int i = 0; i < arr1.length; i++) {
            if(dest.equals(arr1[i])) {
                System.out.println("找到了，位置为：" + i);
                falge = false;
                break;
            }
        }
        if(falge) {
            System.out.println("很遗憾没找到");
        }
        
        //二分法查找(折半查找)
        //前提；所有查找的数组是有序的
        int [] arr2 = new int [] {-98,-34,2,34,54,66,79,105,333};
        int dest1 = -35;
        int head = 0;//初始索引
        int end = arr2.length-1;//结束索引
        boolean isFlage = true;
        while(head <= end) {
            int middle = (head + end)/2;//中间索引
            if(dest1 == arr2[middle]) {
                System.out.println("找到了，位置为：" + middle);
                isFlage = false;
                break;
            }else if(arr2[middle] > dest1) {
                end = middle - 1;
            }else {
                head = middle + 1;
            }
        }
        if(isFlage) {
            System.out.println("没找到原因");
        }
    }

4.数组元素的排序算法

　　衡量排序算法的优劣：

　　　　时间复杂度，空间复杂度，稳定性

　　排序算法的分类：

　　　　内部排序：

　　　　　　整个排序过程不需要借助于外部存储器(磁盘)，所有排序操作都是在内存中完成

　　　　外部排序

　　　　　　参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中必须借助外部存储器。外部排序最常见的是多路归并排序。可以认为外部排序是有多次内部排序组成。

　　冒泡排序：

　　　　通过对待排序序列从前往后，依次比较相邻元素的排序码，若发现逆序则交换，是排序码交到的元素逐渐从前向后移。

　　冒泡小案例：

public static void main(String[] args) {
        int [] arr = new int [] {10,89,52,36,8,44,22,18};
        //冒泡排序
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {//比较的次数
            for (int j = 0; j < arr.length-1 - i; j++) {//次数对应着i
                //比较两个相邻的数
                if(arr[j] > arr[j + 1]) {//从小到大
                    temp = arr[j];
                     arr[j] = arr[j + 1];
                     arr[j + 1] = temp;
                }
            }
        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

5  Arrays工具类的使用

　　　　Arrays是java.util.Arrays包下的，是操作数组的工具类

常用方法：

　　　　equals()：判断连个数组是否相等

int [] arr1 = new int [] {1,2,3,5};
        int [] arr2 = new int [] {1,3,2,5};
        boolean a = Arrays.equals(arr1, arr2);
        System.out.println(a);//false

　　　　toString()：输出数组信息

System.out.println(Arrays.toString(arr1));//[1, 2, 3, 5]

　　　　fill()：将指定值填充到数组之中

Arrays.fill(arr1, 10);
        System.out.println(Arrays.toString(arr1));//[10, 10, 10, 10]
        

　　　　sort()：对数组进行排序

Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));//[1, 2, 3, 5]

　　　　binarySearch()：堆排序后的数组进行二分法检索指定的值

int [] arr3 = new int [] {-98,-34,2,34,54,66,79,105,333};
        int b = Arrays.binarySearch(arr3, 34);
        if(b >= 0) {
            System.out.println(b);//显示的是出现位置的下标
        }else {
            System.out.println("没找到");
        }

6  数组使用中常见的异常

1.

数组下标越界：ArrayIndexOutOfBoundsException

2.

空指针异常：NullPointerException

7 数组总结小案例

package 数组;

import java.util.Arrays;

/*
 * 1.使用冒泡排序实现从小到大的排序
 * 2.反转上面的代码
 * 3.复制上述代码得到一个新的数组
 * 4.使用线性查找看一下22是否存在，如果存在返回下标否则提示
 * 5.常见的异常有哪些
 */
public class Array {
    public static void main(String[] args) {
        int [] arr = new int [] {34,5,22,-98,6,-76,0,-3};
        //1.冒泡排序
        int temp = 0;
        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] ) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
        System.out.println();
        //反转
        for (int i = 0; i < arr.length / 2; i++) {
            int temp1 = arr[i];
            arr[i] = arr[arr.length-1];
            arr[arr.length-1] = temp1;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
        System.out.println();
        //复制
        int [] arr2 = new int [arr.length];
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }
        System.out.println();
        
        //使用线性查找看一下22是否存在，如果存在返回下标否则提示
        
        int bina = Arrays.binarySearch(arr2, 22);
        if(bina >= 0 ) {
            System.out.println("找到了哦，位置为：" + bina);
        }else {
            System.out.println("抱歉没找到");
        }
    }
}