Java数组与方法

若想要存放一连串相同数据类型的数据，使用数组是个相当好用的选择。此外，如果某个程序片段经常反复出现，那么将它定义成一个方法可以有效地简化程序代码。本章主要是介绍数组的基本用法与方法的应用，学完本章，将会对数组与方法的使用有更深一层的认识。

数组是由一组相同类型的变量所组成的数据类型，它属于引用类型。它们以一个共同的名称表示，数组中的每个元素则以下标来访问。数组依照存放元素的复杂程度分为一维数组、二维和多维数组，先来看看一维数组。

3.1 一维数组

一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的。可以将它简单的理解为是相同数据类型的数据的集合。

3.1.1 一维数组的声明与内存的分配

要使用Java的数组，必须经过两个步骤：

（1）声明数组

（2）给数组分配内存

这两个步骤的语法如下：

数据类型数组名[ ]; 或数据类型[ ] 数组名; // 声明一维数组

数组名= new 数据类型[个数]; // 给数组分配内存

数组的声明格式里，“数据类型”是声明数组每个元素的数据类型，常见的类型有整型、浮点型与字符型等，也可以是引用类型。“数组名”是用来统一这组相同数据类型的元素的名称，其命名规则和变量的相同，建议使用有意义的名称为数组命名。数组声明后，接下来便是要配置数组所需的内存，其中“个数”是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的个数，在内存中开辟一块内存供该数组使用。

需要注意的是，在Java中声明数组的时候，不能在[]中指定其长度。比如：int score[3]; // 错误

下面是关于一维数组的声明并分配内存给该数组的一个范例：

int score[]; // 声明整型数组score

score = new int[3]; // 为整型数组score分配内存空间，其元素个数为3 在上例中的第一行，当声明一个整型数组score时，score可视为数组类型的变量，此时这个变量并没有包含任何内容，编译器仅会分配一块内存给它，用来保存指向数组实体的地址，如图3-1所示。

图3-1 声明整型数组

声明之后，接着要做内存分配的操作，也就是上例中第二行语句。这一行会开辟3个可供保存整数的内存空间，并把此内存空间的参考地址赋给score变量。其内存分配的流程如图3-2所示。

图3-2 内存分配

上图中的内存参考地址0x1000是假赋值，此值会因环境的不同而异。数组是属于非基本数据类型，因此数组变量score所保存的并非是数组的元素值，而是数组元素的首地址。

除了可以用两行来声明并分配内存给数组之外，也可以用较为简洁的方式，把两行缩成一行来编写，其格式如下：

数据类型数组名[] = new数据类型[个数];

或

数据类型[] 数组名= new数据类型[个数];

上述的格式会在声明的同时，即分配一块内存空间，供该数组使用。下面的范例是声明整型数组score，并开辟可以保存10个整数的内存给score变量。

int score[] = new int[10]; 或int[] score = new int[10];

//声明一个元素个数为10的整型数组score，同时开辟一块内存空间供其使用

在Java中，由于整数数据类型所占用的空间为4个bytes，而整型数组score可保存的元素有10个，所以上例中占用的内存共有4 * 10 = 40个字节。图3-3是将数组score用图形来表示，可以比较容易理解数组的保存方式。

图3-3 数组的保存方式

3.1.2 数组中元素的表示方法

想要使用数组里的元素，可以利用索引下标来完成。格式如下：

数组名[index];

Java的数组索引编号由0开始，长度为n的数组的合法下标取指范围为：0~(n-1)。以上一节中的score数组为例，score[0]代表第1个元素，score[1]代表第2个元素，score[9]为数组中第10个元素（也就是最后一个元素）。图3-4为score数组中元素的表示法及排列方式：

图3-4 数组中元素的排列

注意：数组下标不要越界。

接下来，看一个范例。下面的程序里，声明了一个一维数组，其长度为3，利用for循环输出数组的内容后，再输出数组的元素个数。

范例：TestJava3_1.java

//下面这段程序说明了一维数组的使用方法

public class TestJava3_1

{

public static void main(String args[])

{

int i;

int a[]; // 声明一个整型数组a

a=new int[3]; // 开辟内存空间供整型数组a使用，其元素个数为3

for(i = 0; i < 3; i++) // 输出数组的内容

System.out.print("a["+i+"] = "+a[i]+",\t");

System.out.println("\n数组长度是："+a.length); // 输出数组长度

}

}

输出结果：

a[0] = 0, a[1] = 0, a[2] = 0,

数组长度是：3

程序说明：

1、第7行声明整型数组a；第8行开辟了一块内存空间，以供整型数组a使用，其元素个数为3。

2、第9~10行，利用for循环输出数组的内容。由于程序中并未给予数组元素赋值，因此输出的结果都是0。

3、第11行输出数组的长度。此例中数组的长度是3，即代表数组元素的个数有3个。要特别注意的是，在Java中取得数组的长度（也就是数组元素的个数）可以利用“.length”完成，如下面的格式：

数组名.length

也就是说，若是要取得TestJava3_1中所声明的数组a的元素个数，只要在数组a的名称后面加上“.length”即可，如下面的程序片段：

a.length; //取得数组a的长度

3.1.3 数组的静态初始化

如果想直接在声明时就给数组赋初值，可以利用大括号完成。只要在数组的声明格式后面再加上初值的赋值即可，如下面的格式：

数据类型数组名[] = new 数据类型[]{初值0, 初值1, …, 初值n};

或简写成：

数据类型数组名[] = {初值0, 初值1, …, 初值n};

在大括号内的初值会依序指定给数组的第1、…、n+1个元素。此外，在声明的时候，不需要将数组元素的个数列出，编译器根据所给出的初值个数来判断数组的长度。如下面的数组声明及赋初值范例：

int data[] = new int[]{32, 23, 45, 22, 13, 45, 78, 96, 43, 32}; // 数组声明并赋初值或：

int data[] = {32, 23, 45, 22, 13, 45, 78, 96, 43, 32}; // 数组声明并赋初值在上面的语句中，声明了一个整型数组data，虽然没有特别指明数组的长度，但是由于大括号里的初值有10个，编译器会分别依序指定给各元素存放，data[0]为32，data[1]为23，…，data[9]为32。

范例：TestJava3_2.java

//一维数组的赋值，这里采用静态初始化方式赋值

public class TestJava3_2

