java数组

最新推荐文章于 2024-08-01 15:05:06 发布

super 琪

最新推荐文章于 2024-08-01 15:05:06 发布

阅读量64

点赞数

分类专栏： java 文章标签： java 二分法排序

本文链接：https://blog.csdn.net/qq_44996346/article/details/114273402

版权

java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Java数组

1、数组的定义

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

2、数组的组成元素

数组名
下标（或索引）
- 从零开始的自然数
元素
数组的长度

3、数组的特点

数组是有序排列的
是引用数据类型的变量，可以存放任意类型的变量
创建数组对象是开辟了一块连续的空间，数组名引用的是这块空间中的首地址
数组的长度一旦定义之后就不可以修改

4、数组的分类

按照维数

一维数组、二维数组…多维数组

一维数组的使用

一维数组的声明和初始化

//元素类型[] 数组名 = new 元素类型[]{元素1、元素2、元素3.....元素n};

//静态初始化：数组初始化和赋值同时进行
int[] ids = new int[]{1001,1002,1003,.....n};

//动态初始化：数组初始化和赋值分开进行
int[] ids = new int[10];

如何调用数组的指定位置的元素

//通过下标或者索引的方式调用，下标（索引）从0开始，到数组的 长度-1
//格式：数组名[下标/索引]
int id = ids[3];

如何获取数组的长度
```
//借助于length属性
ids.length;
```

如何遍历数组

//使用循环
    for(int i = 0; i < ids.length; i++){
        System.out.println(ids[i]);
    }

数组元素的默认初始化值

整形类型，默认的初始化值为0
浮点类型，默认的初始化值为0.0
字符型，默认的初始化值为0（ascll码）
boolean型，默认的初始化值为false
String类型，默认的初始化值为null

数组内存的解析

二维数组的使用

一维数组的声明和初始化

//静态初始化
int[][] arr1 = new int[][]{{1,2},{2,3},{3,4}};

//动态初始化
int[][] arr2 = new int[3][3];

如何调用数组的指定位置的元素
```
arr1[1][1];
```

如何获取数组的长度

//借助于length属性
arr1.length;
//根据对象取长度

如何遍历数组

//使用循环
    for(int i = 0; i < arr1.length; i++){
        for(int j = 0; j < arr1[i].length; j++){
            System.out.println(arr1[i][j]);
        }
    }

数组元素的默认初始化值

外层元素：地址值
内层元素：
	1.数组类型[][] 数组名 = new 数据类型[外层数组长度][内层数组长度]
		整形类型，默认的初始化值为0
    	浮点类型，默认的初始化值为0.0
    	字符型，默认的初始化值为0（ascll码）
   	 	boolean型，默认的初始化值为false
    	String类型，默认的初始化值为null
    2.数组类型[][] 数组名 = new 数据类型[外层数组长度][]
    	初始值为null

数组内存的解析

按照数组元素的类型
- 基本数据元素类型的数组、引用数据元素类型的数组

5、数组的算法

数组元素的赋值（杨辉三角形、回行数等）

//打印杨辉三角形
import java.util.Scanner;

public class YangHuiTest {
    public static void main(String[] args) {
        int num = 0;  //初始杨辉三角形的行数
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入杨辉三角形的行数：");
        num = scanner.nextInt();

        int[][] yangHui = new int[num][];

        for (int i = 0; i < yangHui.length; i++) {
            yangHui[i] = new int[i + 1];  //给yangHui二维数组的每一项前数组初始数组大小
            yangHui[i][i] = yangHui[i][0] = 1;  //让每一行的第一个数和最后一个数为1
            if (i > 1) {
                for (int j = 1; j < yangHui[i].length - 1; j++) {
                    //j = 1 是因为第一个值必须为1
                    //yangHui[i].length-1这减一的目的是最后那个数必须是1
                    yangHui[i][j] = yangHui[i - 1][j] + yangHui[i - 1][j - 1];
                }
            }
        }

        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();
        }
    }
}

在这里插入图片描述

 																											**图1**

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

//Math.random()*(B-A+1)+A：求随机数的公式    [A,B]：随机数的范围
public class ArrayTest {
    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);
        }

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

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

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

        //求平均值
        int averageNum = sum / arr.length;
        System.out.println("平均值为：" + averageNum);
    }
}

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

//复制
public class ArrayCopy {
    public static void main(String[] args) {
        int[] arr1, arr2;
        arr1 = new int[]{1,5,6,7,2,4,11};
        for (int i = 0; i<arr1.length; i++){
            System.out.print("arr1的值："+arr1[i] + " ");
        }
        //将arr1复制给arr2
        arr2 = new int[arr1.length];
        for (int i =0; i< arr2.length; i++){
            arr2[i] = arr1[i];
        }
        System.out.println();
        for (int i =0; i< arr2.length;i++){
            System.out.print("arr2的值："+ arr2[i] + " ");
        }
    }
}

