Java中的数组基本概念

最新推荐文章于 2022-11-14 10:15:03 发布
最新推荐文章于 2022-11-14 10:15:03 发布
阅读量1.1k 收藏 14
点赞数 8
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Paoababa/article/details/115308022
版权

Java中的数组基本概念

一、一维数组

1、定义：
是多个相同类型数据按照一档顺序排列的集合，并用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2、数组中有几个常见的概念：
（1）数组名
（2）索引
（3）元素
（4）数组长度

3、数组的特点
（1） 数组的排列是有序的
（2） 创建数组会在内存中开辟一整块连续的空间，数组应用这块连续空间的首地址
（3） 数组的长度一旦确定就不可修改
（4） 数组属于引用数据类型
（5） 数组元素既可为基本数据类型，也可以为引用数据类型

4、数组的分类
（1）通过维数来分类：一维数组、二维数组…（其实理论上来说没有多维数组，只是一维数组中的元素又为一维数组）
（2）按照数组元素类型：基本数据类型元素数组、引用数据类型元素数组

5、一位数组的使用
（1） 一维数组的声明和初始化

int[] ids;//一维数组的声明
//数组的初始化和数组元素的复制同时进行
ids = new int[] {1001, 1002, 1003, 1004};//静态初始化
//数组的初始化和数据元素分开进行
String[] names = new String[5];//动态初始化`

（2）调用数组指定位置的元素
可以通过索引调用

//数组的索引是从0开始的，到数组的长度-1结束
String[] names = new String[5];
names[0] = "乔桑纳";
names[1] = "乔瑟夫";
names[2] = "空条承太郎";
names[3] = "东方仗助";
names[4] = "乔鲁诺乔巴纳";

（3）获取数组的长度
需要用到一个重要的属性Array.length

int[] arr = new int[3];
System.out.println(arr.length);//输出结果为3

（4）遍历一维数组

String[] names = new String[5];
names[0] = "乔桑纳";
names[1] = "乔瑟夫";
names[2] = "空条承太郎";
names[3] = "东方仗助";
names[4] = "乔鲁诺乔巴纳";
for(int i = 0; i < names.length; i++){
	System.out.println(names[i]);
	/*
	输出结果为：
	乔桑纳
	乔瑟夫
	空条承太郎
	东方仗助
	乔鲁诺乔巴纳
	*/
}

（5）一维数组元素的默认初始化值
①整形数组元素的默认初始化值：0

②浮点型数组元素的默认初始化值：0.0

③ 字符型元素的默认初始化值：0或者是’\u0000’,而非‘0’（这个0的意思是对应的ASCII码为0的时候输出的值）

④布尔型数组元素的默认初始化值：false

⑤引用数据类型元素的默认初始化值：null而非字符串"null"

二、多维数组

1、定义与一维数组一样，但是可以理解为是由数组组成的数组
（概念特点以及分类和一维数组相同）

2、多维数组的使用
（1）多维数组的声明和初始化

//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7}};
//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];
//同样正确的写法
int[][] arr4 = {{1,2,3},{4,5},{6,7}};//类型推断

（2）多维数组调用指定位置的元素

int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7}};
String[][] arr2 = new String[3][2];
String[][] arr3 = new String[3][];
System.out.println(arr1[0][1]);//输出结果为：2
System.out.println(arr1[1][1]);//输出第2行第2列的元素
//错误的写法
System.out.println(arr3[1][0]);//会报异常：空指针。因为arr3的第2行第1列并未声明所以会报错
//给arr3的第2行数组给予4列元素
arr3[1] = new String[4];
//重新输出
System.out.println(arr3[1][0]);//输出结果为：null

（3）获取数组的长度
同样会用到上述一位数组的属性Array.length

int[][] arr4 = new int[][]{{1,2,3},{2,0},{4,5,6}};
System.out.println(arr4.length);//输出结果为：3
System.out.println(arr4[0].length);//输出结果为：3
System.out.println(arr4[1].length);//输出结果为：2

（4）遍历多维数组

int[][] arr4 = new int[][]{{1,2,3},{2,0},{4,5,6}};
for(int i = 0; i < arr4.length; i++){
	for(int j = 0; j < a[i].length; j++){
		System.out.print(arr4[i][j]);
	}
}
//输出结果为：1 2 3 2 0 4 5 6
//同理可得：n维数组遍历需要n个循环

（5）多维数组元素的默认初始化值
内层元素的默认初始化值等同与一维数组的元素默认初始化值

