Java数组(3.9)

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 5.8k 阅读时长 ≈ 5 分钟

 
 

数组

 
 

一、 一维数组

数组： 相同类型的数据元素按顺序组成的一种线性表，元素在数组中的相对位置由下标来指定。数组中的每个元素通过数组名加下标进行引用。

数组有什么用处？
例：定义100个int型变量，求这100个变量的和。
int x1,x2,x3…x100;
int sum;
sum=x1+x2+…+x100;
这样程序很复杂。
例：定义100个int型变量，求这100个变量的和。
有了数组后，可以这样编程：
int [] x=new int[100];
int sum=0;
for(int i=0;i<100;i++)
{
sum=sum+x[i];
}
这样使得程序编写方便很多。

注意：
Java中，数组是独立的类，有自身的方法，不只是变量的集合。在Java里创建一个数组，需要做如下的工作：
（1）说明一个变量来存放该数组。
（2）建立一个新的数组对象（即创建数组空间）并把它赋给这个数组变量。
（3）在该数组中存储信息。

&emsp;&emsp; ↓↓

例如：String list[ ]=new String[3];
list[0]=“one”;
list[1]=“two”;

&emsp;
&emsp;

1.1 一维数组的说明

同其他类变量一样，在使用数组前必须先说明它，一维数组说明的格式如下：
&emsp; 类型 数组名[ ]；
或 类型[ ] 数组名；

例如：int list[ ];
int[] list;
String[] args;
String args[];

&emsp;
&emsp;

1.2 创建数组空间

创建数组空间必须声明数组的长度，以确定所开辟的内存空间的大小，在Java中实际上就是通过new创建一个新的数组对象并把它赋给这个数组变量。其语法格式如下：
&emsp;&emsp;&emsp;数组名=new 数组元素类型[数组元素个数]
例如：int[] list; list=new int[3];

数组的说明和构造合并在一起，其语法格式如下：
&emsp;&emsp;&emsp; 类型 数组名[ ]=new 数组元素类型[数组元素个数]；]
例如：int list[ ]=new int[3];

&emsp;
&emsp;

1.3 数组的初始化

1. 数组的初始化方式有两种：
(1) 像初始化简单类型一样自动初始化数组，即在说明数组的同时进行初始化；
&emsp;&emsp; int a[]={1,2,3,4}
(2) 先定义数组，然后为每个元素赋值。例如：
&emsp;&emsp; int b[]=new int[3];
&emsp;&emsp; b[0]=8;b[1]=9;
&emsp;
2. 这样初始化也可以!
另一种形式1：
int[] a=new int[]{1,2,3,4};&emsp;&emsp; 等价于: int[] a={1,2,3,4}
{}中的元素个数决定了[]中的元素个数。{}中的元素取值决定了数组a各个元素的取值。

另一种形式2：
int[] a;
a=new int[]{1,2,3,4};
等价于：int[] a=new int[3];
&emsp;&emsp;&emsp;&emsp; a[0]=1;a[1]=2;a[2]=3;
&emsp;&emsp;&emsp;&emsp; a[3]=4

但是这样定义是错误的：
int[] a;
a={1,2,3,4};

定义数组要注意：
(1) 不能这样定义数组：
&emsp;&emsp;&emsp;&emsp; int a[5];
(2)不能这样初始化数组：
&emsp;&emsp;&emsp;&emsp; int[] a; a={1,2,3,4};
(3)使用new 创建数组之后，数组中的每个元素被自动初始化为0。
&emsp;&emsp;&emsp;&emsp; int [] a=new int[10];
&emsp;&emsp;&emsp;&emsp; for(int i=0;i<10;i++)
&emsp;&emsp;&emsp;&emsp; { System.out.println(“a[“+i+”]=”+a[i]);
&emsp;&emsp;&emsp;&emsp; }

&emsp;
&emsp;

1.4 数组元素的使用

数组元素的表示方式为：
&emsp;&emsp;&emsp;&emsp; 数组名[下标]
&emsp;
使用数组时要注意：
（1）数组越界异常:Java在对数组元素操作时会对数组下标进行越界检查，以保证安全性。若在Java程序中超出了对数组下标的使用范围则在运行此程序时将出现如下错误信息：
&emsp;&emsp; Exception in thread “main” Java.lang.ArrayIndexOutOfBoundsException
如下的错误即数组越界：int x[]={1,2,3,4};System.out.println(x[4]);

（2）每个数组都有一个属性length来指明其长度，字符串String用length()。
&emsp;&emsp; list.length;

（3）空指针异常

1
2
3
4
5
6
7
8
9
10
数组长度lengh的使用
int x[]={1,2,3,4};                  int x[]={1,2,3,4};
for(int i=0;i<100;i++)              for(int i=0;i<x.length;i++)    
{  System.out.println(x[i]);        { System.out.println(x[i]); 
}                                   }

