Java学习笔记——数组

小眼睛_i

已于 2022-03-17 17:32:30 修改

阅读量669

点赞数 1

文章标签： java 学习排序算法

于 2022-03-17 17:29:10 首次发布

本文链接：https://blog.csdn.net/weixin_45875493/article/details/123551603

版权

数组

一、数组的概念
二、数组的使用
三、数组中的经典的算法
四、二维数组的概念

一、数组的概念

数组本质上就是内存中申请的一段连续的空间，用于记录多个类型相同的数据，存储数据类型单一。

二、数组的使用

1.2.1 数组的定义

格式如下

数组类型[]  数组名称  = new 数据类型[数组长度];
int [] arr = new int[10]; //在内存空间中申请10个长度的空间

1.2.2 数组的初始化

格式如下

数据类型[]  数组名 = {数据1,数据2,数据3};
int[] arr = {1,2,3,4,5,6};

前两种的结合

int[] arr = new int[]{1,2,3,4,5,6};

1.2.3 数组成员的访问

数组名[下标] 数组的下标从0开始到数组长度-1结束

代码如下：

public class test01 {
    public static void main(String[] args) {
        //数组的定义
        int[] arr01 = new int[10];

        //Arrays.toString()会返回字符串类型的引用执行的数据
        System.out.println(Arrays.toString(arr01));

        int[] arr02 ={1,2,3,4,5,6,7,8,9,0};
        System.out.println(Arrays.toString(arr02));

        //数组的访问，通过下标找到指定位置，获取成员。
        int i = arr02[0];//访问数组中1的值
        System.out.println(i);

        int i1 = arr02[4];//访问数组中5的值
        System.out.println(i1);

        //使用数组的过程当中，注意下标越界问题
        int i2 = arr02[10];//数组中最后一个值，下标对应的是数组长度-1
        System.out.println(i2);

    }
}

运行结果
在这里插入图片描述

当数组定义完后，数据会根据数据类型不同的创建不同的默认值。

数据类型	默认值
byte、short、int、long	0
float、double	0.0
boolean	false
char	‘\u0000’ 空
String	null

1.2.4 数组的特性

1、数组中的成员占用的连续的内存空间
2、数组名实为该数组的首地址：l@14ae5a5
3、数组的成员访问时，需要注意下标越界问题
4、数组中的成员数据类型必须相同
5、Java中数组的长度一旦确定不能增减

1.2.5 数组的扩容以及拷贝

方法一

public class test02 {
    public static void main(String[] args) {
        int[] arr01 = {1,2,3,4,5,6,7,8,9,0};//数组的长度一旦定义，不能改变
			
		//方法一
        int[] arr02 = new int[arr01.length * 2];//定义新数组的长度
        //将原数组中的成员拷贝到新数组中
        for(int i = 0;i<arr01.length;i++){
            arr02[i] = arr01[i];
        }
        //遍历新数组的成员
        for (int j = 0;j < arr02.length;j++){
            System.out.print(arr02[j] + "\t");
        }
        System.out.println();
    }
}

方法二

//方法二
        //Arrays.copyOf(),用于数组复制，参数1：原数组，参数2：新数组
        int[] arr03 = Arrays.copyOf(arr01,20);
        for (int i = 0;i<arr03.length;i++){
            System.out.print(arr03[i]+"\t");
        }
        System.out.println();

方法三

        int[] arr04 = new int[arr01.length * 2];//创建新数组
        System.arraycopy(arr01,0,arr04,0,10);
        for (int i =0;i<arr04.length;i++){
            System.out.print(arr04[i]+"\t");
        }

运行结果
在这里插入图片描述
通过以上三个方法，可以看出最简化的代码是方法二。

三、数组中的经典的算法

1.3.1 数组的遍历

数组的遍历，正向，反向

代码如下

public class test03 {
    public static void main(String[] args) {
        //数组的初始化
        int[] score = {99,43,64,543,88};

        //通过循环对数组进行正向遍历
        for (int i = 0;i <= score.length-1;i++){
            System.out.println("score[" + i + "] = " + score[i] );

        }

        System.out.println("========================================");

        //通过循环对数组进行反向遍历
        for(int i = score.length -1; i >= 0;i--){
            System.out.println("score[" + i + "] = " + score[i]);
        }

    }
}

运行结果
在这里插入图片描述

1.3.2 数组中的最大值

代码如下

public class test04 {
    public static void main(String[] args) {
        //用生成来随机
        Random rd = new Random();
        //定义数组，长度为10
        int[] arr = new int[10];

        for(int j = 0;j < arr.length;j++){
            //随机生成1~100范围内
            arr[j] = rd.nextInt(100);
        }
        System.out.println("数组中的随机生成数字是:"+ Arrays.toString(arr));

        //求数组中的最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++){
            max = arr[i] > max ? arr[i] : max;
        }
        System.out.println("数组中的最大值是:"+max);
    }
}

运行结果
在这里插入图片描述

