第03章–数组

第03章--数组

3.1 数组的概述

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

数组的常见概念:

  • 数组名
  • 下标(索引)
  • 元素
  • 数组的长度

数组的特点:

  • 数组本身是引用数据类型,而数组中的元素可以是任何数据类型,包括基本数据类和引用数据类型
  • 创建数组对象会在内存中开辟一整块连续的空间,而数组名中引用的是这块连续空间的首地址
  • 数组的长度一旦确定,就不能修改
  • 我们可以用过下标方式调用指定位置的元素,速度很快

数组的分类:

  • 按照维数:
    • 一维数组
    • 二维数组
    • ......
  • 按照数组元素的数据类型
    • 基本数据类型的数组
    • 引用数据类型的数组(对象数组)

3.2 一维数组的使用

一维数组的使用:

  • 一维数组的声明和初始化
  • 如何调用数组的指定位置的元素
  • 如何获取数组的长度
  • 如何遍历数组
  • 数组元素的默认初始化值
  • 数组的内存解析
class ArrayTest{
    public static void main(String[] args){
        //1. 一维数组的声明和初始化
        int num;    //声明
        num = 10;   //初始化
        int id = 1001; //声明+初始化        

        int[] ids; //声明
        //静态初始化
        //(数组的初始化与数组元素的赋值同时进行)
        ids = new int[]{1001,1002,1003,1004}; 

        //动态初始化
        //先初始化,后对数组元素进行赋值
        String[] names  = new String[5];
        //不管是动态初始化还是静态初始化,一旦初始化完成,其长度就确定了。

        //错误的写法:
        int[] arr1 = new int[]; //没有指明长度
        int[5] arr2 = new int[]; //前面永远是一个空的方括号
        int[] arr3 = new[3]{1,2,3} //想法牛p,合二为一。

        //2. 通过下标的方式调用数组指定位置的元素
        names[0] = "Java";
        names[1] = "zhao";
        names[2] = "qian";
        names[3] = "Sun";
        names[4] = "li";
        // 加上就运行报错 names[5] = "li";

        //3. 如何获取数组的长度
        //length属性
        System.out.println(names.length);

        //4.如何遍历数组的元素
        System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);
        System.out.println(names[3]);
        System.out.println(names[4]);

        //利用for循环遍历
        for(int i = 0; i < names.length; i++){
            System.out.println(names[i]);
        }

        //5. 数组元素的默认初始化值
        int [] arr = new int[4];
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
        //输出0 0 0 0
        //boolean

        //6.数组的内存解析
        int[] arr5 = new int[]{1,2,3};
        String[] arr6 = new String[4];
        arr6[1] = "刘德华";
        arr6[2] = "张学友";
        arr6 = new String[3];

    }
}

数组元素初始化默认值

数组元素类型 元素默认初始值
byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0
char 0或者写为"\u0000"表现为空
boolean false
引用类型 null
// 6.数组的内存解析

package com.atguigu.contact;

public class ArrayTest {
    public static void main(String[] args){
        int[] arr5 = new int[]{1,2,3};
        String[] arr6 = new String[4];
        arr6[1] = "刘德华";
        arr6[2] = "张学友";
        arr6 = new String[3];
    }

}
小练习-学生成绩
import java.util.Scanner;