{

public static void main(String args[])

{

int i = 0;

int a[] = {5, 6, 8}; // 声明一个整数数组a并赋初值

for(i=0; i

System.out.print("a["+i+"]="+a[i]+",\t");

System.out.println("\n数组长度是："+a.length);

}

}

输出结果：

a[0]=5, a[1]=6, a[2]=8,

数组长度是：3

除了在声明时就赋初值之外，也可以在程序中为某个特定的数组元素赋值。可以将程序TestJava3_2的第7行更改成下面的程序片段：

int a [] = new int[3];

a[0] = 5;

a[1] = 6;

a[2] = 8;

通常数组的遍历都需要用到循环，从数组下标0开始一直到a.length为止，输出数组的每个元素。除此之外，数组的遍历还可以利用一种特殊的手段来实现，将TestJava3_2.java 改造之后如下：

int a[] = new int[]{5, 6, 8};

for(int iVal : a)//for_each结构，此时iVal表示具体的数组元素

System.out.print(iVal + "\t");

System.out.println("\n数组长度是：" + a.length);

3.1.4 简单的范例：找出数组元素中的最大值与最小值

由前几节的范例可知，数组的索引就好象饭店房间的编号一样，想要找到某个房间时，就得先找到房间编号！接下来再举一个例子，说明如何将数组里的最大值及最小值列出。算法思路：

打擂台方法：将变量min与max初值设成数组的第一个元素后，再逐一与数组中的各元素相比。比min小，就将该元素的值指定给min存放，使min的内容保持最小；同样的，当该元素比max大时，就将该元素的值指定给max存放，使max的内容保持最大。for循环执行完，也就表示数组中所有的元素都比较完毕，此时变量min与max的内容就是最小值与最大值。

范例：TestJava3_3.java

//这个程序主要是求得数组中的最大值和最小值

public class TestJava3_3

{

public static void main(String args[])

{

int i, min, max;

int A[] = {74, 48, 30, 17, 62}; // 声明整数数组A,并赋初值

min = max = A[0];

System.out.print("数组A的元素包括：");

for(i=0; i

{

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

if(A[i] > max) // 判断最大值

max = A[i];

if(A[i] < min) // 判断最小值

min = A[i];

}

System.out.println("\n数组的最大值是："+max); // 输出最大值

System.out.println("数组的最小值是："+min); // 输出最小值

}

}

输出结果：

数组A的元素包括：74 48 30 17 62

数组的最大值是：74

数组的最小值是：17

程序说明：

1、第6行声明整数变量i 做为循环控制变量及数组的索引，另外也声明存放最小值的变量min与最大值的变量max。

2、第7行声明整型数组A，其数组元素有5个，其值分别为74、48、30、17、62。

3、第8行将min与max的初值设为数组的第一个元素。

4、第9~17行逐一输出数组里的内容，并判断数组里的最大值与最小值。

5、第18~19行输出比较后的最大值与最小值。

3.1.5 与数组操作有关的API 方法

在Java语言中提供了许多的API方法，供开发人员使用，java提供的java.util 包里面的Arrays类包含一些静态修饰方法可以直接操作数组。比如：

binarySearch：使用二分搜索法查找元素出现的索引位置、如果没有搜索到就返回一个负数

copyOf：复制指定的数组，截取或用0填充

copyOfRange：将指定数组的指定范围复制到一个新数组

equals：判断两个指定的数据数组彼此是否相等

fill：将指定的值分配给指定数组的每个元素

sort：对指定的数组按数字升序进行排序

下面先介绍两种常用的数组操作方法，一个是数组的拷贝操作，另一个是数组的排序操

作。其它的操作请自行查阅JDK帮助文档。

范例：TestJava3_4.java

//以下这段程序说明数组的拷贝操作

public class TestJava3_4

{

public static void main(String[] args)

{

int a1[] = {1, 2, 3, 4, 5}; // 声明两个整型数组a1、a2，并进行静态初始化

int a2[] = {9, 8, 7, 6, 5, 4, 3};

System.arraycopy(a1, 0, a2, 0, 3); // 执行数组拷贝的操作

System.out.print("a1数组中的内容：");

for(int i=0; i

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

System.out.println();

System.out.print("a2数组中的内容：");

for(int i=0; i

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

System.out.println("\n数组拷贝完成！");

}

}

输出结果：

a1数组中的内容：1 2 3 4 5

a2数组中的内容：1 2 3 6 5 4 3

数组拷贝完成！

System.arraycopy(source, 0, dest, 0, x);语句的意思就是：复制源数组从下标0开始的x 个元素到目标数组，从目标数组的下标0所对应的位置开始存取。

范例：TestJava3_5.java

//以下程序是数组的排序操作，在这里使用了sort方法对数组进行排序

import java.util.*;

public class TestJava3_5

{

public static void main(String[] args)

{

int a[] = {4, 32, 45, 32, 65, 32, 2};

System.out.print("数组排序前的顺序：");

for(int i=0; i

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

Arrays.sort(a); // 数组的排序方法

System.out.print("\n数组排序后的顺序：");

for(int i=0; i

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

}

}

输出结果：

数组排序前的顺序：4 32 45 32 65 32 2

数组排序后的顺序：2 4 32 32 32 45 65

程序第12行的Arrays.sort(数组名)为数组排序的操作，但这个方法在java.util这个包里面，所以在用到的时候需要先将它导入，至于包的概念，以后章节会讲到。·binarySearch

以int型为例，其它数据类型类似。

函数原型如下：

public static int binarySearch(int[] a, int key);

使用二分搜索法来搜索指定的int型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过sort(int[]) 方法）。如果没有对数组进行排序，则结果是负的。

如果数组包含多个带有指定值的元素，则返回的是第一个找到的下标。

public static int binarySearch(int[] a, int fromIndex, int toIndex, int key);

使用二分搜索法来搜索指定的int型数组的范围，以获得指定的值。必须在进行此调用之前对范围进行排序（通过sort(int[], int, int) 方法）。如果没有对范围进行排序，则结果是负的。如果范围包含多个带有指定值的元素，则返回的是第一个找到的下标。

参数：

a - 要搜索的数组

fromIndex - 要搜索的第一个元素的索引（包括）

toIndex - 要搜索的最后一个元素的索引（不包括）

key - 要搜索的值

返回：

如果它包含在数组中，则返回搜索键的索引；否则返回(-(插入点) - 1)。插入点被定义为将键插入数组的那一点：即第一个大于此键的元素索引，如果数组中的所有元素都小于指定的键，则为 a.length。注意，这保证了当且仅当此键被找到时，返回的值将>= 0。

实例如下：

int iNum = 3;

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

Arrays.sort(A);

int index = Arrays.binarySearch(A, iNum);

//或：

// Arrays.sort(A, 0, A.length);

//int index = Arrays.binarySearch(A, 0, A.length, iNum); //[0, A.length)

System.out.println(index);

if(index < 0)

System.out.println("找不到该元素~");

else

System.out.println("找到，元素的下标为:" + index);

·copyOf

以int型为例，其它数据类型类似。

函数原型如下：

public static int[] copyOf(int[] original, int newLength);

复制指定的数组，截取或用0填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效

而在原数组无效的所有索引，副本将包含0。当且仅当指定长度大于原数组的长度时，这些索引存在。

参数：

original - 要复制的数组

newLength - 要返回的副本的长度

返回：

原数组的副本，截取或用0 填充以获得指定的长度

抛出：

NegativeArraySizeException - 如果newLength 为负

NullPointerException - 如果original 为null

实例如下：

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

int B[] = Arrays.copyOf(A, 14);

for(int iVal : B)

System.out.println(iVal);

·copyOfRange

以int型为例，其它数据类型类似。

函数原型如下：

public static int[] copyOfRange(int[] original, int from, int to);

将指定数组的指定范围复制到一个新数组。该范围的初始索引(from)必须位于0和original.length（包括）之间。original[from]处的值放入副本的初始元素中（除非from == original.length或from == to）。原数组中后续元素的值放入副本的后续元素。该范围的最后索引to（必须大于等于from）可以大于original.length，在这种情况下，0被放入索引大于等于original.length - from的副本的所有元素中。返回数组的长度为to - from。

参数：

original - 将要从其复制一个范围的数组

from - 要复制的范围的初始索引（包括）

to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。

返回：

包含取自原数组指定范围的新数组，截取或用0 填充以获得所需长度抛出：

ArrayIndexOutOfBoundsException - 如果from < 0 或from > original.length()

IllegalArgumentException - 如果from > to

NullPointerException - 如果original为null

实例如下：

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

int B[] = Arrays.copyOfRange(A, 2, 14);

for(int iVal : B)

System.out.println(iVal);

·equals

以int型为例，其它数据类型类似。

函数原型如下：

public static boolean equals(int[] a, int[] a2);

如果两个指定的int型数组彼此相等，则返回true。如果两个数组包含相同数量的

元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为null，则认为它们是相等的。

参数：

a - 将测试其相等性的一个数组

a2 - 将测试其相等性的另一个数组

返回：

如果两个数组相等，则返回true

示例如下：

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

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

System.out.println(Arrays.equals(A, B));

·fill

以int型为例，其它数据类型类似。

函数原型如下：

public static void fill(int[] a, int val)

将指定的int值分配给指定int型数组的每个元素。

public static void fill(int[] a, int fromIndex, int toIndex, int val)

将指定的int值分配给指定int型数组指定范围中的每个元素。填充的范围从索引fromIndex（包括）一直到索引toIndex（不包括）。（如果fromIndex==toIndex，则填充范围为空。）

参数：

a - 要填充的数组

fromIndex - 要使用指定值填充的第一个元素的索引（包括）

toIndex - 要使用指定值填充的最后一个元素的索引（不包括）

val - 要存储在数组所有元素中的值

抛出异常：

IllegalArgumentException - 如果fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果fromIndex < 0 或toIndex > a.length 实例如下：

int A[] = new int[10];

Arrays.fill(A, 1);

//或：Arrays.fill(A, 0, A.length, 1);

for(int iVal : A)

System.out.println(iVal);

3.2 二维数组

虽然一维数组可以处理一般简单的数据，但是在实际的应用上仍显不足，所以Java也提供了二维数组以及多维数组供程序设计人员使用。学会了如何使用一维数组后，再来看看二维数组的使用方法。

3.2.1 二维数组的声明与分配内存

二维数据就是一个表格或一个矩阵，可以把它想象成一个行列表。

二维数组声明的方式和一维数组类似，内存的分配也一样是用new这个关键字。其声

明与分配内存的格式如下所示：

数据类型数组名[][]; 或数据类型[][] 数组名;

数组名= new 数据类型[行的个数][列的个数];

“行的个数”是告诉编译器所声明的数组有多少行，“列的个数”则是说明该数组有多少列，如下面的范例：

int score[][] ; // 声明整型数组score

score = new int[4][3] ; // 分配一块内存空间，供4行3列的整型数组score使用

同样的，可以用较为简洁的方式来声明数组，其格式如下：

数据类型数组名[][] = new 数据类型[行的个数][列的个数];

或：

数据类型[][] 数组名= new 数据类型[行的个数][列的个数];

若用上述的写法，则是在声明的同时，就开辟了一块内存空间，以供该数组使用。范例如下：

int score[][] = new int[4][3] ; //声明整型数组score，同时为其开辟一块内存空间上面的语句中，整型数据score可保存的元素有4*3=12个，而在Java中，int数据类型所占用的空间为4个字节，因此该整型数组占用的内存共为4*12=48个字节。则此时的二维数组相当于一个4行3列的二维表，如图3-5：

图3-5 二维表

如果想直接在声明时就为数组赋初值，可以利用大括号完成。只要在数组的声明格式后面再加上所赋初值即可，如下面的格式：

数据类型数组名[][] = new 数据类型[][]{

{第0行初值},

{第1行初值},

…,

{第n行初值},

};

或简写成：

数据类型数组名[][] = {

{第0行初值},

{第1行初值},

…,

{第n行初值},

};

要特别注意的是，用户不需要定义数组的长度，因此在数组名后面的中括号里不必填入任何的内容。此外，在大括号内还有几组大括号，每组大括号内的初值会依序指定给数组的第0、1、…、n行元素。如下面的关于数组num声明及赋初值的范例：

int num[][] = new int[][]{ // 二维数组的初始化

{23, 45, 21, 45},

{45, 23, 46, 23}

};

或：

int num[][] = { // 二维数组的初始化

{23, 45, 21, 45},

{45, 23, 46, 23}

};

在上面的语句中，声明了一个整型数组num，数组有2行4列共8个元素，大括号里的几组初值会分别依序指定给各行里的元素存放，num[0][0]为23，num[0][1]为45，…，num[1][3]为23。

3.2.1.1 每行的元素个数不同的二维数组

值得一提的是Java允许二维数组中每行的元素个数均不相同，这点与一般的程序语言是不同的。例如，下面的语句是声明整型数组num并赋初值，而初值的赋值指明了num具有三行元素，其中第一行有4个元素，第二行有3个元素，第三行则有5个元素：int num[][] = {

{42, 54, 34, 67},

{33, 34, 56},

{12, 34, 56, 78, 90}

};

或采用下面的方法动态初始化：

int a[][] = new int[4][]; //列利用循环动态分配

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

{

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

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

a[i][j] = i*j;

}

3.2.1.2 取得二维数组的行数与特定行的元素的个数

在二维数组中，若是想取得整个数组的行数，或者是某行元素的个数时，可利用“.length”来获取，其语法如下：

数组名.length // 取得数组的行数

数组名[行的索引].length // 取得特定行元素的个数

也就是说，如要取得二维数组的行数，只要用数组名加上“.length”即可；如要取得数组中特定行的元素的个数，则须在数组名后面加上该行的索引值，再加上“.length”，如下面的程序片段：

num.length; // 计算数组num的行数，其值为3

num[0].length // 计算数组num的第1行元素的个数，其值为4

num[2].length // 计算数组num的第3行元素的个数，其值为5

3.2.2 二维数组元素的引用及访问

二维数组元素的输入与输出方式与一维数组相同，看下面这个范例：

范例：TestJava3_6.java

//二维数组的使用说明，这里采用静态赋值的方式

public class TestJava3_6

{

public static void main(String args[])

{

int i, j, sum = 0;

int num[][] = {

{30, 35, 26, 32},

{33, 34, 30, 29}

}; // 声明数组并设置初值

for(i=0; i

{

System.out.print("第"+(i+1)+" 个人的成绩为：");

for(j=0; j

{

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

sum += num[i][j];

}

System.out.println();

}

System.out.println("\n总成绩是"+sum+" 分！");

}

}

输出结果：

第1 个人的成绩为：30 35 26 32

第2 个人的成绩为：33 34 30 29

总成绩是249 分！

程序说明：

1、第6行声明整数变量i、j 做为外层与内层循环控制变量及数组的索引，i 控制行的元素，j 控制列的元素；而sum则使用来存放所有数组元素值的和，也就是总成绩。

2、第7行声明一整型数组num，并为数组元素赋初值，该整型数组共有8个元素。

3、第8~17行输出数组里各元素的内容，并进行成绩汇总。

4、第18行输出sum的结果即为总分。

与一维数组类似，也可以采用for_each结构输出二维数组的所有元素：

for(int[] i : num)

{

for(int iVal : i)

{

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

sum += iVal;

}

System.out.println();

}

System.out.println("\n总成绩是"+sum+" 分！");

3.3 多维数组

经过前面一、二维数组的练习后不难发现，想要提高数组的维数，只要在声明数组的时候将索引与中括号再加一组即可，所以三维数组的声明为int A[][][]，而四维数组为int A[][][][] ……，以此类推。

使用多维数组时，输入、输出的方式和一、二维相同，但是每多一维，嵌套循环的层数就必须多一层，所以维数越高的数组其复杂度也就越高。以三维数组为例，在声明数组时即赋初值，再将其元素值输出并计算总和。

范例：TestJava3_7.java

//下面程序说明了三维数组的使用方法，要输出数组的内容需要采用三重循环

public class TestJava3_7

{

public static void main(String args[])

{

int sum=0;

int A[][][] = {

{{5,1}, {6,7}},

{{9,4}, {8,3}}

}; // 声明数组并设置初值

// 三维数组的输出需要采用三层for循环方式输出

for(int i = 0; i < A.length; i++) // 输出数组内容并计算总和

{

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

{

for(int k = 0; k < A[i][j].length; k++)

{

System.out.println("A["+i+"]["+j+"]["+k+"]=" + A[i][j][k]);

sum += A[i][j][k];

}

}

}

System.out.println("sum="+sum);

}

}

输出结果：

A[0][0][0]=5

A[0][0][1]=1

A[0][1][0]=6

A[0][1][1]=7

A[1][0][0]=9

A[1][0][1]=4

A[1][1][0]=8

A[1][1][1]=3

sum=43

由于使用的是三维数组，所以嵌套循环有三层。如果利用for_each遍历，则如下：for(int[][] i : A)

{

for(int[] j : i)

{

for(int iVal : j)

{

System.out.println(iVal);

sum += iVal;

}

}

}

3.4 引用类型数组

对象数组概念应用几乎与数组一致，不同的是，对象数组是一组相同类型对象而组成的集合，因此初始化时，对象的默认值是null。

与基本数据类型数组一样，对象数组的声明和初始化采取的方法类似，如下：类名称[] 对象数组名称= new 类名称[对象个数]

使用方法与基本数据类型数组类似。例如：要取得对象数组的长度也是使用对象数组名称.length。

3.5 浅拷贝与深拷贝

浅拷贝是直接定义一个新的数组变量等于原始数组变量。

实例如下：

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

int b[] = a;

b[3] = 9;

for(int iVal : a)

System.out.println(iVal);

此时输出数组a的所有元素，发现a[3]也变为了9。因为b和a指向同一个内存空间。这种数组赋值方式称为浅拷贝。

在一维数组中，我们介绍了System类的arraycopy可以实现将一维数组的所有元素拷贝到另一个一维数组中，相当于是将数据“克隆”了一份，而不是复制一个变量，让两个变量来引用同一个数组，保存数据的独立性。这就是深拷贝。

实例如下：

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

int b[] = new int[4];

System.arraycopy(a, 0, b, 0, b.length);

b[3] = 9;

for(int iVal : a)

System.out.println(iVal);

此时输出数组a的所有元素，发现a[3]仍为4。因为b和a指向不同的堆空间。这种数组赋值的方式称为深拷贝。

如果是二维数组，则示例如下：

public class TestJava

{

public static void main(String[] args) {

int[][] source = new int[5][]; // 定义源数组

// 给源数组赋值

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

source[i] = new int[i + 1];

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

source[i][j] = j + 1;

}

// 打印源数组的数据

System.out.println("-------------源数据-------------");

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

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

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

System.out.println();

}

// 定义目的数组

int[][] target1 = source; //浅拷贝

//如果只拷贝一维，也是浅拷贝

//int[][] target1 = new int[5][];

//System.arraycopy(source, 0, target1, 0, source.length);

// 改变目的1数组的值

target1[1][0] = 100;

// 打印源数组的信息,可以看到值改变，说明没有深拷贝

System.out.println("-----------浅拷贝后输出-----------");

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

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

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

System.out.println();

}

int[][] target2 = new int[5][];

// 数组的深拷贝，先拷贝"第一维"的

System.arraycopy(source, 0, target2, 0, source.length);

// 再深拷贝

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

target2[i] = new int[i + 1];

System.arraycopy(source[i], 0, target2[i], 0, i + 1);

}

// 改变目的2数组的数据

target2[1][0] = 999;

// 打印源数组的信息，可以看到值没有改变，说明是深拷贝

System.out.println("-----------深拷贝后输出未把100改成999-----------");

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

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

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

System.out.println();

}

}

}

3.6 方法

方法可以简化程序的结构，也可以节省编写相同程序代码的时间，达到程序模块化的目的。在每一个类里出现的main()即是一个方法。使用方法来编写程序代码有相当多的好处，它可简化程序代码、精简重复的程序流程，并把具有特定功能的程序代码独立出来，使程序的维护成本降低。

在面向对象的世界里，方法只能作为类和对象的附属，不能独立定义，只能在类里面定义。方法要么属于一个类，要么属于一个对象。方法不能独立执行，执行方法必须使用类或者对象作为调用者。

方法分为两种：

普通方法（对象的方法）：没有static关键字修饰的方法

静态方法（类的方法）：使用static关键字修饰的方法

方法的定义格式：

方法名称规则：第一个单词的字母小写，以后每个单词的首字母大写。如果不需要传递参数到方法中，只要将括号写出，不必填入任何内容。此外，如果方法没有返回值，则返回值类型要指明为void，return语句可以省略或写成“return;”。

类中方法的定义示例如下：

类中方法的调用：

普通方法（对象的方法）：通过类的实例化对象来调用

静态方法（类的方法）：通过类来调用

3.6.1 方法操作的简单范例

TestJava3_8是一个简单的方法操作范例，它在显示器上先输出19个星号“*”，换行之后再输出“I Like Java！”这一字符串，最后再输出19个星号。

范例：TestJava3_8.java

//以下程序主要说明如何去声明并使用一个方法

public class TestJava3_8

{

public static void main(String args[])

{

star(); // 调用star() 方法

System.out.println("I Like Java !");

star(); //调用star() 方法

}

public static void star() // star() 方法

{

for(int i=0;i<19;i++)

System.out.print("*"); // 输出19个星号

System.out.print("\n"); // 换行

}

}

输出结果：

*******************

I Like Java !

*******************

TestJava3_8中声明了两个方法，分别为main()方法与star()方法。因为main()方法是程序进入的起点，所以把调用star()的程序代码编写在main()里。在main()的第6行调用start() 方法，此时程序的运行流程便会进到10~15行的star()方法里执行。执行完毕后，程序返回main()方法，继续运行第7行，输出“I Like Java ！”字符串。接着第8行又调用sart()方法，程序再度进到第10~15行的star()方法里运行。运行完后，返回main()方法里，因main()方法接下来已经没有程序代码可供执行，于是结束程序TestJava3_8。

从本程序中，可以很清楚地看出，当调用方法时，程序会跳到被调用的方法里去运行，

结束后则返回原调用处继续运行。在TestJava3_8中，调用与运行star()方法的流程如图3-6所示：

图3-6 调用与运行star()方法的流程

star()方法并没有任何返回值，所以star()方法前面加上了一个void关键字。此外，因为star()没有传递任何的参数，所以star()方法的括号内保留空白即可。

至于在star()方法之前要加上static关键字，这是因为main()方法本身也声明成static，而在static方法内只能访问到static成员变量（包括数据成员和方法成员），因star()方法被main()方法所调用，自然也要把star()声明成static才行。此时如果还不了解static的真正用意也没有关系，将在以后的章节对static关键字做详尽的介绍。

3.6.2 方法的参数传递与返回值

如果方法有返回值，则在声明方法之前就必须指定返回值的数据类型。相同的，如果有参数要传递到方法内，则在方法的括号内必须填上该参数及其类型。

TestJava3_9是一个关于计算长方形对角线长度的范例，其中show_length()方法可接收长方形的宽与高，计算后返回对角线的长度。

范例：TestJava3_9.java

//以下的程序说明了方法的使用

public class TestJava3_9

{

public static void main(String args[])

{

double num;

num=show_length(22, 19); // 输入22与19两个参数到show_length()里

System.out.println("对角线长度= "+num);

}

public static double show_length(int m, int n)

{

return Math.sqrt(m*m + n*n); // 返回对角线长度

}

}

输出结果：

对角线长度= 29.068883707497267

TestJava3_9的第7行调用show_length(22,19)，把整数22和19传入show_length()方法中。第12行则利用Math类里的sqrt()方法计算对角线长度。而sqrt(n)的作用是将参数n开根号。因sqrt()的返回值是double类型，因此show_length()返回值也是double类型。

Java中参数传递实质是值传递。Java中进行赋值操作或函数调用中传递参数时，遵循

值传递的原则：

基本类型数据传递的是该数据的值本身

引用类型数据传递的是对对象的引用（句柄），而非对象本身

只有引用类型数据传递方式才能将数据写回（传出）。

范例：TestJava3_10.java

public class TestJava3_10

{

public static void main(String[] args)

{

int x = 10;

int y = 20;

System.out.println("main:x="+x+"\ty="+y);

swith(x, y);

System.out.println("main:x="+x+"\ty="+y);

int arr[] = {10, 20};

System.out.println("main:x=" + arr[0] + "\ty=" + arr[1]);

change(arr);

System.out.println("main:x=" + arr[0] + "\ty=" + arr[1]);

}

public static void swith(int x, int y){

x=x+y;

y=x-y;

x=x-y;

System.out.println("swith:x="+x+"\ty="+y);

}

public static void change(int a[]){

a[0] = (a[0] + a[1]) - (a[1] = a[0]);

System.out.println("change:x="+a[0]+"\ty="+a[1]);

}

}

3.6.3 将数组传递到方法里

方法不只可以用来传递一般的变量，也可用来传递数组。本节将讲述在Java里是如何传递数组以及如何处理方法的返回值是一维数组的问题。

3.6.3.1 传递一维数组

要传递一维数组到方法里，只要指明传入的参数是一个数组即可。TestJava3_11是传递一维数组到largest()方法的一个范例，当largest()接收到此数组时，便会把数组的最大值输出。

范例：TestJava3_11.java

//一维数组作为参数来传递，这里的一维数组采用静态方式赋值

public class TestJava3_11

{

public static void main(String args[])

{

int score[] = {7, 3, 8, 19, 6, 22}; // 声明一个一维数组score

// 将一维数组score传入largest()方法中，并将最大值返回来

System.out.println("最大的数= " + largest(score));

}

public static int largest(int arr[])

{

int tmp = arr[0];

for(int i=0; i

if(tmp < arr[i])

tmp = arr[i];

return tmp;

}

}

输出结果：

最大的数= 22

TestJava3_11的第10~17行声明largest()方法，并将一维数组作为该方法的参数。第12~16行找出数组的最大值，并将它返回。注意如果要传递数组到方法里，只要在方法内填上数组的名称即可，如本题的第8行所示。

3.6.3.2 传递二维数组

二维数组的传递与一维数组相当类似，只要在方法里声明传入的参数是一个二维数组即可。程序TestJava3_12是有关传递二维数组的一个范例，把二维数组A传递到print_mat()方法里，并在print_mat()方法里把该数组值输出。

范例：TestJava3_12.java

//以下程序说明了如何将一个二维数组作为参数传递到方法中

public class TestJava3_12

{

public static void main(String args[])

{

int A[][]={{51,38,22,12,34}, {72,64,19,31}}; // 定义一个二维数组A

print_mat(A);

}

public static void print_mat(int arr[][]) // 接收整数类型的二维数组

{

for(int i=0; i

{

for(int j=0; j

System.out.print(arr[i][j]+" "); // 输出数组值

System.out.print("\n"); // 换行

}

}

}

Java数组与Java基础类实验报告

西安邮电大学 （计算机学院） 课内实验报告 实验名称：数组与Java基础类 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.10.27

一、实验目的 掌握Java中的数组定义、引用，掌握String类和StringBuffer类的使用。 二、实验要求 1．编写一个使用Java 数组的的程序。 2．编写一个使用String类的程序。 3．编写一个使用StringBuffer类的程序。 三、实验内容 (一) 使用数组求Fibonacci数列前10项之和 1.编写程序。 public class Fibonacci { public static void main(String args[]){ int i=0,j=1,s=0; for(int n=1;n<=5;n++){ s+=(i+j); i = (int)(i+j); j = (int)(i+j); } System.out.print("前10项之和是："+s); } } 2.编译并运行程序。 （二）练习String类的常用方法 ?实验要求： 编写一个Java应用程序，判断两个字符串是否相同，判断字符串的前缀、后缀是否和某个字符串相同，按字典顺序比较两个字符串的大小关系，检索字符串，创 建字符串，将数字型字符串转换为数字，将字符串存放到数组中，用字符数组创建 字符串。。 ?程序模板： StringExample.java class StringExample { public static void main(String args[]) { String s1=new String("you are a student"),s2=new String("how are you"); if(【代码1】) // 使用equals方法判断s1与s2是否相同 { System.out.println("s1与s2相同"); }

JAVA类与对象及数组习题及答案

JAV A类和对象及数组习题 一、选择题 （1）下列构造方法的调用方式中，正确的是（D ）--原因：在通过new实例化一个类对象时系统会自动调用该类相应的构造方法。 A．按照一般方法调用B．由用户直接调用 C．只能通过new自动调用D．被系统调用 （2）在Java中，能实现多重继承效果的方式是（C ）--原因：一个类可以同时实现多个接口。Java接口反映了对象较高层次的抽象，还弥补了Java只支持单继承的不足，可用它来完成多继承的一些功能。 A．内部类B．适配器C．接口D．同步 （3）int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( D )—原因：java中定义常量用关键字final来定义。 A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100 C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100 （4）下列叙述中，正确的是( A )—原因：Java严格区分大小写，所以变量number 与Number不相同；Java 中的注释方式除了“//”行注释之外还有段注释“/*-------*/”和文档注释/**-------*/。Java源文件中的public类只能有一个。 A. 声明变量时必须指定一个类型 B. Java认为变量number与Number相同 C. Java中唯一的注释方式是"//" D. 源文件中public类可以有0或多个 （5）下列叙述中，错误的是( D )—原因：子类继承父类，并且可以有自己的成员变量和成员方法。所以可以认为子类是父类的扩展。

Java类 类型的数组创建与使用方法

Java类数组的使用方法一 注意一定要把类数组的每一个元素都赋值，否则就报错，既对类数组对象的一空声明，如果并没有实例化，会报空指针异常：NullPointerException 1.创建类类型的数组方法一： 创建一个Person类，在main方法中创建p1,p2,p3,p4 几个Person 类的实例化对象。然后再使用如下代码创建类类型的数组p。Product [] p=new Product[]{p1,p2,p3,p4}; public class Test { public static void main(String[] args) { Product p1=new Product(); https://www.wendangku.net/doc/3617501203.html,="豆浆机"; Product p2=new Product(); https://www.wendangku.net/doc/3617501203.html,="电视机"; Product p3=new Product(); Product p4=new Product(); Product [] p=new Product[]{p1,p2,p3,p4};//创建类类型的数组方法一 for(int i=0;i

} } class Product{ int Num; String name; } 2.创建类类型的数组方法二： public class Test { public static void main(String[] args) { Product p1=new Product(); Product p2=new Product(); Product p3=new Product(); Product p4=new Product(); Product [] p={p1,p2,p3};//创建类类型的数组方法二for(int i=0;i

Java_数组练习题目

一填空题 1)数组的元素通过数组下标来访问，数组Array的长度为元素的个数 （Array.length）。 2)Java中数组的下标的数据类型是整形。 3)不用下标变量就可以访问数组的方法是数组名。 4)数组最小的下标是0 。 5)arraycopy()的最后一个参数指明复制元素的个数。 6)向方法传递数组参数时，传递的是数组的引用。 7)数组初始化包括数组的声明，创建，初始化。 8)数组下标访问超出索引范围时抛出数组越界异常 9)浮点型数组的默认值是0.0f 。 10)对象型数组的默认值是null 。 二选择题 1.下面错误的初始化语句是_A B D__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是_B_ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是__B__ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是__D__ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为__C__ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是_B___ A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; C. char str[5]={"hi"}; D. char str[100]=""; 7.数组在Java中储存在 C 中 A. 栈 B. 队列 C. 堆 D. 链表