int[][] arr = new int[4][3];
System.out.println(arr[0]);//输出结果为：[I@15db9742(为一个地址值，存放的是这个第一行元素的地址值)
System.out.println([0][0]);//输出结果为：0
System.out.println(arr);//输出结果为：[[I@6d06db9c(存放的是arr的地址值)
double arr3[][] = new double[4][];
System.out.println(arr3[1])//输出结果为：null,因为arr3只初始化了行，列没有，然后数组是引用数据类型默认元素初始化值为null

三、数组的常见算法

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

/*
 * 杨辉三角
 * 使用二维数组打印一个10行的杨辉三角形
 *
 * 第一行有一个元素，第n行有n个元素
 * 每一行的第一个元素和最后一个元素都是1
 * 从第三行开始，对于非第一个元素和最后一个元素的元素，即
 * yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j]
 * */

package com.company;

public class Main {

    public static void main(String[] args) {
        //声明并初始化二维数组（动态初始化）
        int[][] yangHui = new int[10][];

        //给数组元素赋值
        for (int i = 0; i < yangHui.length; i++) {
            yangHui[i] = new int[i + 1];
            //给首末元素赋值
            yangHui[i][0] = 1;
            yangHui[i][i] = 1;
            //给每行的非首末元素赋值
            // 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];
            }
            // }

        }

        //遍历打印输出
        for (int[] ints : yangHui) {
            for (int j = 0; j < ints.length; j++) {
                System.out.print(ints[j] + "\t");
            }
            System.out.println();
        }

    }
}

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

/*
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，
 * 和值
 * 要求：所有随机数都是两位数
 * */

package com.company;

public class Main {

    public static void main(String[] args) {
        int[] arr1 = new int[10];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = (int) (Math.random() * (99 - 10 + 1) + 10);
        }
        //最大值
        int maxValue = arr1[0];
        for (int i = 1; i < arr1.length; i++) {
            if (maxValue < arr1[i]) {
                maxValue = arr1[i];
            }
        }
        System.out.println("最大值为：" + maxValue);
        //最小值
        int minValue = arr1[0];
        for (int i = 1; i < arr1.length; i++) {
            if (minValue > arr1[i]) {
                minValue = arr1[i];
            }
        }
        System.out.println("最小值为：" + minValue);
        //总和
        int sumValue = 0;
        for (int i = 0; i < arr1.length; i++) {
            sumValue += arr1[i];
        }
        System.out.println("总和为：" + sumValue);
        //平均值
        int avgValue = 0;
        avgValue = sumValue / arr1.length;
        System.out.println("平均值为：" + avgValue);
    }
}

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

package com.company;

public class ArrayAddressSpecification {

    public static void main(String[] args) {
        /*
        int[] array1, array2;
        array1 = new int[]{2, 3, 5, 7, 11, 13, 17, 19};
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
        //并不是数组的复制
        array2 = array1;
        for (int i = 2; i < array2.length; i++) {
            if (i % 2 == 0) {
                array2[i] = i;
            }
        }
        System.out.println();
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i]+"\t");
        }
        */

        //真正的实现复制
        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] + "\t");
        }
        //数组的复制
        array2 = new int[array1.length];//将array2的长度定义为和array1一样
        for (int i = 0; i < array2.length; i++) {
            array2[i] = array1[i];
        }
        for (int i = 2; i < array2.length; i++) {
            if (i % 2 == 0) {
                array2[i] = i;
            }
        }
        System.out.println();
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
    }
}
//array1的值被改变，是因为一开始只定义了一个数组，数组1和2共用一个数组
//赋值的时候只把1的地址赋给了2，所以2的的元素改变的时候其实是改变的1的元素


package com.company;

public class Main {

    public static void main(String[] args) {
        String[] arr = new String[]{"JJ", "DD", "MM", "BB", "GG", "AA"};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
        //数组的反转
        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; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}


/*
 * 线性查找，二分型查找
 * */

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        boolean isFlag = true;
        int[] arr = new int[]{1, 2, 3, 4, 5, 6};
        Scanner scanner = new Scanner(System.in);
        //线性查找
        System.out.println("请输入你要查找的数：");
        int dest = scanner.nextInt();
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == dest) {
                System.out.print("找到了指定的元素，位置为：" + i);
                isFlag = false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("很遗憾没有找到你想要的元素");
        }

        //二分法查找
        //前提：所要查找的数组必须有序
        int[] arr2 = new int[]{-98, -34, 2, 32, 54, 66, 79, 105, 210, 333};

        int dest1 = -34;
        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.print("找到了指定的元素，位置为：" + middle);
                isFlag1 = false;
                break;
            } else if (arr2[middle] > dest1) {
                end = middle - 1;
            } else {
                head = middle + 1;
            }
        }
        System.out.println("很抱歉，没有找到你想要的元素");
    }
}