1.3.3 查找数组中指定的成员的值所在的位置

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

        System.out.print("请输入你想要查找的值:");
        //获取用户的键盘输入
        int num = new Scanner(System.in).nextInt();

        int resindex = 0;
        for(int i = 0;i<arr.length;i++){
            if(num == arr[i]){
                resindex = i;
                break;
            }
        }
        System.out.println(arr[resindex]+"在数组中出现的位置: ["+ resindex + "]");
    }
}

运行结果
在这里插入图片描述

1.3.4 数组逆序存储

public class test06 {
    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5,6,7,8,9};

        System.out.println("在数组逆序之前:"+ Arrays.toString(arr));

        for(int i = 0, t; i< arr.length / 2; i++){
            //分别取出第一个数与倒数第一个数，进行位置对调，直到内层调换完毕
            t = arr[i];//将第一个数组存储到临时变量中
            arr[i] = arr[arr.length - 1 - i];//后面的值存储到前面
            arr[arr.length - 1 - i] =t;
        }
        System.out.println("逆序之后:"+Arrays.toString(arr));

    }
}

在这里插入图片描述

1.3.5 数组成员排序（冒泡）

public class test07 {
    public static void main(String[] args) {
        Random rd = new Random();
        int arr[] = new int[10];

        for(int i = 0;i<arr.length;i++){
            arr[i] = rd.nextInt(100);
        }
        System.out.println("数组中的数据:"+ Arrays.toString(arr));

        //排序
        //外循环控制比较的次数
        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]){

                    arr[j] ^= arr[j + 1];
                    arr[j + 1] ^= arr[j];
                    arr[j] ^= arr[j + 1];
                }
            }
        }
        System.out.println("排序:"+Arrays.toString(arr));

    }
}

运行结果

在这里插入图片描述

1.3.6 向有序数组中插入数值后依然可以数组有排序

public class test08 {
    public static void main(String[] args) {
        int[] arr = new int[10];

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

        System.out.println("原数组内容"+ Arrays.toString(arr));

        //获取用户的键盘输入
        System.out.print("请输入你想要插入数值:");
        int num = new Scanner(System.in).nextInt();

        //找到应该插入数据的位置
        int place;
        for(place = 0; place < arr.length - 1;place++){
            if(num < arr[place]){
                break;
            }
        }

        for(int i = arr.length - 2;i >= place;i--){
            arr[i + 1] = arr[i];
        }
        arr[place] = num;
        System.out.print("插入后:" + Arrays.toString(arr));

    }
}

运行结果
在这里插入图片描述

四、二维数组的概念

二维数组本质上是由一维数组组成的数组，也就是说数组中的每一个成员都是一个数组。

1.4.1 数组的定义

格式如下

数据类型 [][] 数组名称 = new 数组类型 [行数][列数];
int [][] arr = new int [2][3]; //定义一个2行，3列的二维数组

1.4.2 数组的初始化

int [][] arr = {{1,2,3},{4,5,6}} //直接初始化二维数组

1.4.3 数组的遍历

代码如下

public class Demo03 {
    public static void main(String[] args) {
       int[][] arr = new int[2][4];

        //二维数组赋值方法
        arr[1][2] = 1;
        arr[0][1] = 1;

        //遍历数组
        for (int i = 0; i < 2; i++) {//外循环控制换行
            for (int j = 0; j < 4; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();//换行
        }

        System.out.println();

        //二维数组的初始化
        int [][] arr01={{1,2,3,},{4,5,6,}};

        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arr01[i][j]+"\t");
            }
            System.out.println();//换行
        }

    }
}

运行结果
![在这里插入图片描述](https://img-blog.csdnimg.cn/76de1cb0ed0f4497a4e34530b7658498.png

1.4.4 矩阵转置

public class test10 {
    public static void main(String[] args) {
        int [][] arr = {{1,2,3},{4,5,6},{7,8,9}};

        for (int i = 0; i < 3;i++){
            for (int j = 0; j < 3;j++){
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }


        System.out.println("-----------------");

        //转置算法
        for (int i = 0; i < 3;i++){
            for (int j = 0; j < 3; j++){
                if(j>i){
                    arr[i][j] ^= arr[j][i];
                    arr[j][i] ^= arr[i][j];
                    arr[i][j] ^= arr[j][i];
                }
            }
        }


        for (int i = 0;i < 3;i++){
            for (int j = 0; j < 3; j++){
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

运行结果
在这里插入图片描述

以上数组内容到这里了，Java之路很漫长，后续。。。

小眼睛_i

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
2
评论
Java学习笔记——数组

数组一、数组的概念二、数组的使用三、数组中的经典的算法四、二维数组的概念一、数组的概念数组本质上就是内存中申请的一段连续的空间，用于记录多个类型相同的数据，存储数据类型单一。二、数组的使用1.2.1 数组的定义格式如下数组类型[] 数组名称 = new 数据类型[数组长度];int [] arr = new int[10]; //在内存空间中申请10个长度的空间1.2.2 数组的初始化格式如下数据类型[] 数组名 = {数据1,数据2,数据3};int[] arr =
复制链接

扫一扫