java数组的概念和作用

1 数组的概念 和其他语言一样，Java也提供数组支持，数组是属于引用类型，即数组是一个 对象。 强调数组的类型是引用类型。 数组的基本概念及作用 数组是相同数据类型元素的集合 数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类型。 数组的举例 int [] a = new int []{1,2,3,4,5}; String [] s = new String []{"小熊","小小熊","小小小熊"}; Employee [] e=new Employee[10];（Employee是自定义类） 2 数组的声明 数组的声明的两种方式： 数据类型 [] 数组名字例如：int [] a; 数据类型数组的名字 [] 例如： int a []; 注意： 在Java语言中两种声明方法没有任何区别，但是建议大家用第一种，避免混淆a的数据类型。 数组在声明后还只是一个空指针，不能使用，要想使用必须创建。 数组创建的三种方式：

?//声明数组的同时，根据指定的长度分配内存，但数组中元素值都为默认的初始化值 char[] chAry = new char[10]; ?//声明数组并分配内存，同时将其初始化 ?int[] ary1 = new int[]{1, 2, 3, 4, 5}; ?//与前一种方式相同，仅仅只是语法相对简略 ?int[] ary2 = {1, 2, 3, 4, 5}; 从另一个角度，数组创建可以分为动态和静态两种 动态创建数组（没有为元素赋值，可以结合for循环进行赋值） char[] chAry = new char[10]; 静态创建数组，在创建的时候，即为每个元素赋初值 int[] ary1 = new int[]{1, 2, 3, 4, 5}; 数组的长度 数组的长度：length属性 int [] b1 = new int []{1,2,3,4,5,6,7}; System.out.println(b1.length); 注意：数组的长度是属性，String的长度是length（）； 创建数组的时候必须指定数组的长度，而且一经定义则不允许改变。 数组的长度虽然是7，但是在内存中实际给8个位置，另外一个存储7. 数组之间赋值 在C语言中，不可以将数组直接赋值给另一个数组；

