什么是数组:
数组是一种数据结构,用来存储同一类型值的集合.
具体的来说,将有限个类型相同的变量的集合命名,这个名称就是数组.组成数组的各个变量称为数组的分量,也叫数组的元素.用于区分数组的各个元素的元素的数字编号称为下表.
数组的特点:
数组是相同数据类型的元素集合.
数组中的个元素的存储是有先后顺序的,他们在内存中按先后顺序连续存放在一起.
好处:
可能会看到这样的数组:
比如说一个 int 类型的数组:
int[] arr = { 'a', 25, 45, 78, 'z' };
System.out.println(Arrays.toString(arr));输出结果是：[97, 25, 45, 78, 122]
存放进去的 char 类型的字符会自动转为 int 类型的 ASCII 码。
上面的代码中就将 a 转成了 97，z 转成了 122。
所以数组只能存放同一类型的数据。
数组的声明:
声明有两种方式:
方式一:
dataType[] arrayRefVar; // 首选的方法
方式二:
dataType arrayRefVar[]; // 效果相同，但不是首选方法
示例:
int[] a;
int a[];
建议使用第一种方式,因为他将类型int[](整数型数组)与变量名发呢个开了.
数组的创建:
JAVA中使用new关键字来创建数组.
arrayRefVar = new dataType[arraySize]; //例如 a = new int[1];
声明和创建可以在一条语句中完成. []中为数组的长度.
dataType[] arrayRefVar = new dataType[arraySize]; //例如 int[] a = new int[1];
在创建一个数组的时候,所有的元素都会初始化为0.boolean数组的元素会初始化为false,对象数组的元素会变为null,表示数组还没有存放任何对象
数组一但创建就无法更改长度,只能更改元素的值.要在运训中扩展数组大小用到后面学习的array list数组列表.
数组的初始化
方式一(静态初始化)
java提供了创建数组并同时赋予初始值的简化形式. 由程序员显式指定每个数组元素的初始值，有系统决定数组的长度；
例如
int[] ar;
a = new int[]{2,3,4};
可以简化为
int[] a = {2,3,4};
注意以空格隔开最后一位没有逗号,使用这种方式不需要关键字new
String stringArray[] = {"h", "j", "b"};
方式二 (动态初始化)
初始化时由程序员指定数组的长度，由系统初始化每个数组元素的默认值。
float[] floatArray= new float[3];
floatArray[0] = 1.0f;
floatArray[1] = 132.63f;
floatArray[2] = 100F;
静态可以用循环来给数组赋值
int[] a=new int[10];
forint i = 1; i < 100; i++){
a[i]=i;
}
初始化和动态初始化开始都指定了数组大小，java也在栈空间分配了相应的大小，只是静态初始化开始就指定了值，而动态初始化是在后面指定数组的值，刚开始数组的值都是默认值
注意:不要在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值。
初始化匿名数组
new int[]{2,3,4};
数组的操作
数组元素的应用
可以使用数组名[下标]来使用下标元素
arrayName[index];// a=a[1];
数组的遍历;
int[] a = { 1, 2, 3 };
for (int i = 0; i < 3; i++) {
System.out.println(a[i]);
}
数组可以用数组名.length来获取数组的长度,因此可以这遍历
int[] a = { 1, 2, 3 };
for (int i = 0; i < i.length; i++) {
System.out.println(a[i]);
}
java有一种功能很强的循环结构,用来处理数组中的每个元素,不必为制定下标分心
增强for循环也叫for each循环遍历
int[] a = {1,2,3};
for(int i:a){
System.out.println(i);
}
语法为：
for( arrayType varName: arrayName ){
// Some Code
}
arrayType 为数组类型（也是数组元素的类型）；varName 是用来保存当前元素的变量，每次循环它的值都会改变；arrayName 为数组名称。
每循环一次，就会获取数组中下一个元素的值，保存到 varName 变量，直到数组结束。即，第一次循环 varName 的值为第0个元素，第二次循环为第1个元素......例如：
数组拷贝
java中允许把一个数组变量拷贝给另一个数组变量,这时候两个变量引用同一个数组.这个时候两个变量指向同一个数组.
例如
int[] s = new int[6];
int[] x = s;
x[5] = 12;
这个时候也s[5]也是12
拷贝一个数组变量
如果希望把一个数组的所有值拷贝到一个新的数组中区,(以int[] 为例子)
可以使用Arrays类的copyTo方法:
int[] copyx = Arrays.copyOf(x,copyx.length)
第二个参数是新数组的长度,这个方法常用来增加数组的长度
int[] src = {1,3,5,7,9,11,13,15,17};
int[] dest = {2,4,6,8,10,12,14,16,18,20};
//copyOf(是复制src数组从0开始的两个元素到新的数组对象)
int[] copyof=Arrays.copyOf(src, 2);
//[1,3]
System.arraycopy的用法:
System.arraycopy(x,下标,copyx,下标2,下标3)
第一个小标表示从原数组那个下标开始,第三个表示从目标数组的那个下标开始,到下标3
int[] x= {1,3,5,7,9,11,13,15,17};
int[] s = {2,4,6,8,10,12,14,16,18,20};
//从x中的第一个元素起复制三个元素，即1，3，5复盖到s第2个元素开始的三个元素
System.arraycopy(x, 0,s, 1, 3);
结果
//[2, 1, 3, 5, 10, 12, 14, 16, 18, 20]
Arrays.copyOfRange的用法
int[] copyx = Arrays.copyOfRange(x,下标1,下标2);
参数表示从下标一到下标2的距离;
int[] src = {1,3,5,7,9,11,13,15,17};
int[] dest = {2,4,6,8,10,12,14,16,18,20};
//copyRange(从src数组中从0开始的第二个元素到第五个元素复制到新数组，含头不含尾)
int[] copyofRange=Arrays.copyOfRange(src, 2,6);
//[5, 7, 9, 11]
如果数组是数值型那么多余的元素会被赋值为0;如果前面的数组元素是bollean类型,会被赋值为false,相反,如果长度小于原数组长度则会这拷贝前面的元素.
Arrays类的使用
java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：
给数组赋值：通过fill方法。
对数组排序：通过sort方法,按升序。
比较数组：通过equals方法比较数组中元素值是否相等。
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
import java.util.Arrays;
public class TestArrays {
public static void output(int[] array) {
if (array != null) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
System.out.println();
}
public static void main(String[] args) {
int[] array = new int[5];
// 填充数组
Arrays.fill(array, 5);
System.out.println("填充数组：Arrays.fill(array, 5)：");
TestArrays.output(array);
// 将数组的第2和第3个元素赋值为8
Arrays.fill(array, 2, 4, 8);
System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");
TestArrays.output(array);
int[] array1 = { 7, 8, 3, 2, 12, 6, 3, 5, 4 };
// 对数组的第2个到第6个进行排序进行排序
Arrays.sort(array1, 2, 7);
System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");
TestArrays.output(array1);
// 对整个数组进行排序
Arrays.sort(array1);
System.out.println("对整个数组进行排序：Arrays.sort(array1)：");
TestArrays.output(array1);
// 比较数组元素是否相等
System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):" + "\n" + Arrays.equals(array, array1));
int[] array2 = array1.clone();
System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):" + "\n" + Arrays.equals(array1, array2));
// 使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）
Arrays.sort(array1);
System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)：" + "\n" + Arrays.binarySearch(array1, 3));
// 如果不存在就返回负数
System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)：" + "\n" + Arrays.binarySearch(array1, 9));
}}
数组的常见异常
1数组越界异常 ArrayIndexOutOfBoundsException
访问了不存在的下标值,下标从0开始
public static void main(String[] args) {
int[] x = { 1, 2, 3 };
System.out.println(x[3]);
//java.lang.ArrayIndexOutOfBoundsException
}
2 NullPointerException 空指针异常
引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。
public static void main(String[] args) {
int[] x = { 1, 2, 3 };
x = null;
System.out.println(x[1]);
// java.lang.NullPointerException
}
多维数组
java实际上没有多维数组,只有一维数组.多维数组被解释为"数组的数组".
简单的说就是数组中又存储了数组.
两种初始化方式:
动态初始化:
数据类型 数组名 [ ][ ] = new 数据类型[m][n]
数据类型 [ ][ ] 数组名 = new 数据类型[m][n]
数据类型 [ ] 数组名 [ ] = new 数据类型[m][n]
int [ ][ ] arr=new int [5][3]; 也可以理解为“5行3例”
静态初始化:
数据类型 [ ][ ] 数组名 = {{元素1,元素2....},{元素1,元素2....},{元素1,元素2....}.....};
举例：int [ ][ ] arr={{22,15,32,20,18},{12,21,25,19,33},{14,58,34,24,66},};
for each循环语句不能自动处理二维数组的每一个元素,他是按照行,也就是一维数组处理的,因此想要访问二维数组的所有元素要嵌套循环.
for(int[] row:a){
for(int value:row){
}
}
要想快速的打印一个二维数组,可以调用
System.out.println(Arrays.deepToString(a))
不规则数组
即每一行有不同的长度.
要想创建一个不规则的数组,首先要分配一个具有包含所有行数的数组.
转载于:https://blog.51cto.com/10760006/2153801
扫一扫
404
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
