您的位置:

java中数组的一些笔记,Java的数组

本文目录一览:

JAVA中数组的优点

1.1 越界检查

1.2 length field:与传统的C++中的数组相比,length字段可以方便的得到数组的大小;但要注意,仅仅可以得到数组的大小,不能得到数组中实际包含多少个元素,因为length 只会告诉我们最多可将多少元素置入那个数组。

1.3 初始化:对象数组在创建之初会自动初始化成null,由原始数据类型构成的数组会自动初始化成零(针对数值类型),(Char)0 (针对字符类型)或者false (针对布尔类型)。

1.4 数组作为返回值:首先,既然数组是对象,那么就可以把这个对象作为返回值;而且,不必担心那个数组的是否可用只要需要它就会自动存在而且垃圾收集器会在我们完成后自动将其清除

2. 通用算法

2.1 在java.util 中的Arrays 数组类容纳着一系列静态方法可简化我们对数组的操作,总共有四个函数。equals()用于比较两个数组是否相等、fill()可将一个值填入数组、sort()可对数组排序、而binarySearch()用于在排好序的数组中查找一个元素。所有这些方法都已为全部原始数据类型及对象重载使用。除此以外还有一个asList()方法可用它获取任意数组然后把数组转变成一个List 容器。

2.2 sort和binarySearch的使用:在Java 2 中有两个办法可提供比较功能。第一个办法是用自然比较方法,这是通过实现java.lang.Comparable 接口来实现。Java 2 提供的第二个办法来进行对象的比较,单独创建一个类实现名为Comparator 的一个接口。接口提供了两个方法分别是compare()和equals() 。不过除非考虑到一些特殊的性能方面的因素,否则我们用不着实现equals() ,因为每次创建一个类的时候它都会默认从Object 继承,而Object 已经有了一个equals()。Comparator可以作为sort和binarySearch方法的参数。

java的数组有些不懂 请高人指点?????

java数组定义和赋值2007-11-25 18:39数组是有序数据的集合,数组中的每个元素具有相同的数组名和下标来唯一地确定数组中的元素。

§5.1一维数组

一、一维数组的定义

type arrayName[];

其中类型(type)可以为Java中任意的数据类型,包括简单类型组合类型,数组名arrayName为一个合法的标识符,[]指明该变量是一个数组类型变量。例如:

int intArray[];

声明了一个整型数组,数组中的每个元素为整型数据。与C、C++不同,Java在数组的定义中并不为数组元素分配内存,因此[]中不用指出数组中元素个数,即数组长度,而且对于如上定义的一个数组是不能访问它的任何元素的。我们必须为它分配内存空间,这时要用到运算符new,其格式如下:

arrayName=new type[arraySize];

其中,arraySize指明数组的长度。如:

intArray=new int[3];

为一个整型数组分配3个int型整数所占据的内存空间。

通常,这两部分可以合在一起,格式如下:

type arrayName=new type[arraySize];

例如:

int intArray=new int[3];

二、一维数组元素的引用

定义了一个数组,并用运算符new为它分配了内存空间后,就可以引用数组中的每一个元素了。数组元素的引用方式为:

arrayName[index]

其中:index为数组下标,它可以为整型常数或表达式。如a[3],b[i](i为整型),c[6*I]等。下标 从0开始,一直到数组的长度减1。对于上面例子中的in-tArray数来说,它有3个元素,分别为:

intArray[0],intArray[1],intArray[2]。注意:没有intArray[3]。

另外,与C、C++中不同,Java对数组元素要进行越界检查以保证安全性。同时,对于每个数组都有一个属性length指明它的长度,例如:intArray.length指明数组intArray的长度。

例5.1

public class ArrayTest{

public static void main(String args[]){

int i;

int a[]=newint[5];

for(i=0;i<5;i++)

a[i]=i;

for(i=a.length-1;i>=0;i--)

System.out.println("a["+i+"]="+a[i]);

}

}

运行结果如下:

C:\>java ArrayTest

a[4]=4

a[3]=3

a[2]=2

a[1]=1

a[0]=0

该程序对数组中的每个元素赋值,然后按逆序输出。

三、一维数组的初始化

对数组元素可以按照上述的例子进行赋值。也可以在定义数组的同时进行初始化。

例如:

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

用逗号(,)分隔数组的各个元素,系统自动为数组分配一定空间。

与C中不同,这时Java不要求数组为静态(static)。

四、一维数组程序举例:

例5.2Fibonacci数列

Fibonacci数列的定义为:

F1=F2=1,Fn=Fn-1+Fn-2(n>=3)

public classFibonacci{

public static void main(String args[]){

int i;

int f[]=new int[10];

f[0]=f[1]=1;

for(i=2;i<10;i++)

f[i]=f[i-1]+f[i-2];

for(i=1;i<=10;i++)

System.out.println("F["+i+"]="+f[i-1]);

}

}

运行结果为:

C:\>java Fibonacci

F[1]=1

F[2]=1

F[3]=2

F[4]=3

F[5]=5

F[6]=8

F[7]=13

F[8]=21

F[9]=34

F[10]=55

例5.3冒泡法排序(从小到大)

冒泡法排序对相邻的两个元素进行比较,并把小的元素交到前面。

public class BubbleSort{

public static void main(String args[]){

int i,j;

int intArray[]={30,1,-9,70,25};

int l=intArray.length;

for(i=0;i<l-1;i++)

for(j=i+1;j<l;j++)

if(intArray[i]>intArray[j]){

int t=intArray[i];

intArray[i]=intArray[j];

intArray[j]=t;

}

for(i=0;i<l;i++)

System.out.println(intArray[i]+"");

}

}

运行结果为:

C:\>java BubbleSort

-9

1

25

30

70

§5.2多维数组

与C、C++一样,Java中多维数组被看作数组的数组。例如二维数组为一个特殊的一维数组,其每个元素又是一个一维数组。下面我们主要以二维数为例来进行说明,高维的情况是类似的。

一、二维数组的定义

二维数组的定义方式为:

type arrayName[][];

例如:

int intArray[][];

与一维数组一样,这时对数组元素也没有分配内存空间,同要使用运算符new来分配内存,然后才可以访问每个元素。

对高维数组来说,分配内存空间有下面几种方法:

1直接为每一维分配空间,如:

int a[][]=new int[2][3];

2从最高维开始,分别为每一维分配空间,如:

int a[][]=new int[2][];

a[0]=new int[3];

a[1]=new int[3];

完成1中相同的功能。这一点与C、C++是不同的,在C、C++中必须一次指明每一维的长度。

二、二维数组元素的引用

对二维数组中每个元素,引用方式为:arrayName[index1][index2] 其中index1、index2为下标,可为整型常数或表达式,如a[2][3]等,同样,每一维的下标都从0开始。

三、二维数组的初始化

有两种方式:

1直接对每个元素进行赋值。

2在定义数组的同时进行初始化。

如:int a[][]={{2,3},{1,5},{3,4}};

定义了一个3×2的数组,并对每个元素赋值。

四、二维数组举例:

例5.4矩阵相乘

两个矩阵Am×n、Bn×l相乘得到Cm×l,每个元素Cij= aik*bk (i=1..m,n=1..n)

public class MatrixMultiply{

public static void main(String args[]){

int i,j,k;

int a[][]=new int[2][3];

int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};

int c[][]=new int[2][4];

for(i=0;i<2;i++)

for(j=0;j<3;j++)

a[i][j]=(i+1)*(j+2);

for(i=0;i<2;i++){

for(j=0;j<4;j++){

c[i][j]=0;

for(k=0;k<3;k++)

c[i][j]+=a[i][k]*b[k][j];

}

}

System.out.println("\n***MatrixA***");

for(i=0;i<2;i++){

for(j=0;j<3;j++)

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

System.out.println();

}

System.out.println("\n***MatrixB***");

for(i=0;i<3;i++){

for(j=0;j<4;j++)

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

System.out.println();

}

System.out.println("\n***MatrixC***");

for(i=0;i<2;i++){

for(j=0;j<4;j++)

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

System.out.println();

}

}

}

其结果为:

C:\>java MatrixMultiply

for(j=0;j<4;j++)

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

System.out.println();

}

}

}

其结果为:

C:\>java MatrixMultiply

***MatrixA***

2 3 4

4 6 8

***MatrixB***

1 5 2 8

5 9 10 -3

2 7 -5 -18

***MatrixC***

25 65 14 -65

50 130 28 -130

如果你学过线性代数,应该可以比较好地理解多维数组。

多维数组和矩阵结合紧密。

a[i][j]就是第i-1行的第j-1列的元素,因为下标是从0开始的。

比如:

一个数组:1 2 3

4 5 6

