一:什么是数组:
数组是相同类型的,用一个标识符名称封装到一起的一个对象序列或基本数据类型序列。
数组就是一个简单的线性序列,这使得元素访问非常快速,但是为这种速度所付出的代价是数组对象的大小被固定,并且在其生命周期中不可改变。
在Java中数组是一种效率最高的存储和随机访问对象引用序列的方式。
二:数组和其它容器有什么区别:
1. 数组可以存储基本数据类型,也可以存储引用数据类型,集合只能存储引用数据类型。
数组可以持有基本数据类型,而容器不能持有基本数据类型,但是JAVA SE5 泛型出来后,容器就可以指定并检查它们所持有的对象类型,并且有了自动包装机制,“容器看起来还能够持有基本类型”(这里只是看起来,实际上是持有的基本类型多对应的包装器类型)。
2. 数组是固定长度的,集合的长度是可变的。
数组是一种内存结构,而容器是一种数据结构。数组创建就必须指定大小,指定了大小数组也就固定了。当数组空间不足的时候,只能创建一个新的数组,然以把数据拷贝到新数组中。
知道数组的长度,而且以后也不会再增加,那肯定就使用数组了;如果数组的长度不定或者说是长度会增加,为了方便起见使用容器
三:数组的创建与初始化:
public class ArrayTest {
public static void main(String[] args) {
int[] a = new int[5]; //第一种初始化方法
System.out.println(Arrays.toString(a)); //[0, 0, 0, 0, 0]
int[] b = new int[]{1, 2, 3, 4, 5}; //第二种初始化方法
System.out.println(Arrays.toString(b)); //[1, 2, 3, 4, 5]
int[] c = {1, 2, 3, 4, 5}; //第三种初始化方式
System.out.println(Arrays.toString(c)); //[1, 2, 3, 4, 5]
}
}
四:多维数组:
对于一个二维数组来说:它是一个数组,它的每个元素都是一个一维数组。
对于n(n>1)维数组来说:它是一个数组,它的每个元素都是一个(n-1)维数组。
二维数组声明和初始化:
public class ArrayTest {
public static void main(String[] args) {
int[][] a = new int[5][3]; //第一种初始化方法,表示有5个长度为3的一维数组
System.out.println(Arrays.deepToString(a)); //[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
System.out.println(a.length); //5
int[][] b = new int[][]{{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}};//第二种初始化方法,表示有2个长度为5的一维数组
System.out.println(Arrays.deepToString(b)); //[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
System.out.println(b.length); //2
int[][] c = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}};//第三种初始化方式
System.out.println(Arrays.deepToString(c)); //[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
System.out.println(c.length); //2
int[][] d = new int[2][]; //第四种创建方式,数组中构成矩阵的每个向量都可以具有任意长度,也就是说构成二维数组的每个元素的一维数组的长度可以任意长度。
for (int i = 0; i < d.length; i++) {
d[i] = new int[i + 1];
}
System.out.println(Arrays.deepToString(d)); //[[0], [0, 0]]
System.out.println(d.length); //2
}
}
五:Arrays实用功能:
- Arrays.fill():填充数组
用同一个值来填充数组的各个位置,而针对对象而言,就是复制同一个引用进行填充。
public class ArrayTest {
public static void main(String[] args) {
int[] a = new int[5]; //创建数组,默认值为0
System.out.println(Arrays.toString(a)); //[0, 0, 0, 0, 0]
Arrays.fill(a, 6); //将数据全部替换成6
System.out.println(Arrays.toString(a)); //[6, 6, 6, 6, 6]
boolean[] b = new boolean[6]; //创建数组,默认值为false
System.out.println(Arrays.toString(b)); //[false, false, false, false, false, false]
Arrays.fill(b, true); //将数据全部替换成true
System.out.println(Arrays.toString(b)); //[true, true, true, true, true, true]
Animal[] c = new Animal[7]; //创建数组,默认值为null
Animal animal = new Animal("animal"); //创建将要替换的对象
System.out.println(Arrays.toString(c)); //[null, null, null, null, null, null, null]
Arrays.fill(c, animal); //将数据全部替换成animal
System.out.println(Arrays.toString(c)); //[com.lonbon.mytest.Animal@1540e19d, com.lonbon.mytest.Animal@1540e19d, com.lonbon.mytest.Animal@1540e19d, com.lonbon.mytest.Animal@1540e19d, com.lonbon.mytest.Animal@1540e19d, com.lonbon.mytest.Animal@1540e19d, com.lonbon.mytest.Animal@1540e19d]
}
}
- System.arraycopy():复制数组
Java标准类库提供有static方法System.arraycopy(),用它复制数组比用for循环复制要快很多。
我们来看一下这个方法:public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
src:原数组
srcPos:原数组起始位置
dest:目标数组
destPos:目标数组的起始位置
length:要复制的数组元素的数目
下面看一个简单例子:
public class ArrayTest {
public static void main(String[] args) {
int[] a = new int[5];
Arrays.fill(a, 6);
int[] b = new int[7];
System.arraycopy(a, 0, b, 0, a.length);
System.out.println(Arrays.toString(b)); //[6, 6, 6, 6, 6, 0, 0]
}
}
- Arrays.equals():数组的比较
Arrays类提供了重载后的equals()方法,用来比较整个数组。数组相等的条件是元素个数必须相等并且对应的元素也相等。
看下面例子:
public class ArrayTest {
public static void main(String[] args) {
int[] a = new int[10];
int[] b = new int[10];
Arrays.fill(a, 6);
Arrays.fill(b, 6);
System.out.println(Arrays.equals(a, b)); //true
String[] c = new String[10];
String[] d = new String[10];
Arrays.fill(c, "q");
Arrays.fill(d, "w");
System.out.println(Arrays.equals(c, d)); //false
}
}
- java.lang.Comparable:数组对象的排序:
我们只需要实现Comparable接口,并且在compareTo()里面定义自己的排序规则就可以实现自定义的对象排列。如果当前对象小于参数则返回负值,如果相等则返回零,如果当前对象大于参数则返回正值。
下面我们来看一个例子
public class ArrayTest implements Comparable<ArrayTest> {
private int i;
public ArrayTest(int i) {
this.i = i;
}
@Override
public int compareTo(@NonNull ArrayTest another) { //自定义排序规则
return (i < another.i ? -1 : (i == another.i ? 0 : 1));
}
@Override
public String toString() {
return i+"";
}
public static void main(String[] args) {
ArrayTest[] a = {new ArrayTest(10), new ArrayTest(30), new ArrayTest(3), new ArrayTest(7), new ArrayTest(1)};
System.out.println(Arrays.toString(a)); //[10, 30, 3, 7, 1]
Arrays.sort(a);
System.out.println(Arrays.toString(a)); //[30, 10, 7, 3, 1]
}
}