Java数组练习题(带答案)

一填空题 1)数组的元素通过下标来访问，数组Array的长度为Array.length 。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是0 。 7)arraycopy()的最后一个参数指明复制元素的个数。 8)向方法传递数组参数时，传递的是数组的引用。 9)数组初始化包括数组的申明，创建和初始化。 10)数组下标访问超出索引范围时抛出数组越界异常 11)浮点型数组的默认值是0.0f 。 12)数组创建后其大小不能改变。 二选择题 1.下面错误的初始化语句是_ABD__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是_B__ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是____ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是_D___ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是__B__ A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; C. char str[5]={"hi"}; D. char str[100]=""; 7.数组在Java中储存在 C 中 A. 栈 B. 队列 C. 堆 D. 链表 8.下面程序的运行结果是____ main() { int a[][]={{1,2,3},{4,5,6}}; System.out.printf("%d", a[1][1]); } A. 3 B. 4 C. 5 D. 6 9.下面程序的运行结果是_C___ main() {

JAVA数组与List之间相互转换的方法详解

数组与List之间相互转换的方法详解 1.List转换成为数组。（这里的List是实体是ArrayList) 调用ArrayList的toArray方法。 toArray public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时类型。如果列表能放入指定的数组，则返回放入此列表元素的数组。否则，将根据指定数组的运行时类型和此列表的大小分配一个新的数组。 如果指定的数组能容纳列表并有剩余空间（即数组的元素比列表的多），那么会将数组中紧跟在集合末尾的元素设置为null。这对确定列表的长度很有用，但只在调用方知道列表中不包含任何null 元素时才有用。 指定者： 接口Collection 中的toArray 指定者： 接口List 中的toArray 覆盖： 类AbstractCollection 中的toArray 参数： a - 要存储列表元素的数组，如果它足够大的话；否则，它是一个为存储列表元素而分配的、具有相同运行时类型的新数组。 返回： 包含列表元素的数组。 抛出： ArrayStoreException - 如果a 的运行时类型不是此列表中每个元素的运行时类型的超类型。 具体用法： 复制代码代码如下: List list = new ArrayList(); list.add("1");

