Java零基础入门数组-eolink官网

Java零基础入门数组

目录认识数组数组的初始化默认初始化静态初始化动态初始化数组有关的问题数组的遍历求最值问题查询子元素Arrays工具类二维数组二维数组初始方式二维数组的遍历

认识数组

数组的定义

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。

数组的四个基本特点

长度是确定的。数组一旦被创建，它的大小就是不可以改变的。其元素的类型必须是相同类型，不允许出现混合类型。数组类型可以是任何数据类型，包括基本类型和引用类型。数组有索引的：索引从0开始，到数组.length-1结束数组变量属于引用类型，数组也是对象。

PS:数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

数组下标从0开始

arr[0] == 12

arr[1] == 6

arr[2] == 27

…

arr[5] == 43

数组的初始化

数组的初始化方式总共有三种：默认初始化、静态初始化、动态初始化。

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int[] arr = new int[3]; //数组有默认的初始化值

基本数据类型数组的默认值：

byte[] : 0

short[] : 0

cahr[] : ‘\u0000’

int[] : 0

long[] : 0

float[] : 0.0

double[] : 0.0

boolean[] : false

引用数据类型数组的默认值：null

静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] arr = {12,23,45};

int[] arr = new int[]{12,23,45};

动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

int[] arr ;

arr = new int[3]

arr[0] = 12;

arr[1] = 23;

arr[2] = 45;

数组有关的问题

数组的遍历

两种方法