空指针如下使用会导致错误
int x[]=new int[10];
x=null;
x[0]=1;

&emsp;
&emsp;

1.5 一维数组使用举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
[例3-12] 练习数组的创建和使用
[例3-13] 练习数组越界
[例3-14] 数组作为函数的参数

[例3-12] HalfDollars.java 练习数组的创建与使用
class HalfDollars{
	public static void main(String[] args){
		int[] denver={15000006,18810000,20752110};
		int[] philadelphia=new int[denver.length];
		int[] total=new int[denver.length];
		int average;
		
		philadelphia[0]=15020000;
		philadelphia[1]=18709000;
		philadelphia[2]=21348000;
		
		total[0]=denver[0]+philadelphia[0];
		total[1]=denver[1]+philadelphia[1];
		total[2]=denver[2]+philadelphia[2];
		average=(total[0]+total[1]+total[2])/3;
		System.out.println("1993 production:"+total[0]);
        System.out.println("1994 production:"+total[1]);
        System.out.println("1995 production:"+total[2]);
        System.out.println("Average production:"+average);
	  }
}
运行结果：
1993 production:30020006
1994 production:37519000
1995 production:42100110
Average production:36546372


[例3-13] ChoiceSort.java 数组的越界
public class ChoiceSort
{
	public static void main(String arg[])
     {   int i,min;
          int str[]={2,13,41,58,32};
          for(i=0;i<5;i++)
          {
	         min=i;
	        for(int j=i+1;j<6;j++)
	         {      
	           if(str[min]>str[j])
	         	 {
	              int at=str[j];
	              str[j]=str[min];
	              str[min]=at;
	             }
	         }  
	      }
	    for(i=0;i<5;i++)
	    System.out.println(str[i]+" ");
	}
}
运行结果：
程序没能正常运行，抛出了“java.lang.ArrayIndexOutOfBoundsException”异常。 
		

例[3-14] test.java 数组作为函数的参数
class test  
{   static void change(int [] a)  //输出a[0]和a[1]中大的那个数
    {    int t;
         if(a[0]<a[1])
         {        t=a[0];
                  a[0]=a[1];
                  a[1]=t;
         }
         System.out.println(a[0]);
    }
    public static void main(String args[])
   {    int x[]={5,12};
        change(x);     //调用过后，数组x可能发生变化
   }
}

&emsp;
&emsp;

二、 二维数组

Java中的多维数组实际上是数组的数组。不一定是规则的矩阵数组。
多维数组：数组的数组，例如，二维数组为一个特殊的一维数组，其每个元素又是一个一维数组

1.png2.png

&emsp;
&emsp;
二维数组说明的格式为：
&emsp; 类型 数组名[ ][ ]；
或 类型[ ][ ] 数组名；

例如，说明一个整型的二维数组如下：
&emsp; int intArray[ ][ ];或 int[ ][ ] intArray;

&emsp;
二维数组的创建：
直接为每一维分配空间，如：
&emsp; int a[ ][ ]=new int[2][3];

|||
:-: | :-: | :-:
a[0][0]|a[0][1]|a[0][2]
a[1][0]|a[1][1]|a[1][2]

&emsp;
从最高维开始，分别为每一维分配空间，如：
int b[ ][ ]=new int[2][ ];
b[0]=new int[3];
b[1]=new int[5];
b[0][0] b[0][1] b[0][2]
b[1][0] b[1][1] b[1][2]

&emsp;
元素的初始化：
（1）直接对每个元素进行赋值。
（2）在说明数组的同时进行初始化。

1
2
3
4
5
例如：  int[][] a=new int[3][2]：
              a[0][0]=2； a[0][1]=3
              a[1][0]=1； a[1][1]=5
              a[2][0]=3； a[2][1]=4  
等价于：int a[ ][ ]={{2,3},{1,5},{3,4}};

&emsp;
总结：与数组操作相关的系统函数
（1）使用Arrays.sort来对数组排序
int x[]=new int[]{3,2,1,4};
java.util.Arrays.sort(x); //对数组x内的元素进行排序（升序）
for(int i=0;i < x.length;i++)
{
System.out.println(x[i]);
}

（2）使用Arrays.binarySearch函数对数组进行二分查找
int [] x=new int[]{2,5,1,6,8,3};
java.util.Arrays.sort(x);
System.out.println(java.util.Arrays.binarySearch(x,1)); //二分查找，在数组x中查找1，输出0 ;如果没找到，则会输出一个<0的数

（3）使用System.arraycopy函数拷贝数组
int [] x;
x=new int[]{3,1,2,4};
int [] y;
y=new int[4];
System.arraycopy(x,0,y,0,4);
//将数组x内的 4个元素拷贝给数组y

（4）使用Ayyars.fill函数填充数组
int [] x;
x=new int[]{3,1,2,4};
java.util.Arrays.fill(x,7); //数组x中的4个元素都改为7

&emsp;
&emsp;
&emsp;
&emsp;