a[0][0]=1 a[0][1]=2 a[0][2]=3

a[1][0]=3 a[1][1]=5 a[1][2]=6

Java语言中,数组的实现原理是什么?

这个涉及到编译原理的问题,我只能说,这是一个编译规范。在规范中比如:int[],中的int告诉计算机这是一个整型数据,[]告诉计算机这是一个连续存储的内存地址空间,简单点说一个连续数据的存储空间就是数组,数组只是一个名称!!当然我只是简略的这样说,实际上数组是很复杂的!!

java中数组的特点?数组的声明和初始化方法和简单变量有什么不同?

java语言中,数组是一种最简单的复合数据类型。数组是有序数据的集合,数组中的每个元素具有相同的数据类型,可以用一个统一的数组名和下标来唯一地确定数组中的元素。数组有一维数组和多维数组。

★ 一维数组

1. 一维数组的定义

type arrayName[ ];

类型(type)可以为Java中任意的数据类型,包括简单类型和复合类型。

例如:

 int intArray[ ];

 Date dateArray[];

2.一维数组的初始化

◇ 静态初始化

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

String stringArray[]={"abc", "How", "you"};

◇ 动态初始化

  1)简单类型的数组

int intArray[];

intArray = new int[5];

 2)复合类型的数组

String stringArray[ ];

String stringArray = new String[3];/*为数组中每个元素开辟引用

  空间(32位) */

stringArray[0]= new String("How");//为第一个数组元素开辟空间

stringArray[1]= new String("are");//为第二个数组元素开辟空间

stringArray[2]= new String("you");// 为第三个数组元素开辟空间

3.一维数组元素的引用

数组元素的引用方式为:

 arrayName[index]

index为数组下标,它可以为整型常数或表达式,下标从0开始。每个数组都有一个属性length指明它的长度,例如:intArray.length指明数组intArray的长度。

★多维数组

Java语言中,多维数组被看作数组的数组。

1.二维数组的定义

type arrayName[ ][ ];

type [ ][ ]arrayName;

2.二维数组的初始化

◇ 静态初始化

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

Java语言中,由于把二维数组看作是数组的数组,数组空间不是连续分配的,所以不要求二维数组每一维的大小相同。

◇ 动态初始化

1) 直接为每一维分配空间,格式如下:

arrayName = new type[arrayLength1][arrayLength2];

int a[ ][ ] = new int[2][3];

2) 从最高维开始,分别为每一维分配空间:

arrayName = new type[arrayLength1][ ];

arrayName[0] = new type[arrayLength20];

arrayName[1] = new type[arrayLength21];

arrayName[arrayLength1-1] = new type[arrayLength2n];

3) 例:

二维简单数据类型数组的动态初始化如下,

int a[ ][ ] = new int[2][ ];

a[0] = new int[3];

a[1] = new int[5];

对二维复合数据类型的数组,必须首先为最高维分配引用空间,然后再顺次为低维分配空间。

而且,必须为每个数组元素单独分配空间。

例如:

String s[ ][ ] = new String[2][ ];

s[0]= new String[2];//为最高维分配引用空间

s[1]= new String[2]; //为最高维分配引用空间

s[0][0]= new String("Good");// 为每个数组元素单独分配空间

s[0][1]= new String("Luck");// 为每个数组元素单独分配空间

s[1][0]= new String("to");// 为每个数组元素单独分配空间

s[1][1]= new String("You");// 为每个数组元素单独分配空间

3.二维数组元素的引用

对二维数组中的每个元素,引用方式为:arrayName[index1][index2]

例如: num[1][0];

4.二维数组举例:

【例2.2】两个矩阵相乘

public class MatrixMultiply{

 public static void main(String args[]){

 int i,j,k;

 int a[][]=new int [2][3]; //动态初始化一个二维数组

 int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//静态初始化

一个二维数组

 int c[][]=new int[2][4]; //动态初始化一个二维数组

 for (i=0;i2;i++)

 for (j=0; j3 ;j++)

a[i][j]=(i+1)*(j+2);

 for (i=0;i2;i++){

 for (j=0;j4;j++){

c[i][j]=0;

 for(k=0;k3;k++)

 c[i][j]+=a[i][k]*b[k][j];

}

 }

 System.out.println("*******Matrix C********");//打印Matrix C标记

 for(i=0;i2;i++){

 for (j=0;j4;j++)

System.out.println(c[i][j]+" ");

 System.out.println();

}

 }

 }