4、数组元素的排序算法

package com.company;

public class Main {

    public static void main(String[] args) {
        int[] arr = new int[]{43, 32, 76, -98, 0, 64, 33, -21, 32, 99};
        //冒泡排序
        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.println(arr[i] + "\t");
        }


    }
}

四、Array工具类

详细可见jkd帮助文档
相对常见的有以下几种

package com.company;

import java.util.Arrays;

public class Main {

    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 isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals);//输出结果：false

        //【2】String toString (int[] a):输出数组信息
        System.out.println(Arrays.toString(arr1));//输出结果:[1,2,3,4]

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

        //【4】void sort(int[] a):对数组进行排序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));//输出结果:[1,2,3,4]

        //【5】int binarySearch(int[] a,int key):二分法查找
        int[] arr3 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
        int index = Arrays.binarySearch(arr3, 210);
        System.out.println(index);//输出结果:8(如果结果为负数则为没有找到)

（以上内容为观看尚硅谷视频所总结）

三桥.
关注
  • 8
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
什么是数组？认识 Java 中的数组
AlinaQ05的博客
05-15 1243
文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 数组是 JavaSE 中遇到的第一个引用类型，在数据结构中属于顺序表。学好数组就是学好数据结构的一个重要基础。 1. 数组是什么？ 如果我们需要两个数据就可以直接创建两个变量，如果需要多个数据，直接创建会很麻烦，这时候就会使用“批量生产”，而数组就是可以“批量”创建变量，需要注意的是在 Java 中数组是创建相同类型的变量。 2. 创建数组 2.1 基本语法（数组的声明和初始化
java数组概述
weixin_51755941的博客
03-02 824
目录 一.数组 二.数组的优缺点 一.数组 1.java语言中的数组是一种引用数据类型，不属于基本数据类型，数组的父类是Object。 2.数组实际上是一个容器，可以同时容纳多个元素（数组是一个数据的集合）字面意思：“一组数据” 3.数组当中可以储存“基本数据类型”的数据，也可以储存“引用数据类型”的数据 4.数组因为是引用类型，所以数组对象是堆内存当中（数组是存储在堆当中的）。 5.数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用地址” 6....
【Java|基础篇】全面解析数组,数组知识点汇总
云泽野の编程日记
11-14 940
Java数组超详细讲解文章目录 1.数组的概念 2.一维数组3.一维数组的定义 4.访问数组的元素 5.遍历数组 for循环遍历数组 for each遍历数组 toString遍历数组 6.数组的初始化 静态初始化动态初始化 数组元素的默认值 7.二维数组 8.二维数组的遍历 for循环进行遍历 for each进行遍历 deepToString 9.数组的拷贝 for循环拷贝数组 Arrays.copyOf方法 Arrays.copyofRange方法System.arraycopy方法 clone方法
java数组
Jason_LH1024的博客
05-20 189
数组：是一种容器，可以存放多个数据值。 数组的特点： 1.数组是一种引用数据类型 2.数组当中的多个数据，类型必须统一 3.数组的长度在程序运行期间不可改变。 数组的初始化：在内存中创建一个数组，并且向其中赋予一些默认值。 两种常见的初始化方式： 1.动态初始化（指定长度） 2.静态初始化（指定内容） 动态初始化数组的格式： 数据类型[ ] 数组名称 = new 数...
Java中数组的定义及使用
随便写写
05-13 957
在java中数组是对象1.一个数组是一系列匿名变量，数组就是一些相关变量的集合，数组中的元素可以通过下标来进行访问。类Object中定义的方法都可以用于数组对象。数组元素可以是基本类型也可以是类类型，当然还可以是数组。数组在使用之前必须先说明，也就是要先定义！数组定义语法如下：    动态初始化①声明并开辟数组：数据类型   数组名称[]=new 数据类型[长度];  ([]也可以写在数组名称前面...
java 中数组初始化实例详解
08-30
Java 中数组初始化是 Java 编程语言中的一种基本概念，它允许开发者创建和操作数组对象。在本文中，我们将深入探讨 Java 中数组初始化的概念，包括数组初始化的定义、可变参数列表的使用、可变参数列表对函数重载的...
java中数组的应用及方法
09-05
除了以上的基本应用，Java数组还支持许多其他操作，如排序（使用`Arrays.sort()`方法）、填充（使用`Arrays.fill()`方法）以及复制（使用`System.arraycopy()`方法）。此外，Java还提供了多维数组，可以创建数组的...
java中数组的定义及使用方法(推荐)
09-01
数组是编程中非常基础且重要的概念，它允许我们在处理大量数据时保持数据的有序性。本文将深入探讨Java中数组的定义、使用方法以及相关知识点。 一、数组的定义 在Java中，数组是由相同类型的数据元素组成的集合。...
Java数组的基本操作方法整理
09-03
Java数组是程序设计中不可或缺的基础概念，主要用于存储一组相同类型的元素。在Java中，数组是一种对象，它提供了按索引访问数据的能力，索引通常是从0开始的。本篇文章将详细解析Java数组的基本操作方法。 1. **...
Java中数组在内存中存放原理的讲解
08-26
Java中数组在内存中存放...在Java中，数组是一种基本的数据结构，它广泛应用于各种场景中，了解数组在内存中的存放原理对于程序设计和优化具有重要的参考价值。本文的内容对大家的学习或者工作具有一定的参考学习价值。
Java——数组（概念理解+应用举例）
胜天半子祁同伟
06-04 9286
Java——数组（概念理解+应用举例）
Java数组的概念
bestkain的博客
07-06 193
Java数组的创建与初始化方式
java中一维数组、二维数组的定义和使用
weixin_42051673的博客
07-27 3716
一维数组的定义： //动态初始化 int []a; int b[]; int []c=new int [3]; int d[]=new int [3]; //通过下标赋值 //a，b这种定义方式必须在使用前给a，b声明长度，否则编译会出问题: //（The local variable a may not have been initialized）。 //静态初始化 ...
java中数组的定义及其基础应用
RYJ359的博客
07-18 704
一维数组的定义及使用： 基础知识： (1).定义：用来存储同一种数据类型，是定长的容器；数组的数据类型属于应用数据类型。 (2).使用数组的好处：一是可以存储多个同类型的数据，二是可以给这些数据从0开始编号，以便于操作这些数。 (3).语法格式 a.动态初始化格式：   数组元素类型 [ ]  数组名 = new  数组元素类型  [ 元素个数] ;   还可以这样写：  数组元素类
Java中数组的定义和使用
热门推荐
xkfanhua的博客
06-02 4万+
如果希望保存一组有相同类型的数，可以使用数组。今天天气不错，来复习复习Java数组。数组的定义和和内存分配Java中定义数组的语法有两种：int[] arr;//第一种 int arr[];//第二种这两种形式上没有区别，使用效果完全一样。与C、C++不同，Java在定义数组时并不为数组元素分配内存空间，因此[]中无需指定数组元素的个数，也就是数组长度。所以我们需要先分配内存空间，才能访问数组中的...
数组
zhenhangsky的专栏
06-14 636
Java 一维数组详解
KUNKING1958的博客
02-23 1053
一维数组知识点： 一、数组的定义 1、Java 语言中的数组是一种引用数据类型。 不属于基本数据类型。 数组的父类是Object类 2、数组实际上是一个容器,可以同时容纳多个元素。( 数组是一个数据的集合。) 数组:字面意思是“一组数据” 二、数组的特点： 3、数组当中可以存储“基本数据类型”的数据,也可以存储“引用数据类型”的数据。 4.数组因为是引用类型,所以数组对象是堆内存当中。( 数组是存储在堆当中的) 5、数组当中如果存储的是“java对象”的话,实际上存储的是对象的“引用(内存地址)”,数组
Java数组一：数组的相关概念
qq479850581的博客
08-14 90
数组的定义 数组是相同类型数据的有序集合. 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.（从零开始） 数组的声明和创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法: dataType[] arrayRefVar;首选的方法 或 dataType arrayRefVar[];l/效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下: dataType[] ar
可变参数 int...arr = int[] arr
weixin_43018910的博客
09-13 2389
public class Demo03 { public static void main(String[] args) { /* 可变参数 public static void method(int...arr) 等价于 public static void method(int[] ar...
Java中数组对象和元素对象
最新发布
05-27
元素对象则是存储在数组中的具体数据项，它可以是任意的Java对象或基本数据类型。在访问数组元素时，需要使用下标来指定要访问的元素位置，例如：arr[0]、arr[1]、arr[2]等。 需要注意的是，数组对象和元素对象是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值