public class TestCode04 {

public static void main(Stringhttp://[] args) {

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

int[] arr2 = {5, 4, 3, 2, 1};

//方式1，使用普通for循环

//arr1.length获取数组长度的方法

for (int i = 0; i < arr1.length; i++) {

System.out.print(arr1[i] + " ");

}

System.out.println();

//方式2，使用增强for循环

for (int a : arr2) {

System.out.print(a + " ");

}

求最值问题

问题：给定一个数组int[] arr = {3,5,6,17,26,9,0,7}; ，求出数组中最大的数

public class TestCode05 {

public static void main(String[] args) {

int[] arr={3,5,6,17,26,9,0,7};

int max=arr[0];//假设最大元素为数组arr[0]位置上的数

//然后依次向后比较

for(int i=1;i

//因为max=arr[0];可以从arr[1]位置开始比较

if(arr[i]>max){

max=arr[i];

}

System.out.println(max);

}

查询子元素

查询指定位置元素

给定一个数组，查询索引位置为2上的元素

public class TestCode06 {

public static void main(String[] args) {

int[] arr={3,5,6,17,26,9,0,7};

//直接输出arr[2];

System.out.println(arr[2]);

//输出-->6

}

上面代码体现了数组的一个优点：在按照位置查询的时候，直接一步到位，效率非常高

查询指定元素的位置–>找出元素对应的索引

public class TestCode07{

public static void main(String[] args){

//查询指定元素的位置-->找出元素对应的索引

//给定一个数组：

int[] arr = {12,34,56,7,3,56};

// 0 1 2 3 4 5

//功能：查询元素12对应的索引：

int index = -1; //这个初始值只要不是数组的索引即可

for(int i=0;i

if(arr[i]==12){

index = i;//只要找到了元素，那么index就变成为i

break;//只要找到这个元素，循环就停止

}

if(index!=-1){

System.out.println("元素对应的索引："+index);

}else{//index==-1

System.out.println("查无此数！");

}

Arrays工具类

为了方便我们对数组进行操作，系统提供一个类Arrays，我们将它当做工具类来使用。

下面通过代码演示Arrays类中常用的方法:

Arrays.toString(arr);//对数组进行遍历查看，返回的是一个字符串

Arrays.sort(arr);//对数组进行排序 -->升序

Arrays.copyOf(arr,index);//对数组的复制

Arrays.copyOfRange(arr,startindex,endindex);//区间复制

Arrays.equals(arr1,arr2);//比较两个数组的值是否一样

Arrays.fill(arr,1);//数组填充

import java.util.Arrays;

public class TestCode08{

public static void main(String[] args){

//给定一个数组：

int[] arr = {1,3,7,2,4,8};

//toString:对数组进行遍历查看的，返回的是一个字符串

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

//binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：

//这个方法的使用前提：一定要查看的是一个有序的数组：

//sort：排序 -->升序

Arrays.sort(arr);

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

System.out.println(Arrays.binarySearch(arr,4));

int[] arr2 = {1,3,7,2,4,8};

//copyOf:完成数组的复制：

int[] newArr = Arrays.copyOf(arr2,4);

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

TiQpvpFkt //copyOfRange:区间复制：

int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置

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

//equals:比较两个数组的值是否一样：

http:// int[] arr3 = {1,3,7,2,4,8};

int[] arr4 = {1,3,7,2,4,8};

System.out.println(Arrays.equals(arr3,arr4));//true

System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是falhttp://se

//fill：数组的填充：

int[] arr5 = {1,3,7,2,4,8};

Arrays.fill(arr5,10);

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

}

二维数组

本质上全部都是一维数组

二维数组初始方式

静态初始化

int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

动态初始化

int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组

arr[0] = new int[]{1,2};

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

arr[2] = new int[]{34,45,56};

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int[][] arr=new int[3][3];//定义一个3*3的二维数组，默认值为0

二维数组的遍历

两个for循环

for (int i = 0; i < arr.length; i++) {

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

System.out.print(arr[i][j] + " ");

}

System.out.println();//换行

}

//因为max=arr[0];可以从arr[1]位置开始比较

if(arr[i]>max){

max=arr[i];

}

System.out.println(max);

}

查询子元素

查询指定位置元素

给定一个数组，查询索引位置为2上的元素

public class TestCode06 {

public static void main(String[] args) {

int[] arr={3,5,6,17,26,9,0,7};

//直接输出arr[2];

System.out.println(arr[2]);

//输出-->6

}

上面代码体现了数组的一个优点：在按照位置查询的时候，直接一步到位，效率非常高

查询指定元素的位置–>找出元素对应的索引

public class TestCode07{

public static void main(String[] args){

//查询指定元素的位置-->找出元素对应的索引

//给定一个数组：

int[] arr = {12,34,56,7,3,56};

// 0 1 2 3 4 5

//功能：查询元素12对应的索引：

int index = -1; //这个初始值只要不是数组的索引即可

for(int i=0;i

if(arr[i]==12){

index = i;//只要找到了元素，那么index就变成为i

break;//只要找到这个元素，循环就停止

}

if(index!=-1){

System.out.println("元素对应的索引："+index);

}else{//index==-1

System.out.println("查无此数！");

}

Arrays工具类

为了方便我们对数组进行操作，系统提供一个类Arrays，我们将它当做工具类来使用。

下面通过代码演示Arrays类中常用的方法:

Arrays.toString(arr);//对数组进行遍历查看，返回的是一个字符串

Arrays.sort(arr);//对数组进行排序 -->升序

Arrays.copyOf(arr,index);//对数组的复制

Arrays.copyOfRange(arr,startindex,endindex);//区间复制

Arrays.equals(arr1,arr2);//比较两个数组的值是否一样

Arrays.fill(arr,1);//数组填充

import java.util.Arrays;

public class TestCode08{

public static void main(String[] args){

//给定一个数组：

int[] arr = {1,3,7,2,4,8};

//toString:对数组进行遍历查看的，返回的是一个字符串

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

//binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：

//这个方法的使用前提：一定要查看的是一个有序的数组：

//sort：排序 -->升序

Arrays.sort(arr);

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

System.out.println(Arrays.binarySearch(arr,4));

int[] arr2 = {1,3,7,2,4,8};

//copyOf:完成数组的复制：

int[] newArr = Arrays.copyOf(arr2,4);

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

TiQpvpFkt //copyOfRange:区间复制：

int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置

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

//equals:比较两个数组的值是否一样：

http:// int[] arr3 = {1,3,7,2,4,8};

int[] arr4 = {1,3,7,2,4,8};

System.out.println(Arrays.equals(arr3,arr4));//true

System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是falhttp://se

//fill：数组的填充：

int[] arr5 = {1,3,7,2,4,8};

Arrays.fill(arr5,10);

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

}

二维数组

本质上全部都是一维数组

二维数组初始方式

静态初始化

int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

动态初始化

int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组

arr[0] = new int[]{1,2};

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

arr[2] = new int[]{34,45,56};

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int[][] arr=new int[3][3];//定义一个3*3的二维数组，默认值为0

二维数组的遍历

两个for循环

for (int i = 0; i < arr.length; i++) {

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

System.out.print(arr[i][j] + " ");

}

System.out.println();//换行

}

if(arr[i]==12){

index = i;//只要找到了元素，那么index就变成为i

break;//只要找到这个元素，循环就停止

}

if(index!=-1){

System.out.println("元素对应的索引："+index);

}else{//index==-1

System.out.println("查无此数！");

}

Arrays工具类

为了方便我们对数组进行操作，系统提供一个类Arrays，我们将它当做工具类来使用。

下面通过代码演示Arrays类中常用的方法:

Arrays.toString(arr);//对数组进行遍历查看，返回的是一个字符串

Arrays.sort(arr);//对数组进行排序 -->升序

Arrays.copyOf(arr,index);//对数组的复制

Arrays.copyOfRange(arr,startindex,endindex);//区间复制

Arrays.equals(arr1,arr2);//比较两个数组的值是否一样

Arrays.fill(arr,1);//数组填充

import java.util.Arrays;

public class TestCode08{

public static void main(String[] args){

//给定一个数组：

int[] arr = {1,3,7,2,4,8};

//toString:对数组进行遍历查看的，返回的是一个字符串

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

//binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：

//这个方法的使用前提：一定要查看的是一个有序的数组：

//sort：排序 -->升序

Arrays.sort(arr);

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

System.out.println(Arrays.binarySearch(arr,4));

int[] arr2 = {1,3,7,2,4,8};

//copyOf:完成数组的复制：

int[] newArr = Arrays.copyOf(arr2,4);

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

TiQpvpFkt //copyOfRange:区间复制：

int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置

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

//equals:比较两个数组的值是否一样：

http:// int[] arr3 = {1,3,7,2,4,8};

int[] arr4 = {1,3,7,2,4,8};

System.out.println(Arrays.equals(arr3,arr4));//true

System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是falhttp://se

//fill：数组的填充：

int[] arr5 = {1,3,7,2,4,8};

Arrays.fill(arr5,10);

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

}

二维数组

本质上全部都是一维数组

二维数组初始方式

静态初始化

int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

动态初始化

int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组

arr[0] = new int[]{1,2};

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

arr[2] = new int[]{34,45,56};

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int[][] arr=new int[3][3];//定义一个3*3的二维数组，默认值为0

二维数组的遍历

两个for循环

for (int i = 0; i < arr.length; i++) {

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

System.out.print(arr[i][j] + " ");

}

System.out.println();//换行

}

Java十大经典排序算法的实现图解

231 2022-08-14

Java零基础入门数组

Java十大经典排序算法的实现图解

Java数据结构常见几大排序梳理

数据结构与算法Java版-数组分割（数据结构与算法 Java）

推荐文章

接口调用是什么意思？几种常用接口调用方式

接口设计原则

8款在线 API 接口文档管理工具

api管理系统是什么？

什么是接口调试？接口调试的步骤有哪些？

api 接口管理系统有哪些？

接口测试有几种测试方法

API文档生成工具有哪些？

微服务和api网关区别

交换机配置步骤

最近发表

热评文章

在线接口文档管理工具推荐，支持在线测试，HTTP接口

开源的在线接口文档wiki工具Mindoc的介绍与使

如何优雅的进行接口设计？接口设计的六大原则是什么？

什么是API测试,api检测公司

软件接口设计怎么做？前后端分离软件接口设计思路

接口管理平台推荐，几大接口管理平台总有一款适合你！