【Java】 数组和Array用法详解
概念：同一种类型数据的集合。其实数组就是一个容器，但是与容器的区别在于数组的长度难以扩充。
特点： 数组长度是固定的， length 属性只能获取数组定义的个数，而不是实际存储元素的多少。
java 数组的常用操作介绍：
（1）增加、删除数组元素
（2）输入、输出数组元素
（3）数组元素的排序、查找
一、 一维数组
格式1：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：
int[] x = new int[5];
x[0] = 1;
x[1] = 2;
格式2：
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
示例：int[] arr = new int[]{3,5,1,7};
格式3：
元素类型[] 数组名 = {元素，元素，……};
示例：int[] arr = {3,5,1,7};
注意：
给数组分配空间时，必须指定数组能够存储的元素个数来确定数组大小。创建数组之后不能修改数组的大小。可以使用length 属性获取数组的大小。
- 数组创建指定大小数组，但不赋值
int c[]=new int[3];
System.out.println(Arrays.toString(c));
注意：基本类型会自动初始化为空值，int型则为0.输出结果为[0, 0, 0]，Arrays.toString产生一维数组的可打印版本。
- 一个数组赋给另一个数组
int a[]= {1,2,3,4,5};
int b[];
b=a;
注意：这种方法真正做的只是复制了一个引用，简单的说就是a，b指针指向同一个内存空间，即对b操作相当于对a操作，当然Java没提指针这个概念。
一维数组的建立（三种方法）
package Packger;
public class array {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("声明数组： 数组元素类型 数组名字[]; 或者 数组元素类型[] 数组名字"+
"声明数组后还必须分配内存空间， 分配时必须指明数组的长度");
System.out.println("数组名字 = new 数组元素类型[数组元素的个数]");
System.out.println("使用 new 关键字为数组分配内存时， 整形数组中各个元素的初始值都为0");
// 创建一维数组的第一种方法， 不常用
float[] arr;
arr = new float[1];
arr[0] = (float) 2.2;
// 创建一维数组的第二种方法，
int[] arr1 = new int[12];
// 创建一维数组的第三种方法，
System.out.println("初始化一维数组： ");
int[] arr2 = new int[]{12,45,32,55};
// 创建一维数组的第四种方法，
double[] arr3 = {12.3, 52.1, 54.2, 44.1};
for (int i=0; i<arr3.length; i++) {//通过数组的 length 属性可获得数组的长度
System.out.println("arr[]："+arr3[i]);
}
int m=0;
boolean length = isLength(m,arr2);
if(length){
System.out.println(arr2[m]);
}else{
System.err.println("数组标越界");
}
}
//判断数组下标是否越界
public static boolean isLength(int m,int[] arr){
boolean flag=false;
int lengths = arr.length;
if(m<lengths)
flag=true;
return flag;
}
}
二、二维数组
二维数组：实质就是一个元素为一维数组的数组；
数组定义：
数组类型[][] 数组名 = new 数组类型[一维数组的个数][每一个一维数组中元素的个数];
格式1：
数据类型[][] 变量名=new 数据类型[m][n];
m表示这个二维数组有多少个数组
n表示每一个一维数组的元素个数
举例：
int[][] arr=new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是ar[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取
格式2：
数据类型[][] 变量名=new 数据类型[m][];
m表示这个二维数组有多少个数组
这一次没有直接给出一维数组的元素个数，可以动态的给出
举例：
int[][] arr=new int[3][];
arr[0] = new int[2];
arr[1]= new int[3];
arr[2]=new int[1];
格式3：
数据类型[][] 变量名=new 数据类型[][]{{元素...},{元素...},{元素...}};
数据类型[][] 变量名={{元素...},{元素...},{元素...}};
举例：
int[][] arr={{1,2,3},{4,6},{6}}
二维数组的建立
package Packger;
import java.util.ArrayList;
public class array2 {
public static void main(String[] args) {
System.out.println("二维数组的建立---------------------");
// 创建二维数组的第一种方法
int[][] a = new int[][]{{1,2,3,4},{5,6,7,8}};
// 创建二维数组的第二种方法
int[][] c = {{1,2,3,4},{5,6,7,8}};
// 创建二维数组的第三种方法
int[][] b = new int[2][];
b[0] = new int[]{1,2,3,4};
b[1] = new int[] {5,6};
int m = 2, n = 3;
double[][] array = new double[m][n];
for (int i = 0; i<array.length; i++) { // 注意： 二维数组使用 length 属性，返回的为行值
for (int j = 0; j < array[i].length; j++) {
array[i][j] = i+j;
}
}
for (int i = 0; i<array.length; i++) { // 注意： 二维数组使用 length 属性，返回的为行值
for (int j = 0; j < array[i].length; j++) {
System.out.println("a["+i+"]["+j+"]:-----------"+array[i][j]);
}
}
System.out.println("创建二维数组的第三种方法");
// 创建二维数组的第三种方法
ArrayList<Integer> a4[]=new ArrayList[3];
for(int i=0;i<a4.length;i++) {
a4[i]=new ArrayList();
a4[i].add(i);
for(int j:a4[i])
System.out.print(j+" ");
System.out.println();
}
}
}
输出结果：
二维数组的建立---------------------
a[0][0]:-----------0.0
a[0][1]:-----------1.0
a[0][2]:-----------2.0
a[1][0]:-----------1.0
a[1][1]:-----------2.0
a[1][2]:-----------3.0
创建二维数组的第三种方法
0
1
2
数组的常见异常
数组中最常见的问题：
-
NullPointerException 空指针异常
原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。\ -
ArrayIndexOutOfBoundsException 索引值越界。
原因：访问了不存在的索引值。
一数组角标越界异常:，注意：数组的角标从0开始。
public static void main(String[] args) {
int[] x = { 1, 2, 3 };
System.out.println(x[3]);
//java.lang.ArrayIndexOutOfBoundsException
}
二 空指针异常:
public static void main(String[] args) {
int[] x = { 1, 2, 3 };
x = null;
System.out.println(x[1]);
// java.lang.NullPointerException
}
三、数组的内存分析
一维数组内存分析
二维数组内存分析
疑问： 为什么a.length = 3, a[0].length = 4?
四、数组元素的输出
方法一：遍历输出
public class array {
public static void main(String[] args) {
int[] ns = { 1, 4, 9, 16, 25 };
for (int i=0; i<ns.length; i++) {
int n = ns[i];
System.out.println(n);
}
}
}
输出结果：
1
4
9
16
25
方法二：for each循环
public class array {
public static void main(String[] args) {
int[] ns1 = { 1, 4, 9, 16, 25 };
for (int n : ns1) {//注意是直接将ns数组的值送到n里面去了
System.out.println(n);
}
}
}
注意：在for (int n : ns)循环中，变量n直接拿到ns数组的元素，而不是索引。
显然for each循环更加简洁。但是，for each循环无法拿到数组的索引，因此，到底用哪一种for循环，取决于我们的需要
方法三：使用Java标准库提供的Arrays.toString()
import java.util.Arrays;
public class array {
public static void main(String[] args) {
int[] ns2 = { 1, 1, 2, 3, 5, 8 };
System.out.println(Arrays.toString(ns2));
}
输出·结果：
[1, 1, 2, 3, 5, 8]
五、Java 使用 scanner 进行动态赋值（以二维数组为例）
类型一
import java.util.Arrays;
import java.util.Scanner;
public class scanner3 {
public static void main(String[] args) {
System.out.println("输入：");
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int n = sc.nextInt();
System.out.println("m: "+ m);
System.out.println("n: "+ n);
int[][] num = new int[m][n];
for(int i = 0; i < num.length; i ++) {
for (int j = 0; j < n; j++) {
num[i][j] = sc.nextInt(); // 一个一个读取
}
}
System.out.println(Arrays.toString(num));
for(int[]v : num) {
System.out.println(Arrays.toString(v));
}
}
}
输入：
2 3
m: 2
n: 3
1 2 3
4 5 6
[[I@4aa298b7, [I@7d4991ad]
[1, 2, 3]
[4, 5, 6]
类型二
package Packger;
import java.util.Arrays;
import java.util.Scanner;
public class scanner4 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int numCount=sc.nextInt();
int[][] numArrs=new int[numCount][];
for(int i=0;i<numCount;i++){
int l=sc.nextInt();
numArrs[i]=new int[l];
for(int j=0;j<l;j++){
numArrs[i][j]=sc.nextInt();
}
}
for (int[]v : numArrs) {
System.out.println(Arrays.toString(v));
}
}
}
2
4
1 2 3 4
2
7 8
[1, 2, 3, 4]
[7, 8]
Java 数组使用实例
键盘输入一个整数型数组（数组长度和数组元素都是键盘输入）在数组中任意位置上插入一个从键盘上录入的数值，打印出插入指定数值后的新数组
package Packger;
import java.util.Scanner;
public class arrayTest {
public static void main(String[] args){
int[] arr=genArray();
printArray(arr);
Scanner s=new Scanner(System.in);
System.out.print("请您输入一个所需要插入的数值：");
int value=s.nextInt();
System.out.print("请您输入所需要插入的位置索引值：");
int position=s.nextInt();
int[] res=arrayAnyInsert(arr,position,value);
if(res != null){
printArray(res);
}else{
System.out.println("位置非法");
}
}
public static int[] genArray(){
Scanner s=new Scanner(System.in);
System.out.print("请您输入所需要的数组元素长度：");
int line=s.nextInt();
int[] arr=new int[line];
for(int i=0;i<arr.length;i++){
System.out.print("请您输入所需要的数组元素：");
int r=s.nextInt();
arr[i]=r;
}
return arr;
}
public static int[] arrayAnyInsert(int[] arr,int position,int value){
int[] res=new int[arr.length+1];
if(position<0 || position>res.length){
return null;
}
for(int i=0;i<res.length;i++){
if(i<position){
res[i]=arr[i];
}else if(i==position){
res[i]=value;
}else{
res[i]=arr[i-1];
}
}
return res;
}
public static void printArray(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
六、Arrays 类的使用
特点： 数组是作为对象来实现的。(really occupy the memopry，真实的占用内存 )
An array is a data structure that stores a collection of value of the same type.（数组是一个数据结构，它存储一堆类型相同的值）
java 数组的常用操作介绍：
（1）增加、删除数组元素
（2）输入、输出数组元素
（3）数组元素的排序、查找
Java Arrays工具类
Arrays 类是一个工具类，其中包含了数组操作的很多方法。这个 Arrays 类里均为 static 修饰的方法（static 修饰的方法可以直接通过类名调用），可以直接通过 Arrays.xxx(xxx) 的形式调用方法。
- int binarySearch(type[] a, type key)
使用二分法查询 key 元素值在 a 数组中出现的索引，如果 a 数组不包含 key 元素值，则返回负数。调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果。 - int binarySearch(type[] a, int fromIndex, int toIndex, type key)
这个方法与前一个方法类似，但它只搜索 a 数组中 fromIndex 到 toIndex 索引的元素。调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果。 - type[] copyOf(type[] original, int length)
这个方法将会把 original 数组复制成一个新数组，其中 length 是新数组的长度。如果 length 小于 original 数组的长度，则新数组就是原数组的前面 length 个元素，如果 length 大于 original 数组的长度，则新数组的前面元索就是原数组的所有元素，后面补充 0（数值类型）、false（布尔类型）或者 null（引用类型）。 - type[] copyOfRange(type[] original, int from, int to)
这个方法与前面方法相似，但这个方法只复制 original 数组的 from 索引到 to 索引的元素。 - boolean equals(type[] a, type[] a2)
如果 a 数组和 a2 数组的长度相等，而且 a 数组和 a2 数组的数组元素也一一相同，该方法将返回 true。 - void fill(type[] a, type val)
该方法将会把 a 数组的所有元素都赋值为 val。 - void fill(type[] a, int fromIndex, int toIndex, type val)
该方法与前一个方法的作用相同，区别只是该方法仅仅将 a 数组的 fromIndex 到 toIndex 索引的数组元素赋值为 val。 - void sort(type[] a)
该方法对 a 数组的数组元素进行排序。 - void sort(type[] a, int fromIndex, int toIndex)
该方法与前一个方法相似，区别是该方法仅仅对 fromIndex 到 toIndex 索引的元素进行排序。 - String toString(type[] a)
该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号,和空格隔开。
1、Arrays.toString()：数组转字符串
格式：Arrays.toString(数组名)
将数组转化成字符串，此时输出的结果是字符串类型。
import java.util.Arrays;
public class ArrayToString {
public static void main(String[] args) {
int arr[] = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
}
}
运行结果：
[1, 2, 3, 4, 5, 6]
2、Arrays.copyOf(数组名，扩容后长度)：数组扩容
格式：Arrays.copyOf(数组名，扩容后长度)
注意：此方法可以用于扩容，也可以用于缩容，改变其第二个参数即可。
复制代码
import java.util.Arrays;
public class ArraycopyOf {
public static void main(String[] args) {
int arr[] = {1,2,3,4};
arr = Arrays.copyOf(arr,8);
for(int a:arr)
System.out.print(a+" ");
}
}
运行结果：
1 2 3 4 0 0 0 0
3、Arrays.copy()：数组的复制
格式：Arrays.copy(原数组，原数组起始位置，新数组，新数组起始位置，复制长度)
public class Arrayscopy {
public static void main(String[] args) {
int arr[] = {1,2,3,4};
int[] arr1 = new int[6];
System.arraycopy(arr, 0, arr1, 1, 3);
for (int str : arr1){
System.out.print(str+“ ”);
}
}
}
运行结果：
0 1 2 3 0 0
4、Arrays.sort()：数组排序
格式：Arrays.sort(数组名, int fromIndex, int toIndex)
注意：只能做升序排序,不能做降序排序。
import java.util.Arrays;
public class ArraySort {
public static void main(String[] args) {
int arr[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
Arrays.sort(arr);
for(int a:arr)
System.out.print(a+" ");
}
}
运行结果：
-9 -7 -3 -2 0 2 4 5 6 8
5、Arrays.fill()：向数组中填充元素
格式：Arrays.fill(数组名 ,开始位置 , 结束位置, 填入的值)
import java.util.Arrays;
public class ArrayFill {
public static void main(String[] args) {
int arr[] = {1,2,3,4,5,6,7,8,9,10};
Arrays.fill(arr, 3, 6, 50);
for(int a:arr)
System.out.print(a+" ");
System.out.println();
int array[] = new int[6];
Arrays.fill(array, 100);
for (int i=0, n=array.length; i < n; i++) {
System.out.print(array[i]+" ");
}
}
}
运行结果：
1 2 3 50 50 50 7 8 9 10
100 100 100 100 100 100
6、Arrays.equals()：比较两个数组是否相等
数组相等的条件不仅要求数组元素的个数必须相等，而且要求对应位置的元素也相等。Arrays 类提供了 equals() 方法比较整个数组。
格式：Arrays.equals(arrayA, arrayB);
其中，arrayA 是用于比较的第一个数组，arrayB 是用于比较的第二个数组。
public static void main(String[] args) {
double[] score1 = { 99, 100, 98.5, 96.5, 72 };
double[] score2 = new double[5];
score2[0] = 99;
score2[1] = 100;
score2[2] = 98.5;
score2[3] = 96.5;
score2[4] = 72;
double[] score3 = { 99, 96.5, 98.5, 100, 72 };
if (Arrays.equals(score1, score2)) {
System.out.println("score1 数组和 score2 数组相等");
} else {
System.out.println("score1 数组和 score2 数组不等");
}
if (Arrays.equals(score1, score3)) {
System.out.println("score1 数组和 score3 数组相等");
} else {
System.out.println("score1 数组和 score3 数组不等");
}
}
运行结果：
score1 数组和 score2 数组相等
score1 数组和 score3 数组不等
7、Arrays.binarySearch() :查找指定元素
查找数组是指从数组中查询指定位置的元素，或者查询某元素在指定数组中的位置。使用 Arrays 类的 binarySearch() 方法可以实现数组的查找，该方法可使用二分搜索法来搜索指定数组，以获得指定对象，该方法返回要搜索元素的索引值。
格式：binarySearch(Object[] a,int fromIndex,int toIndex,Object key);
其中 int fromIndex,int toIndex, 可以省略；默认查找全部。
public static void main(String[] args) {
double[] score = {99.5,100,98,97.5,100,95,85.5,100};
Arrays.sort(score);
int index1 = Arrays.binarySearch(score,2,6,100);
int index2 = Arrays.binarySearch(score,2,6,60);
System.out.println("查找到 100 的位置是："+index1);
System.out.println("查找到 60 的位置是："+ index2);
}
执行上述代码，输出结果如下：
查找到 100 的位置是：5
查找到 60 的位置是：-3
参考博客：
https://blog.csdn.net/jdbfvhxx/article/details/95377739
https://www.cnblogs.com/cstdio1/p/11244383.html
https://blog.csdn.net/oguro/article/details/52971487
https://blog.csdn.net/weixin_41933796/article/details/79860279
645
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
