1.数组的定义:
数组是具有相同数据类型的一组数据的集合。
Java中虽然基本数据类型不是对象,但是由基本数据类型组成的数组则是对象,在程序设计中引入数组可以更有效地管理和处理数据。
一维数组:
声明:数组元素类型[ ] 数组名字;(记住:数组名是引用类型变量)
创建空间:数组作为对象,使用new关键字进行内存分配。
注意:数组的大小一旦指定,就不可更改。
数组空间创建后具有默认的初值
数值类型的数组元素默认值为0
char数组中,每个值都被初始化为0(\u0000)字符;
boolean类型的数组元素默认值为false
对象类型的数组元素默认值为null
声明、创建、默认初始化一步完成:
Point p [] = new Point [100];
int score[]=new int[]{1,2,4};(注意红色中括号中不能指明大小)
Point p[] = { new Point(), new Point(1,2)};
二维数组:
二维数组是每个元素是一维数组的数组。
以此类推,N维数组就是每个元素是N-1维数组的数组。
声明:数组元素类型 [ ][ ] 数组名字;创建空间:a=new int[4][5];
声明、创建、默认初始化一步完成:
eg. int [][] a = new int[4][5];
访问数组
通过下标进行,如a[5]或者a[8], b[1][3].
数组的下标都从0开始,到数组名.length-1
例如:int[] a=new int[10];
a[0]=10; a[5]=2; a[9]=100;
数组被看成对象,具有length属性, 存储数组元素的个数值。
数组元素下标范围: [0 , 数组名.length)
遍历一维数组:
int[] a = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
System.out.println();
for (int i : a)
System.out.print(i + " ");
System.out.println();
遍历二维数组:
int[][] a = { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 } };
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++)
System.out.print(a[i][j] + " ");
System.out.println();
}
for (int[] i : a) {
for (int j : i)
System.out.print(j + " ");
System.out.println();
}
3.复制数组:
第一(复制数组):Arrays.copyOf(int[] original,int newLength);
original
- 要复制的数组
newLength
- 要返回的副本的长度
具体说明:
copyOf
public static short[] copyOf(short[] original,int newLength) 复制指定的数组,截取或用 0 填充(如有必要),以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引,这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引,副本将包含 (short)0。当且仅当指定长度大于原数组的长度时,这些索引存在。 参数:original - 要复制的数组 newLength - 要返回的副本的长度 返回:原数组的副本,截取或用 0 填充以获得指定的长度 抛出:NegativeArraySizeException - 如果 newLength 为负 NullPointerException - 如果 original 为 null 从以下版本开始:1.6
public static short[] copyOf(short[] original,int newLength) 复制指定的数组,截取或用 0 填充(如有必要),以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引,这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引,副本将包含 (short)0。当且仅当指定长度大于原数组的长度时,这些索引存在。 参数:original - 要复制的数组 newLength - 要返回的副本的长度 返回:原数组的副本,截取或用 0 填充以获得指定的长度 抛出:NegativeArraySizeException - 如果 newLength 为负 NullPointerException - 如果 original 为 null 从以下版本开始:1.6
具体例子:
int[] array = { 01, 2, 3, 4, }; // 定义整型数组
System.out.print("原数组:");
for (int i : array) { // 遍历输出数组
System.out.print(i + " ");
}
System.out.println();
int[] arrayCopy = Arrays.copyOf(array, 6);// 复制数组
System.out.print("复制数组:");
for (int i : arrayCopy) {// 遍历输出数组
System.out.print(i + " ");
}
System.out.println();
运行结果为:
原数组:1 2 3 4
复制数组:1 2 3 4 0 0
复制数组:1 2 3 4 0 0
original
- 将要从其复制一个范围的数组
from
- 要复制的范围的初始索引(包括)
to
- 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
具体说明:
copyOfRange
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。
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 从以下版本开始:1.6
具体例子:
int[] array = { 01, 2, 3, 4, }; // 定义整型数组
System.out.print("原数组:");
for (int i : array) { // 遍历输出数组
System.out.print(i + " ");
}
System.out.println();
int[] arrayRangeCopy = Arrays.copyOfRange(array, 2, 6);// 部分复制数组
System.out.print("部分复制数组:");
for (int i : arrayRangeCopy) {// 遍历输出数组
System.out.print(i + " ");
}
System.out.println();
运行结果为:
原数组:1 2 3 4
部分复制数组:3 4 0 0
部分复制数组:3 4 0 0
src
- 源数组。
srcPos
- 源数组中的起始位置。
dest
- 目标数组。
destPos
- 目标数据中的起始位置。
length
- 要复制的数组元素的数量。具体说明:
具体例子:
int[] array = { 01, 2, 3, 4, }; // 定义整型数组
System.out.print("原数组:");
for (int i : array) { // 遍历输出数组
System.out.print(i + " ");
}
System.out.println();
int myArray[] = new int[10];
System.arraycopy(array, 1, myArray, 3, 2);
System.out.print("用System的arraycopy复制数组:");
for (int i : myArray) {// 遍历输出数组
System.out.print(i + " ");
}
运行结果为:
原数组:1 2 3 4
用System的arraycopy复制数组:0 0 0 2 3 0 0 0 0 0
src
- 源数组。
srcPos
- 源数组中的起始位置。
dest
- 目标数组。
destPos
- 目标数据中的起始位置。
length
- 要复制的数组元素的数量。
具体说明:
arraycopy
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 异常,并且不会修改目标数组。 否则,只要下列任何情况为真,则抛出 ArrayStoreException 异常并且不会修改目标数组: •src 参数指的是非数组对象。 •dest 参数指的是非数组对象。 •src 参数和 dest 参数指的是那些其组件类型为不同基本类型的数组。 •src 参数指的是具有基本组件类型的数组且 dest 参数指的是具有引用组件类型的数组。•src 参数指的是具有引用组件类型的数组且 dest 参数指的是具有基本组件类型的数组。否则,只要下列任何情况为真,则抛出 IndexOutOfBoundsException 异常,并且不会修改目标数组: •srcPos 参数为负。 •destPos 参数为负。 •length 参数为负。 •srcPos+length 大于 src.length,即源数组的长度。 •destPos+length 大于 dest.length,即目标数组的长度。 否则,如果源数组中 srcPos 到 srcPos+length-1 位置上的实际组件通过分配转换并不能转换成目标数组的组件类型,则抛出 ArrayStoreException 异常。在这种情况下,将 k 设置为比长度小的最小非负整数,这样就无法将 src[srcPos+k] 转换为目标数组的组件类型;当抛出异常时,从srcPos 到srcPos+k-1 位置上的源数组组件已经被复制到目标数组中的 destPos 到 destPos+k-1 位置,而目标数组中的其他位置不会被修改。(因为已经详细说明过的那些限制,只能将此段落有效地应用于两个数组都有引用类型的组件类型的情况。) 参数:src - 源数组。 srcPos - 源数组中的起始位置。 dest - 目标数组。 destPos - 目标数据中的起始位置。 length - 要复制的数组元素的数量。 抛出:IndexOutOfBoundsException - 如果复制会导致对数组范围以外的数据的访问。 ArrayStoreException - 如果因为类型不匹配而使得无法将 src 数组中的元素存储到 dest 数组中。 NullPointerException - 如果 src 或 dest 为 null。
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 异常,并且不会修改目标数组。 否则,只要下列任何情况为真,则抛出 ArrayStoreException 异常并且不会修改目标数组: •src 参数指的是非数组对象。 •dest 参数指的是非数组对象。 •src 参数和 dest 参数指的是那些其组件类型为不同基本类型的数组。 •src 参数指的是具有基本组件类型的数组且 dest 参数指的是具有引用组件类型的数组。•src 参数指的是具有引用组件类型的数组且 dest 参数指的是具有基本组件类型的数组。否则,只要下列任何情况为真,则抛出 IndexOutOfBoundsException 异常,并且不会修改目标数组: •srcPos 参数为负。 •destPos 参数为负。 •length 参数为负。 •srcPos+length 大于 src.length,即源数组的长度。 •destPos+length 大于 dest.length,即目标数组的长度。 否则,如果源数组中 srcPos 到 srcPos+length-1 位置上的实际组件通过分配转换并不能转换成目标数组的组件类型,则抛出 ArrayStoreException 异常。在这种情况下,将 k 设置为比长度小的最小非负整数,这样就无法将 src[srcPos+k] 转换为目标数组的组件类型;当抛出异常时,从srcPos 到srcPos+k-1 位置上的源数组组件已经被复制到目标数组中的 destPos 到 destPos+k-1 位置,而目标数组中的其他位置不会被修改。(因为已经详细说明过的那些限制,只能将此段落有效地应用于两个数组都有引用类型的组件类型的情况。) 参数:src - 源数组。 srcPos - 源数组中的起始位置。 dest - 目标数组。 destPos - 目标数据中的起始位置。 length - 要复制的数组元素的数量。 抛出:IndexOutOfBoundsException - 如果复制会导致对数组范围以外的数据的访问。 ArrayStoreException - 如果因为类型不匹配而使得无法将 src 数组中的元素存储到 dest 数组中。 NullPointerException - 如果 src 或 dest 为 null。
具体例子:
int myArray[] = { 1, 2, 3, 4, 5, 6 };
int yourArray[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
System.arraycopy(myArray, 0, yourArray, 0, myArray.length);
for (int j = 0; j < yourArray.length; j++) {
System.out.print(yourArray[j] + " ");
}
System.out.println();
运行结果为:
1 2 3 4 5 6 4 3 2 1
a
- 要填充的数组
val
- 要存储在数组所有元素中的值
具体说明:
fill
public static void fill(int[] a,int val)
public static void fill(int[] a,int val)
将指定的 int 值分配给指定 int 型数组的每个元素。 参数:a - 要填充的数组 val - 要存储在数组所有元素中的值
具体例子:
int[] array = new int[5];// 定义能保存5个元素的数组
Arrays.fill(array, 5);// 将数组中全部元素赋值为5
System.out.println("数组中的元素");
for (int i : array) {// 遍历输出数组元素
System.out.print(i + " ");
}
运行结果为:
数组中的元素
5 5 5 5 5
5 5 5 5 5
a
- 要排序的数组
对指定的 int 型数组按数字升序进行排序。
具体例子:
具体例子:
int[] array = { 5, 4, 3, 2, 1 };// 定义整型数组
System.out.println("排序前数组元素:");
for (int i : array) {// 遍历数组
System.out.print(i + " ");
}
System.out.println();
Arrays.sort(array);// 将数组排序
System.out.println("排序后数组元素:");
for (int i : array) {// 遍历数组
System.out.print(i + " ");
}
运行结果为:
排序前数组元素:
5 4 3 2 1
排序后数组元素:
1 2 3 4 5
采用冒泡算法(真正的冒泡)对一维数组进行排序:
public class maopao {
public static void main(String[] args) {
int a[] = { 3, 1, 2345, 3, 78, 5, 234 };
for (int x : a) {
System.out.print(x + " ");
}
System.out.println("\n");
for (int i = 0; i < a.length - 1; i++) {
for (int j = a.length - 1; j >= i + 1; j--) {
if (a[j] < a[j - 1]) {
int t = a[j];
a[j] = a[j - 1];
a[j - 1] = t;
}
}
for (int x : a) {
System.out.print(x + " ");
}
System.out.println();
}
}
}
运行结果为:
3 1 2345 3 78 5 234
1 3 3 2345 5 78 234
1 3 3 5 2345 78 234
1 3 3 5 78 2345 234
1 3 3 5 78 234 2345
1 3 3 5 78 234 2345
1 3 3 5 78 234 2345
6.数组的查找:Arrays.binarySearch(int[] a,int key);
a
- 要搜索的数组
key
- 要搜索的值
具体说明:
binarySearch
public static int binarySearch(int[] a,int key)
使用二分搜索法来搜索指定的 int 型数组,以获得指定的值。必须在进行此调用之前对数组进行排序(通过 sort(int[]) 方法)。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个带有指定值的元素,则无法保证找到的是哪一个。
参数:a - 要搜索的数组
key - 要搜索的值
返回:如果它包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。
插入点 被定义为将键插入数组的那一点:即第一个大于此键的元素索引,如果数组中的所有元素都小于指定的键,则为 a.length。注意,这保证了当且仅当此键被找到时,返回的值将 >= 0。
public static int binarySearch(int[] a,int key)
使用二分搜索法来搜索指定的 int 型数组,以获得指定的值。必须在进行此调用之前对数组进行排序(通过 sort(int[]) 方法)。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个带有指定值的元素,则无法保证找到的是哪一个。
参数:a - 要搜索的数组
key - 要搜索的值
返回:如果它包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。
插入点 被定义为将键插入数组的那一点:即第一个大于此键的元素索引,如果数组中的所有元素都小于指定的键,则为 a.length。注意,这保证了当且仅当此键被找到时,返回的值将 >= 0。
具体例子:
int[] array = { 5, 4, 3, 2, 1 };// 定义整型数组
System.out.print("数组中的元素:");
for (int i : array) {// 遍历数组
System.out.print(i + " ");
}
System.out.println();
Arrays.sort(array);// 将数组排序
int index = Arrays.binarySearch(array, 0);// 查找元素0在数组中的索引值,注意查找之前必须先把数组排好序
System.out.println("元素0在数组中的索引值:" + index);
index = Arrays.binarySearch(array, 2);// 查找元素0在数组中的索引值
System.out.println("元素2在数组中的索引值:" + index);
运行结果为:
数组中的元素:5 4 3 2 1
元素0在数组中的索引值:-1
元素2在数组中的索引值:1
7.互换二维数组的行列:
import java.util.Scanner;
public class Transposition {
public static void main(String[] args) {
int hang, lie;
Scanner sc = new Scanner(System.in);
System.out.println("请输入原始二维数组的行数、列数:");
hang = sc.nextInt();
lie = sc.nextInt();
System.out.println();
int[][] array = new int[hang][lie];// 定义二维数组
int[][] arrayT = new int[lie][hang];// 定义转置后的二维数组
System.out.println("请输入原始二维数组的元素:");
for (int i = 0; i < array.length; i++) {// 对二维数组中的元素进行赋值
for (int j = 0; j < array[i].length; j++) {
array[i][j] = sc.nextInt();
}
}
System.out.println();
System.out.println("原始二维数组的元素如下:");
for (int i = 0; i < array.length; i++) {// 对二维数组中的元素进行赋值
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");// 输出数组中的元素
}
System.out.println();
}
System.out.println();
System.out.println("转置后的二维数组元素:");
for (int i = 0; i < arrayT.length; i++) {// 实现二维数组转置
for (int j = 0; j < arrayT[i].length; j++) {
arrayT[i][j] = array[j][i];
System.out.print(arrayT[i][j] + " ");// 输出数组中的元素
}
System.out.println();
}
sc.close();
}
}
运行结果为:
请输入原始二维数组的行数、列数:
3 4
请输入原始二维数组的元素:
8 5 6 4
3 5 7 1
0 8 4 2
原始二维数组的元素如下:
8 5 6 4
3 5 7 1
0 8 4 2
转置后的二维数组元素:
8 3 0
5 5 8
6 7 4
4 1 2
8.利用二维数组存储并输出杨辉三角的前n(n的值自己指定)行。
1
11
12 1
13 3 1
14 6 4 1
import java.util.Scanner;
public class five {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("输入行数:");
int hang = sc.nextInt();
// 声明二维数组
int[][] a = new int[hang][];
// 给每行创建空间
for (int i = 0; i < a.length; i++) {
a[i] = new int[i + 1];
}
// 赋值1
for (int i = 0; i < a.length; i++) {
a[i][0] = 1;
a[i][i] = 1;
}
// 给中间那块赋值
for (int i = 2; i < a.length; i++) {
for (int j = 1; j < i; j++) {
a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
}
}
// 打印
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j] + "\t");
}
System.out.println();
}
sc.close();
}
}
运行结果为:
输入行数:
11
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
9.编写程序利用二维数组存储九九乘法表,并输出该乘法表。public class six {
public static void main(String[] args) {
String[][] a = new String[9][];
for (int i = 0; i < a.length; i++) {
a[i] = new String[i + 1];
for (int j = 0; j < a[i].length; j++) {
a[i][j] = (j + 1) + "*" + (i + 1) + "=" + (i + 1) * (j + 1);
}
}
// 遍历输出
for (String[] x : a) {
for (String y : x)
System.out.print(y + "\t");
System.out.println();
}
}
}
运行结果为:
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81