list.add("2"); finalint size = list.size(); String[] arr = (String[])list.toArray(new String[size]); 2.数组转换成为List 调用Arrays的asList方法. JDK 1.4对java.util.Arrays.asList的定义，函数参数是Object[]。所以，在1.4中asList()并不支持基本类型的数组作参数。 JDK 1.5中，java.util.Arrays.asList的定义，函数参数是Varargs, 采用了泛型实现。同时由于autoboxing 的支持，使得可以支持对象数组以及基本类型数组。 不过在使用时，当传入基本数据类型的数组时，会出现小问题，会把传入的数组整个当作返回的List中的第一个元素，例如： 复制代码代码如下: public static void main(String[] args){ int[] a1 = new int[]{1,2,3}; String[] a2 = new String[]{"a","b","c"}; System.out.println(Arrays.asList(a1)); System.out.println(Arrays.asList(a2)); } 1.打印结果如下： 复制代码代码如下: 1 2 [[I@dc8569] [a, b, c] 下面说说Arrays.asList()的返回值： JDK文档是这么说的： public static ListasList(T... a) 返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同Collection.toArray() 一起，充当了基于数组的API 与基于collection 的API 之间的桥梁。返回的列表是可序列化的，并且实现了RandomAccess。此方法还提供了一个创建固定长度的列表的便捷方法，该列 复制代码代码如下:

Java数组与方法

若想要存放一连串相同数据类型的数据，使用数组是个相当好用的选择。此外，如果某个程序片段经常反复出现，那么将它定义成一个方法可以有效地简化程序代码。本章主要是介绍数组的基本用法与方法的应用，学完本章，将会对数组与方法的使用有更深一层的认识。 数组是由一组相同类型的变量所组成的数据类型，它属于引用类型。它们以一个共同的名称表示，数组中的每个元素则以下标来访问。数组依照存放元素的复杂程度分为一维数组、二维和多维数组，先来看看一维数组。 3.1 一维数组 一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的。可以将它简单的理解为是相同数据类型的数据的集合。 3.1.1 一维数组的声明与内存的分配 要使用Java的数组，必须经过两个步骤： （1）声明数组 （2）给数组分配内存 这两个步骤的语法如下： 数据类型数组名[ ]; 或数据类型[ ] 数组名; // 声明一维数组 数组名= new 数据类型[个数]; // 给数组分配内存 数组的声明格式里，“数据类型”是声明数组每个元素的数据类型，常见的类型有整型、浮点型与字符型等，也可以是引用类型。“数组名”是用来统一这组相同数据类型的元素的名称，其命名规则和变量的相同，建议使用有意义的名称为数组命名。数组声明后，接下来便是要配置数组所需的内存，其中“个数”是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的个数，在内存中开辟一块内存供该数组使用。 需要注意的是，在Java中声明数组的时候，不能在[]中指定其长度。比如：int score[3]; // 错误 下面是关于一维数组的声明并分配内存给该数组的一个范例： int score[]; // 声明整型数组score score = new int[3]; // 为整型数组score分配内存空间，其元素个数为3 在上例中的第一行，当声明一个整型数组score时，score可视为数组类型的变量，此时这个变量并没有包含任何内容，编译器仅会分配一块内存给它，用来保存指向数组实体的地址，如图3-1所示。 图3-1 声明整型数组 声明之后，接着要做内存分配的操作，也就是上例中第二行语句。这一行会开辟3个可供保存整数的内存空间，并把此内存空间的参考地址赋给score变量。其内存分配的流程如图3-2所示。

java中数组的学习完整版一

1.知识点 一维数组：定义、初始化、使用（相关的算法，常用系统类的使用） 多维数组：定义、初始化、使用 增强for循环，break、continue控制语句的学习 2.讲解 什么是数组？ 例子 //要求把一个班的一门课的成绩，加起来求平均值； import java.util.*; class Average{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); float avg=0; float sum=0; int count=1; while(count<=3){ sum=sum+sc.nextFloat(); count++; } avg=sum/(count-1); System.out.println("平均值是:"+avg); System.out.println("程序结束"); } } //新要求：我要在输出平均值的同时，也要将这门课的最高分，最低分，同时也要能看到这门的成绩 数组概念：一组能够存储相同数据类型值的变量的集合。 在java中我们本着一切是对象的原则，我们把数组在java中看成是对象，数组对象。数组是最基本的引用型数据类型。 一维数组的知识点 定义方法： 1、三步法 A、int[] arr;用来申明数组的引用，在栈中为arr开辟内存； B、arr = new int[5];这是为数组arr在堆中为数组元素开辟6个存储单元； C、把数组在堆中的起始位置给了arr这个引用变量 *一般我们的程序在运行时，我们为局部变量在栈中开辟内存，而为对象(对象属性)在堆中开辟内存。为对象方法在方法区开辟内存空间。为类的属性，在静态区开辟内存空间。 具体的内存图：

JAVA数组基础学习知识-情况总结与简单规范标准示范

只为成功找方法，不为失败找借口！ java基础学习总结——数组 一．数组的基本概念 ?数组可以看成是多个相同类型数据组合，对这些数据的统一管理。 ?数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。 ?数组的元素可以是任何数据类型，包括基本类型和引用类型。 ?C和C++中的数组都可以分配在栈上面，而JAVA中的数组是只能分配在堆上面的，因为JAVA中的数组是引用类型。 二．一维数组 一维数组的声明方式有2种： ?格式一：数组元素类型数组名[ ]; 即type var[ ]; ?格式二：数组元素类型[ ] 数组名; 即type[ ] var; ?格式二声明数组的方法与C#上声明一维数组的方法一样。 例如：int a1[ ]; int[ ] a2; double b[ ]; person[ ] p1; String s1[ ]; 注意：JAVA语言中声明数组时不能指定其长度(数组中的元素个数) 如：int a[5]; 这样声明一维数组是非法的。 三．数组的模型 ?一维数组：一维数组就是一行，一行小格。 ?二维数组：二维数组就是一行加一列组成的一个平面分成的小格，有行有列。 ?三维数组：三维数组就是一个立方体。 ?人类对最多认识到三维空间。 四．数组对象的创建 JAVA中使用关键字new创建数组对象。 格式为：数组名= new数组元素的类型[数组元素的个数]

例如： 五．元素为引用数据类型的数组 注意：元素为引用数据类型的数组中的每一个元素都需要实例化。例如： class Date{ int year; int moth; int day; Date(int y; int m, int d){ year=y ; month=m ; day=d ; } }

JAVA数组的排序方法实例

冒泡排序法 1.public class SortArray_01 { 2. public static void main(String args[]) { 3. int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55 }; // 创建一个初始化的一维数组array 4. System.out.println("未排序的数组:"); 5. for (int i = 0; i < array.length; i++) { // 遍历array数组中的元素 6. System.out.print(" " + array[i]); // 输出数组元素 7. if ((i + 1) % 5 == 0) // 每5个元素一行 8. System.out.println(); 9. } 10. int mid; // 定义一个中间变量， 起到临时存储数据的作用 11. for (int i = 0; i < array.length; i++) { // 执行冒 泡排序法 12. for (int j = i; j < array.length; j++) { 13. if (array[j] < array[i]) { 14. mid = array[i]; 15. array[i] = array[j]; 16. array[j] = mid; 17. } 18. } 19. } 20. System.out.println("\n使用冒泡法排序后的数组:"); 21. for (int i = 0; i < array.length; i++) { // 遍历排好序的array数组中的元素 22. System.out.print(" " + array[i]); // 输出数组元素 23. if ((i + 1) % 5 == 0) 24. System.out.println(); // 每5 个元素一行 25. } 26. } 27.} 数组递增排序

JAVA中运用数组的四种排序方法

JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。 快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。 冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。 选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。 插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。 <1>利用Arrays带有的排序方法快速排序 import java.util.Arrays; publicclass Test2{ publicstaticvoid main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } } <2>冒泡排序算法 publicstaticint[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;iargs[j]){ int temp=args[i]; args[i]=args[j]; args[j]=temp; } } } return args; } <3>选择排序算法 publicstaticint[] selectSort(int[] args){//选择排序算法 for (int i=0;i

java中数组的定义及使用方法详解

java中数组的定义及使用方法详解 数组：是一组相关变量的集合 数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组按照使用可以分为一维数组、二维数组、多维数组 数据的有点 不使用数组定义100个整形变量：int i1;int i2;int i3 使用数组定义 int i[100]; 数组定义：int i[100];只是一个伪代码，只是表示含义的 一维数组 一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的，使用java数组，必须经过两个步骤，声明数组和分配内存给该数组，声明形式一 声明一维数组：数据类型数组名[]=null; 非配内存给数组：数组名=new 数据类型[长度]; 声明形式二 声明一维数组：数据类型 [] 数组名=null; java数据类型分为两大类 基本数据类型 int、long操作的时候本身就是具体的内容 引用数据类型：数组、类、接口 引用传递的就是一个内存的使用权，一块内存空间，可能有多个人同

时使用 事例声明数组 package com.qn.array; public class Test { public static void main(String[] args) { int score[]=null;//声明数组 score=new int[3];//开辟空间，大小为3 } } 数组的声明格式里，数据类型是数组元素的数据类型，常见的有整形、浮点型、与字符型等 数组名是用来统一这组相同数据类型元素的名称，其命名规则和变量的相同 数组声明后实际上是在栈内存中保存了此数组的名称，结下了是要在堆内存中配置数组所需要的内存，齐产固定是告诉编译器，所声明的数组要存放多少个元素，而new 则是命令编译器根据括号里的长度 基本数据类型偶读有其默认值：int 0;只要是引用数据类型默认值就是null 事例 package com.qn.array;

Java中数组常用方法的总结

Java中数组常用方法的总结 一、Java标准类库提供static方法System.arraycopy(),用它复制数组比用for循环复制要快得多，System.arraycopy()针对所有的类型做了重载，需要5个参数。 第一个参数：源数组。 第二个参数：偏移量,即从哪个位置开始复制的索引。 第三个参数：目标数组。 第四个参数：偏移量。 第五个参数：要从源数组中复制到目标数组元素的个数,一般情况下为目标数组的长度。 例： 从A数组中复制元素到B数组？ public class Practice { public static void main(String[] args){ String[] A = {"H","e","l","l","o"}; String[] B = new String[3]; System.arraycopy(A, 0, B, 1, B.length - 1); for(int i = 0; i < B.length; i ++){ System.out.print(B[i] + " "); } } } 运行结果为：null H e; 二、Array.Fill(数组名，值)此方法用于填充数组。 例： 现向已知数组A中填充值？ public class Practice { public static void main(String[] args){ String[] A = new String[5]; Arrays.fill(A, "Hello"); for(int i = 0; i < A.length; i ++){ System.out.print(A[i] + " "); } } } 运行结果为： Hello Hello Hello Hello Hello 三、Array.equals(数组名A，数组名B),比较两个数组A、B是否相等，此方法针对所有基本类型与object都作了重载，例如比较两个数是否相等用Integer.equals()方法……，通过object.equals()方法比较数组是否相等，是基于内容的。 例： 三个已知数组的比较？ public class Practice { public static void main(String[] args){ String[] A = {"1","2","3"}; String[] B = {"一","二","三"}; String[] C = {"1","2","3"}; System.out.println(Arrays.equals(A, B)); System.out.println(Arrays.equals(A, C)); } } 运行结果为：false true 四、Array.asList()此方法用于输出数组中的所有数. 例： 输出已知数组A中的所有数？ public class Practice { public static void main(String[] args){ String[] A = {"H","e","l","l","o"};

Java数组练习题(带答案)教学提纲

J a v a 数组练习题 ( 带 答案)

一填空题 1） 数组的元素通过下标来访问，数组Array 的长度为 Array.length 。 2） 数组复制时，"="将一个数组的 引用 传递给另一个数组。 3） JVM 将数组存储在 栈（堆或栈）中。 4） 数组的二分查找法运用的前提条件是数组已经排序 。 5） Java 中数组的下标的数据类型是整型。 6） 数组最小的下标是 0 0 7） arraycopy （）的最后一个参数指明复制元素的个数 。 8） 向方法传递数组参数时，传递的是数组的 引用° 9） 数组初始化包括 数组的申明，创建和初始化 。 10） 数组下标访问超出索引范围时抛出 数组越界 异常 11） 浮点型数组的默认值是 O.Of ° 12） 数组创建后其大小 不能 改变。 二选择题 1. 下面错误的初始化语句是_ABD__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e',T,T,'o'}; D. char str[]={'hello'}; 2. 定义了一维int 型数组a[10]后，下面错误的引用是_B__ 3. A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 4. 下面的二维数组初始化语句中，正确的是 _____ 5. A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; 6. C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 7. 引用数组元素时，数组下标可以是 _D___ 8. A.整型常量 B.整型变量 C.整型表达式 D.以上均 9. 定义了 int 型二维数组a[6][7]后，数组元素 A. 24 B. 25 C. 18 10. 下列初始化字符数组的语句中，正确的是 __B__ 11. A. char str[5]="hello"; B. char str[]={'h','e',T,T,'o','\0'}; 12. C. char str[5]={"hi"}; D. char str[100]=""; 13. 数组在Java 中储存在丄中 14. A.栈 B.队列 C.堆 D.链表 15. 下面程序的运行结果是 ____ mai n() { int a[][]={{1,2,3},{4,5,6}}; System.out.pri ntf("%d", a[1][1]); } a[3][4]前的数组元素个数为 D. 17

java数组复制的4种方式

java数组复制的4种方式： 第一种方式利用for循环： int[]a={1,2,4,6}; int length=a.length; int[]b=new int[length]; for(int i=0;i

第四种方式： 这里再介绍一下System.arraycopy这个函数，从JAVA API中找了一段。大家看一下。 public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。从src引用的源数组到dest 引用的目标数组，数组组件的一个子序列被复制下来。被复制的组件的编号等于length参数。源数组中位置在srcPos到srcPos+length-1之间的组件被分别复制到目标数组中的destPos到destPos+length-1位置。 如果参数src和dest引用相同的数组对象，则复制的执行过程就好像首先将srcPos到srcPos+length-1位置 的组件复制到一个带有length组件的临时数组，然后再将此临时数组的内容复制到目标数组的destPos到 destPos+length-1位置一样。 If 如果dest为null，则抛出NullPointerException异常。 如果src为null, 则抛出NullPointerException异常，并且不会修改目标数组。

Java基础篇—数组详解

Java基础篇—数组详解 项目开发中，如果需要存储大量的数据，例如如果需要读取100个数，那么就需要定义100个变量，显然重复写100次代码，是没有太大意义的。Java语言提供了数组（array）的数据结构，可以解决这个问题。 数组的概念 一个数组是相同数据类型的元素按一定顺序排列的集合。使用数组可以将同一类型的数据存储在连续的内存位置。数组中各元素的类型相同，通过下标的方式来访问数组中的元素，下标从0开始。 由此得出，数组具有以下基本特点： 数组的长度是确定的，数组一旦被创建，它的大小就是不可以改变的。数组的元素必须是相同类型，不能出现混合类型。数组类型可以是任意数据类型，包括基本数据类型和引用类型。数组在使用之前必须先声明，也就是要先定义后使用。一维数组的定义格式为： 数据类型[]数组名;数据类型数组名[];这两种声明方式完全等价，不过在实际开发中，我们一般推荐使用第一种方式。 数组的初始化 数组声明之后，仅仅是定义了一个数组引用，系统并没有为数组分配任何内存，因此现在还不能访问它的任何元素。必须经过数组初始化后，才能使用数组的元素。 数组的初始化分为静态初始化和动态初始化两种。

静态初始化就是在定义数组的同时给数组元素赋值。静态初始化使用一对大括号将初值括起来，大括号中元素的个数就是数组的长度。格式：数据类型[]数组名=new数据类型[]{元素1,元素2,…}; 例如：int[]arr=new int[]{1,2,3,4}; 动态初始化就是在定义数组时，只指定数组的长度，不为它赋值。在使用到的时候在给它添加元素。格式：数据类型[]数组名=new数据类型[数组长度]; 例如： int[]arr=new int[4]; arr[0]=1; arr[1]=2; arr[2]=3; arr[3]=4; 数组内存图解 首先我们要先了解Java中堆和栈的概念。我们可以这样理解： 我们定义的局部变量都存储在栈中；而堆中存放的都是数组和对象（其实数组也是对象）。凡是new建立的都是在堆中，堆中存放的都是实体（对象），实体可以有多个属性，如果一个数据消失，这个实体没有消失，还可以用，所以堆是不会释放的；但是栈不一样，栈里存放的都是单个变量，变量被释放了，那就没有了。 下面，我们通过对一个数组的声明和初始化的例子来看内存的分配情况。 1.声明一个数组 int[]s=null; 这时，只是声明了一个数组变量，这个变量存储在栈中，堆内存中是不会发生变化的：

实验报告 Java数组与字符串

实验五 Java数组与字符串 【实验目的】 1）掌握数组的声明、分配空间及初始化 2）理解多维数组（重点掌握二维） 3）掌握String类的特点及常用方法的使用 4）掌握StringBuffer类的特点及常用方法的使用 5）掌握String类和StringBuffer类的区别 6）掌握equal方法与==的区别 【实验环境】 JDK1.6+Eclpise3.2 【实验准备】 1）复习课件中理论知识 2）练习课堂所讲的例子 【实验内容】 1、定义一个10个元素组成的一维数组，输出该数组中的最大值、最小值、所有元素总和，以及最大值和最小值在该数组中的位置。 2、编写一个Java程序，完成以下功能： 1）声明一个名为name的String对象，内容是“My name is Networkcrazy”； 2）打印字符串的长度； 3）打印字符串的第一个字符； 4）打印字符串的最后一个字符； 5）打印字符串的第一个单词； 6）打印字符串crazy的位置（从0开始编号的位置）。 3、四位同学中一位做了好事，校长问这四位是谁做的好事。 A说：不是我 B说：是C C说：是D D说：C胡说 已知三个人说的是真话，一个人说的是假话。根据这些信息，找出做好事的人。 【提示】四个人中，每个人均有可能是做好事的人，所以用循环去测试，分别针对每种情形测试说真话的人的个数，如果count值为3，则为要找结果。【实验过程及结果】

1、定义一个10个元素组成的一维数组，输出该数组中的最大值、最小值、所有元素总和，以及最大值和最小值在该数组中的位置。 运行结果

2、编写一个Java程序，完成以下功能： 运行结果： 3、四位同学中一位做了好事，校长问这四位是谁做的好事。 A说：不是我 B说：是C C说：是D D说：C胡说 已知三个人说的是真话，一个人说的是假话。根据这些信息，找出做好事的人。

Java数组操作的10大方法

Java数组操作的10大方法 分享到：更多12 2014-08-27 分类：JAVA、编程开发暂无人评论 本文是码农网原创翻译，转载请看清文末的转载要求，谢谢合作！ 下面是精心整理的Java数组操作的10大方法，大部分代码都来自Stack Overflow。 0、定义一个Java数组 第一种是定义了一个数组，并且指定了数组的长度，我们这里称它为动态定义。 第二种和第三种在分配内存空间的同时还初始化了值。 1、打印Java数组中的元素

这里的重点是说明了Java中数组的引用和值得区别，第三行直接打印intArray，输出的是乱码，因为intArray仅仅是一个地址引用。第4行输出的则是真正的数组值，因为它经过了A rrays.toString()的转化。对Java初学者来说，引用和值仍需重视。 2、从Array中创建ArrayList 为什么要将Array转换成ArrayList呢？可能是因为ArrayList是动态链表，我们可以更方便地对ArrayList进行增删改，我们并不需要循环Array将每一个元素加入到ArrayList中，用以上的代码即可简单实现转换。 3、检查数组中是否包含某一个值 先使用Arrays.asList()将Array转换成List，这样就可以用动态链表的contains函数来判断元素是否包含在链表中。

4、连接两个数组 ArrayUtils是Apache提供的数组处理类库，其addAll方法可以很方便地将两个数组连接成一个数组。 5、声明一个数组内链 6、将数组中的元素以字符串的形式输出 同样利用StringUtils中的join方法，可以将数组中的元素以一个字符串的形式输出。 7、将Array转化成Set集合

java中方法和数组的练习

####计算机与信息技术学院 实验报告 姓名学号专业班级 课程名称 Java实验实验日期 成绩指导教师批改日期实验名称实验3 方法和数组 实验目的： （1）掌握一维数组和二维数组的定义、初始化方法。 （2）了解和初步应用https://www.wendangku.net/doc/3617501203.html,ng.Math类的random（）方法处理实际问题。 （3）了解增强for循环，并使用增强for循环顺序访问数组元素。 （4）掌握String类中split方法、charAt方法以及length方法的使用。 （5）掌握Double、Integer等数据包装类的parseDouble、parseInt等方法。 （6）掌握数组的length属性的应用 实验内容： （1）分别用一维数组(例子数组如下{ 7, 4, 3, 9, 0, 6 })实现冒泡排序、选择排序和插入排序中的两种排序算法，程序中要求加注释。 选择排序程序代码： import java.util.*; public class SelectionSort{ public static void sort_1(double []list){ for(int i=0;ilist[min]) min = j; } if(min !=i){ double temp = list[i]; list[i] = list[min]; list[min] = temp; } } } public static void main(String []args){ Scanner input = new Scanner(System.in); System.out.println("请输入要排序的个数："); int num = input.nextInt(); double []list = new double[num]; System.out.println("请输入"+num+"个要排序的数字："); for(int i=0;i