class ArrayTest{
    public static void main(String[] args) {
        //1. 使用Scanner读取学生个数
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入学生人数:");
        int number = scan.nextInt();

        //2. 根据学生个数创建数组(动态初始化)
        int[] scores = new int[number];

        //3. 给数组中的元素赋值
        System.out.println("请输入"+number+"个学生的成绩");
        for(int i = 0;i < scores.length; i++) {
            scores[i] = scan.nextInt();
        }

        //4. 找到最大值
        int maxScore = scores[0];
        for(int j = 1; j< scores.length;j++) {
            if(maxScore < scores[j]) {
                maxScore = scores[j];
            }
        }

        //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.3 多维数组的使用

3.3.1 二维数组的使用

/*
二维数组的使用
1.  二维数组的声明和初始化
2.  如何调用数组的指定位置的元素
3.  如何获取数组的长度
4.  如何遍历数组
5.  数组元素的默认初始化值
6.  数组的内存解析

*/
public class ArrayTest2{
    public static void main(String[] args){
        //1.二维数组的声明和初始化
        int[] arr1 = new int[]{1,2,3}; //一维数组的舒适化
        //二维数组的静态初始化
        int[][] arr2 = new int[][]{{1,2,3},{4,5},{6,7,8}}; 
        //二维数组的动态初始化
        String[][] arr3 = new String[3][2];
        String[][] arr4 = new String[3][]; //内层数组的长度可以不确定

        //错误的初始化
        String[][] arr3 = new String[][2];
        String[4][3] arr3 = new String[][];

        //2. 如何调用数组的指定位置的元素
        System.out.println(arr1[1][2]); //输出单个元素

        //3. 获取数组的长度
        System.out.println(arr2.length);

        //4. 遍历二维数字
        for(int i = 0;i< arr2.length;i++){
            for(int j=0;j<arr2[i].length;j++){
             System.out.print(arr2[i][j]); 

            }
            System.out.println();
        }

        //5. 数组元素的默认初始化值
        /*
        二维数组分为外层数组的元素,和内层数组的元素
        方式一:int[][] arr2 = new int[4][3];
        外层元素的初始化值:地址值
        内层元素的初始化值:与一维元素的初始化值相同

        方式二:double[][] arr3 = new double[4][];
        外层元素的初始化值:null
        内层元素的初始化值:报错

        class ArrayTest{
            public static void main(String[] args) {
                int[][] arr2 = new int[4][3];
                System.out.println(arr2[1]);   // 地址值
                System.out.println(arr2[1][0]);   // 0

                double[][] arr3 = new double[4][];
                System.out.println(arr3[1]); //null
                System.out.println(arr3[1][1]); //报错:空指针异常

            }
        }
        */

        //6. 数组的内存解析

    }
}
小练习1
package com.atguigu.exer;

public class ArrayExer {
    public static void main(String[] args) {
        int[][]  arr = new int[][] {{3,5,8},{12,9},{7,0,6,4}};

        int sum = 0;
        for(int i = 0; i < arr.length; i++) {
            for(int j = 0; j < arr[i].length;j++) {
                sum += arr[i][j];

            }
        }
        System.out.println(sum);
    }
}
小练习2-打印杨辉三角
public class YangHuiTest {
    public static void main(String[] args){
        //1.声明并初始化二维数组
        int[][] yangHui = new int[10][];
        //2.给数组的元素赋值
        for(int i = 0;i<yangHui.length;i++) {
            yangHui[i] = new int[i+1];
            //2.1 给每行的第一个元素和最后一个元素赋值
            yangHui[i][0] = 1;
            yangHui[i][i] = 1;
            //2.2 给每行的其他元素赋值
            if(i >1) {
                for(int j=1;j<(yangHui[i].length-1);j++) {
                    yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
                }
            }
        }

        //3.遍历二维数组
        for(int i = 0; i< yangHui.length;i++) {
            for(int j = 0;j<yangHui[i].length;j++) {
                System.out.print(yangHui[i][j] + "  ");
            }
            System.out.println();
        }
    }
}

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

  • 数组元素的赋值(杨辉三角、回形数等)
  • 求数值型数组中元素的最大值、最小值、平均数、总和
  • 数组的赋值、反转、查找(线性查找、二分法查找)
  • 数组元素的排序算法
小练习-1
/*
创建一个长度为6的int型数组
要求数组的元素的值在1-30之间
并且是随机赋值
同时要求元素的值不重复
*/

//方式2
package com.atguigu.exer;

public class caipiao{
    public static void main(String[] args){
        int[] arr = new int[6];
        for(int i = 0; i< arr.length; i++){
            arr[i] = (int)(Math.random()* 30)+ 1;

            boolean flag = false;
            while(true){
                for(int j = 0; j<i; j++){
                    if(arr[i] == arr[j]){
                        flag = true;
                        break;
                    }
                }
                if(flag){
                    arr[i] = (int)(Math.random() * 30) + 1;
                    flag = false;
                    continue;
                }
                break;
            }
        }
        for(int i = 0; i< arr.length ; i++){
            System.out.println(arr[i]);
        }
    }
}

//方式2
package com.atguigu.exer;

public class caipiao{
    public static void main(String[] args){
        int[] arr = new int[6];
        for(int i = 0; i< arr.length; i++){
            arr[i] = (int)(Math.random() * 30) + 1;

                for(int j = 0;j < i; j++){
                    if(arr[i] == arr[j]){
                        i--;
                        break;
                    }
                }
        }
        for(int i = 0; i< arr.length ; i++){
        System.out.println(arr[i]);
        }
    }
}
小练习-2 (回形数字方阵的实现)
/*
1   2   3   4 
12  13  14  5 
11  16  15  6 
10  9   8   7

*/

//方式1
class RectangleTest1 {

    public static void main(String[] args) {
        int n = 7;
        int[][] arr = new int[n][n];

        int count = 0; // 要显示的数据
        int maxX = n - 1; // x轴的最大下标
        int maxY = n - 1; // Y轴的最大下标
        int minX = 0; // x轴的最小下标
        int minY = 0; // Y轴的最小下标
        while (minX <= maxX) {
            for (int x = minX; x <= maxX; x++) {
                arr[minY][x] = ++count;
            }
            minY++;
            for (int y = minY; y <= maxY; y++) {
                arr[y][maxX] = ++count;
            }
            maxX--;
            for (int x = maxX; x >= minX; x--) {
                arr[maxY][x] = ++count;
            }
            maxY--;
            for (int y = maxY; y >= minY; y--) {
                arr[y][minX] = ++count;
            }
            minX++;
        }

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                String space = (arr[i][j] + "").length() == 1 ? "0" : "";
                System.out.print(space + arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

//方式2
class RectangleTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入一个数字");
        int len = scanner.nextInt();
        int[][] arr = new int[len][len];

        int s = len * len;
        /*
         * k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
         */
        int k = 1;
        int i = 0, j = 0;
        for (int m = 1; m <= s; m++) {
            if (k == 1) {
                if (j < len && arr[i][j] == 0) {
                    arr[i][j++] = m;
                } else {
                    k = 2;
                    i++;
                    j--;
                    m--;
                }
            } else if (k == 2) {
                if (i < len && arr[i][j] == 0) {
                    arr[i++][j] = m;
                } else {
                    k = 3;
                    i--;
                    j--;
                    m--;
                }
            } else if (k == 3) {
                if (j >= 0 && arr[i][j] == 0) {
                    arr[i][j--] = m;
                } else {
                    k = 4;
                    i--;
                    j++;
                    m--;
                }
            } else if (k == 4) {
                if (i >= 0 && arr[i][j] == 0) {
                    arr[i--][j] = m;
                } else {
                    k = 1;
                    i++;
                    j++;
                    m--;
                }
            }
        }

        // 遍历
        for (int m = 0; m < arr.length; m++) {
            for (int n = 0; n < arr[m].length; n++) {
                System.out.print(arr[m][n] + "\t");
            }
            System.out.println();
        }
    }
}
小练习3
/*
求数值型数组中元素的最大值、最小值、平均值、总和

定义一个int型的一维数组,包含10个元素
求数值型数组中元素的最大值、最小值、平均值、总和
要求所有的元素为两位数

*/

public class ArrayTest1{
    public static void main(String[] args){
        int[] arr = new int[10];
        //赋值
        for(int i = 0; i< arr.length; i++){
            arr[i] = (int)(Math.random() * (99-10 +1) + 10);
        }
        //最大值
        int maxValue = arr[0];
        for(int i  = 0; i< arr.length; i++){
            if(maxValue < arr[i]){
                maxValue = arr[i];
            }
        }
        System.out.println("最大值: " + maxValue);

        //最小值
        int minValue = arr[0];
        for(int i  = 0; i< arr.length; i++){
            if(minValue > arr[i]){
                minValue = arr[i];
            }
        }
        System.out.println("最小值: " + minValue);

        //总和
        int sum = 0;
        for(int i = 0 ; i < arr.length; i++){
            sum += arr[i];
        }
        System.out.println("总和为:" + sum);

        //平均数
        float aveValue = sum / arr.length;
        System.out.println("平均值为:" + aveValue);

    }
}
小练习4-数组的复制
/*
使用简单数组
(1)创建一个名为ArrayTest的类,在main()方法中声明array1和array2两个变量,他们是int[]类型的数组
(2)使用大括号{},把array1初始为8个素数 {2,3,5,7,11,13,17,19}
(3)显示array1的内容
(4)赋值array2变量等于array1,修改array2中的偶数索引元素,使其等于索引值,显示array2

思考:
array1和array2是什么关系
array1和array2地址指相同,都指向了堆空间中唯一的一个数组实体

如何实现真正意义上的数组的复制

*/

public class ArrayExer2{
    public static void main(String[] args){
        int[] array1, array2;
        array1 = new int[]{2,3,5,7,11,13,17,19};

        //显示array1的内容
        for(int i = 0; i< array1.length; i++){
            System.out.print(array1[i]+ " ");
        }
        System.out.println();

        //赋值array2变量等于array1

        //不能称作数组的复制
        array2 = array1;

        //真正意义的复制,有new才是创建了新空间
        array2 = new int[array1.length];
        for(int i = 0; i< array2.length; i++){
            array2[i] = array1[i];
        }

        //修改array2的偶索引的元素
        for(int i = 0; i< array2.length; i++){
            if(i%2 == 0){
                array2[i] = i;
            }
        }

        //显示array1的内容
        for(int i = 0; i< array1.length; i++){
            System.out.print(array1[i]+ " ");
        }
        System.out.println();

        //显示array2的内容
       for(int i = 0; i< array1.length; i++){
            System.out.print(array2[i]+ " ");
        }
        System.out.println();

    }
}

/*
输出结果:
2 3 5 7 11 13 17 19 
0 3 2 7 4 13 6 19 
0 3 2 7 4 13 6 19 

array1 和 array2有相同的地址
所以修改array2的时候,其实连同修改了array1

*/
小练习5-数组的复制
public class ArrayTest2{
    public static void main(String[] args){
        String[] arr1 = new String[]{"JJ","DD","GG","MM","AA","BB"};

        //数组的复制
        String[] arr2 = new String[arr1.length];
        for(int i = 0;i< arr1.length; i++){
            arr2[i] = arr1[i];
        }

        //数组的反转
        String[] arr3 = new String[arr1.length];
        for(int i = 0; i< arr1.length; i++){
            arr3[i] = arr1[arr1.length - i-1];
            System.out.print(arr3[i] + " ");
        }

       //数组的反转:方式1
        for(int i = 0; i< arr1.length/2; i++) {
            String temp = arr1[i];
            arr1[i] = arr1[arr1.length-i-1];
            arr1[arr1.length-i-1] = temp;   
        }

        //数组的反转:方式2
        for(int i = 0,j = arr1.length-1 ; i< j; i++,j--){
            String temp = arr1[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

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

        //查找(或者搜索)
        //线性查找:
        String dest = "BB";
        isFind  = false;
        for(int i = 0; i< arr1.length;i++){
            if(arr1[i].equals(dest)){
                System.out.println("找到了,在第"+(i+1)+"位");
                isFind = true;
            }
        }
        if(isFind == false){
            System.out.println("没有找到啊");
        }

        //二分法查找:必须是要有序的
        int[] arr6 = new int[]{-98,-23,2,4,6,10,20,35,100,345};

        int dest1 = 2;
        int head = 0; //初始的首索引值
        int end = arr2.length -1; //初始的末索引值

        while(head <= end){
            int middle = (head + end)/2;

            if(dest1 == arr6[middle]){
                System.out.println("找到了指定的元素,位置为:" + middle);
                break;
            }else if(arr6[middle] > dest1){
                end = middle -1;
            }else{
                head  = middle + 1;
            }

        }

    }
}
小练习6-数组排序

衡量排序算法的优劣

  • 时间复杂度:分析关键字的比较次数和记录的移动次数
  • 空间复杂度:分析排序算法中需要多少辅助内存
  • 稳定性:A=B,排序时A与B是否交换

算法的五大特性

  • 输入
  • 输出
  • 有穷性
  • 确定性
  • 可行性
//冒泡排序

public class BubbleSortTest{
    public static void main(String[] args){
        int[] arr = new int[]{32,4,5,62,4,6324,5,6234,745};

        //冒泡排序
        for(int i = 0; i< arr.length; 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;
                }
            }
        }
        //输出
        for(int i = 0; i< arr.length; i++){
            System.out.println(arr[i]);
        }

    }
}
//快速排序

package com.atguigu.array.sort;

/**
 * 快速排序
 * 通过一趟排序将待排序记录分割成独立的两部分,其中一部分记录的关键字均比另一部分关键字小,
 * 则分别对这两部分继续进行排序,直到整个序列有序。
 * @author shkstart
 * 2018-12-17
 */
public class QuickSort {
    private static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    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);
        }
    }
    public static void quickSort(int[] data){
        subSort(data,0,data.length-1);
    }