//反转
public class ArrayReversal {
    public static void main(String[] args) {
        int[] arr;
        arr = new int[]{1,5,6,7,2,4,11};
        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 temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        for (int i = 0; i< arr.length; i++){
            System.out.print("反转后："+ arr[i]);
        }
    }
}

//查找
/*
线性查找：一个一个往下找，从最前面到最后面，直到找到为止
*/
import java.util.Scanner;

public class ArrayLiner {
    public static void main(String[] args) {
        int arr[] = new int[]{-12,-10,-7,-3,0,12,45,67,89,99,114,123,125,126,245,267,375,486,489,568,589,688,699,799};
        int desc;  //定义一个查找的数值
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入你要查询的值：");
        desc = scanner.nextInt();
        boolean isFlag = true;
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < arr.length; i++) {
            if (desc == arr[i]) {
                System.out.println("找到了指定的元素，地址在数组的第" + (i + 1) + "个位置");
                isFlag = false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("很遗憾，没有找到指定的元素");
        }
        long endTime = System.currentTimeMillis();
        System.out.println("查询所花费的时间为："+ (endTime - startTime) + "毫秒（ms）");
    }
}


/*
使用前提：所要查找的数组中的数值必须是有序的
二分法查找：
*/
import java.util.Scanner;

public class ArrayDichotomy {
    public static void main(String[] args) {
        int arr[] = new int[]{-12,-10,-7,-3,0,12,45,67,89,99,114,123,125,126,245,267,375,486,489,568,589,688,699,799};
        int desc;  //定义一个查找的数值
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入你要查询的值：");
        desc = scanner.nextInt();
        int head = 0;//定义首索引
        int end = arr.length - 1;//定义尾索引
        boolean isFlag = true;
        long startTime = System.currentTimeMillis();
        while (head <= end){
            int middle = (head + end) / 2;  //得到数组中间的索引值
            if (desc == arr[middle]){
                System.out.println("找到了指定的元素，地址在数组的第" + (middle + 1) + "个位置");
                isFlag = false;
                break;
            }else if (desc > arr[middle]){
                head = middle + 1;
            }else {
                end = middle - 1;
            }
        }
        if (isFlag){
            System.out.println("很遗憾，没有找到指定的元素");
        }
        long endTime = System.currentTimeMillis();
        System.out.println("查询所花费的时间为："+ (endTime - startTime) + "毫秒（ms）");
    }
}

数组元素的排序算法

排序的目的是：快速查找
分类：内部排序 和 外部排序
	内部排序：在本身内存空间够的空间里面排序
		1.选择排序
        	直接选择排序，推排序
        2.交换排序
        	冒泡排序，快速排序
        3.插入排序
        	直接插入排序，折半插入排序，Shell排序
        4.归并排序
        5.桶式排序
        6.基数排序
	外部排序，本身内存不够，需要借助外部内存辅助排序

冒泡排序：比较相邻的数

public class ArrayBubble {
    public static void main(String[] args) {
        int arr[] = new int[]{2, 31, 25, 21, -54, -22, -42, 34, 56, 2};
        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;
                }
            }
        }
        for (int i = 0; i<arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
    }
}

快速排序
- 快速排序法相对于冒泡排序速度要更快，因为它的时间复杂度为O(nlog2n)，而冒泡的时间复杂度为O(n的平分)
- 快速排序跟二分法查询的原理有些类似
- 原理：定义三个指针变量，将三个指针变量指定相对应的值，指定一个参照值，一个最左边的值，一个最右边的值，左边的值小于参照值，右边的值大于参照值，然后两值互换位置，继续比较，到最后全部划分完毕，且比较后指针 < 前指针，再将前后指针所指的值于参照值相比，小于参照值的与参照值互换（以下面例子为案），比较结束，再划分成两个数组，继续比较和划分，直到排序完成
  
  图2

在这里插入图片描述

  																								**图3**

6、Arrays的工具类的使用

Arrays工具类里面有很多现成的数组操作的方法
常用的几个操作

图4

7、数组使用中的常见异常

数组角标越界的异常：ArrayIndexOUtOfBoundsExcetion
- 超过数组下标（角标）的范围就是角标越界异常
空指针异常：NullPointerException
- 所指向的值为null

super 琪

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java数组

Java数组1、数组的定义是多个相同类型的数据按一定的顺序排列的集合，并使用一个名字命名，并通过编号的方式对数据进行统一的管理和运用2、数组的组成元素数组名下标（或索引）从零开始的自然数元素数组的长度3、数组的特点数组是有序排列的是引用数据类型的变量，可以存放任意类型的变量创建数组对象是开辟了一块连续的空间，数组名引用的是这块空间中的首地址数组的长度一旦定义之后就不可以修改4、数组的分类按照维数一维数组、二维数组…多维数组一维数组的使用一
复制链接

扫一扫