    public static void main(String[] args) {
        int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
        System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
        quickSort(data);
        System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
    }
}

3.5 Arrays工具类的使用

/*
java.util.Arrays
操作数组的工具类
定义了很多操作数组的方法
*/

package com.atguigu.exer;

import java.util.Arrays;

public class ArraysTest {
    public static void main(String[] args){
        // 1. boolean equals(int[] a, int[] b) 判断两个数组是否相等
        int[] arr1 = new int[]{1,2,3,4};
        int[] arr2 = new int[]{1,3,2,4};
        boolean isEqual = Arrays.equals(arr1, arr2);
        System.out.println(isEqual);       

        // 2. String toString(int[] a) 输出数组信息

        System.out.println(Arrays.toString(arr1));

        // 3. void fill(int[] a,int val) 将指定的值填充到数组之中
        Arrays.fill(arr1, 10);
        System.out.println(Arrays.toString(arr1));

        // 4. void sort(int[] a) 排序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));

        // 5. int binarySearch(int[] a,int key) 二分查找
        int[] arr3 = new int[] {-98,2,5,6,8,9,10,234,345,999};
        int index = Arrays.binarySearch(arr3, 10);
        System.out.println(index);     

    }  
}

3.6 数组使用过程中的常见异常

package com.atguigu.exer;

/*
数组中的常见异常
1. 数组角标越界异常:ArrayIndelOutOfBoundsExcetion
2. 空指针异常:NullPointerExection
*/

public class ArrayExectionTest{
    public static void main(String[] args){

        // 1.数组角标越界异常:ArrayIndelOutOfBoundsExcetion
        int[] arr = new int[]{1,2,3,4,5};
        for(int i = 0; i<= arr.length;i++){
            System.out.println(arr[i]);
        }

        // 2.空指针异常:NullPointerExection
        // 情况1
        int[] arr1 = new int[]{1,2,3};
        arr1 = null;
        System.out.println(arr1[0]);

        // 情况2
        int[][] arr2 = new int[4][];
        System.out.println(arr2[0]); //null
        System.out.println(arr2[0][0]); //空指针

        // 情况3
        String[] arr3 = new String[]{"AA","BB","CC"};
        arr3[0] = null;
        System.out.println(arr3[0].toString());
    }
}
暂无评论

发送评论 编辑评论


				
上一篇
下一篇