数组
一、概述
1、数组是一种容器，与其他容器有三方面的区别：效率、类型和保存基本类型的能力。
2、数组是一种简单地线性序列，是一种存储和随机访问对象效率最高的序列方式。但，这种效率需要付出代价：数组的对象大小被固定，并且在其生命周期内不可变。
3、数组标识符是一个引用，指向在堆中创建的一个真实对象(这个对象中保存了指向其他对象的引用)。
4、函数可通过返回数组同一时间返回多个对象等。函数返回的是数组的引用。
5、与C、C++不同，Java在数组的定义中并不为数组元素分配内存，因此[]中不用指出数组中元素个数，即数组长度。对于只是声明而没有开辟空间的数组，不能访问该数组；对于开辟了空间而没有赋值的数组，其自动初始化为空。
6、数组初始化
class ElementArray{
static int count;
private String str;
ElementArray(){
count++;
str = "element of array";
}
}
public class InitArray {
public static void main(String[] args) {
//方式一
ElementArray[] obArray1;
//System.out.println(obArray1);
obArray1 = new ElementArray[]{new ElementArray(), new ElementArray(),};
System.out.println(obArray1);
//方式二
ElementArray[] obArray2 = new ElementArray[]{new ElementArray(), new ElementArray(),};
System.out.println(obArray2);
//方式三
ElementArray[] obArray3 = new ElementArray[5];
System.out.println(obArray3);
for(int i=0; i<obArray2.length; i++){
System.out.print("前：" + obArray3[i] + " ");
if(obArray3[i] == null)
obArray3[i] = new ElementArray();
System.out.println("后：" +obArray3[i] + " ");
}
}
}
运行结果：
[Larray.ElementArray;@b40443
[Larray.ElementArray;@83ce25
[Larray.ElementArray;@152e
前：null 后：array.ElementArray@
前：null 后：array.ElementArray@2de41d
上面的实例展示了数组初始化的三种方式。新生成一个数组对象时，其中所有的引用被自动初始化为null；索引检查其中的引用是否为null，即可知道数组的某个位置是否存有对象。同样，基本类型的数组如果是数值型的，就被自动初始化为0；如果是字符型(char)，就被自动初始化为(char)O；如果是布尔型(boolean)，就被自动初始化为false。
二、数组操作类Array
1、类：java.lang.reflect.Array
2、Array提供了动态创建和访问JAVA数组的方法，允许在执行get()或set()操作期间进行扩展和转换。如果发生收缩转换，则抛出IllegalArgumentException。
3、Array的作用：(1)动态获取数组某个位置的值；(2)动态生成数组对象(一维或者多维)；(3)动态设置数组某个位置的值；(4)用于完成数组的反射应用。
4、Array提供的方法都是静态方法，用于对JAVA数组的操作。
|
函数 |
参数 |
功能详述 |
|
get |
(Object array, int index) |
返回指定对象数组、指定索引的某种类型的值 |
|
getBoolean |
(Object array, int index) | |
|
getByte |
(Object array, int index) | |
|
getChar |
(Object array, int index) | |
|
getDouble |
(Object array, int index) | |
|
getFloat |
(Object array, int index) | |
|
getInt |
(Object array, int index) | |
|
getLong |
(Object array, int index) | |
|
getShort |
(Object array, int index) | |
|
| ||
|
set |
(Object array, int index, Object value) |
以某种类型设置指定数组、指定索引的值。 |
|
setBoolean |
(Object array, int index, boolean z) | |
|
setByte |
(Object array, int index, byte b) | |
|
setChar |
(Object array, int index, char c) | |
|
setDouble |
(Object array, int index, double d) | |
|
setFloat |
(Object array, int index, float f) | |
|
setInt |
(Object array, int index, int i) | |
|
getLong |
(Object array, int index, long l) | |
|
setShort |
(Object array, int index, short s) | |
|
| ||
|
getLength |
(Object array) |
返回指定数组对象的长度 |
|
newInstance |
(Class<?> componentType, int... dimensions) |
创建一个具有指定的组件类型和维度的新数组。 |
|
newInstance |
(Class<?> componentType, int length) |
创建一个具有指定的组件类型和长度的新数组。 |
|
|
|
|
5、应用实例
import java.lang.reflect.Array;
import java.util.Arrays;
public class ArrayReflect {
public static void main(String[] args) throws SecurityException, NoSuchMethodException {
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i] = i * i;
}
//使用Array反射获取数组的长度
int length = Array.getLength(arr);
System.out.println("length: " + length);
//使用Array反射获取数组的某个位置的值
Object Obj = Array.get(arr, 5);
System.out.println("get() : " + Obj);
//使用Array反射设置某个位置的值
Array.set(arr, 5, new Integer(1));
//打印整个数组
System.out.println(Arrays.toString(arr));
//使用Array反射生成数组（一维数组）10 ：数组的长度
ElementArray[] obj = (ElementArray[]) Array.newInstance(ElementArray.class, 10);
for (int i = 0; i < obj.length; i++) {
ElementArray h = obj[i];
System.out.print(h + " "); // 都是null ，因为反射生成的都是引用
}
System.out.println();
System.out.println("length: " + obj.length);
//使用反射生成多维数组 其中 1 维：有2个B[]数组，每个数组总有4个B元素
ElementArray[][] obj2 = (ElementArray[][]) Array.newInstance(ElementArray.class, 2,4);
System.out.println(Arrays.toString(obj2));
}
}
运行结果：
length: 10
get() : 25
[0, 1, 4, 9, 16, 1, 36, 49, 64, 81]
null null null null null null null null null null
length: 10
[[Larray.ElementArray;@
三、数组操作类Arrays
提供数组操作的相关的方法：搜索、拷贝、比较、排序等。Arrays提供都是静态方法。
|
函数 |
功能详述 |
|
asList |
返回一个受指定数组支持的固定大小的列表 |
|
binarySearch |
使用二分搜索法来搜索指定类型的数组(或数组的某个范围)，以获得指定的值。为了适应不同的数据类型，根据不同数据类型重载该方法。 |
|
copyOf |
复制指定的数组，截取或用相应类型数据填充（如有必要），以使副本具有指定的长度。为了适应不同的数据类型，根据不同数据类型重载该方法。 |
|
copyOfRange |
将指定数组的指定范围复制到一个新数组。为了适应不同的数据类型，根据不同数据类型重载该方法。 |
|
equals |
如果两个指定的同类型数组彼此相等，则返回 true。为了适应不同的数据类型，根据不同数据类型重载该方法。 |
|
fill |
将指定类型值分配给同一类型数组的每个元素。为了适应不同的数据类型，根据不同数据类型重载该方法。 |
|
hashCode |
基于指定数组的内容返回哈希码。为了适应不同的数据类型，根据不同数据类型重载该方法。 |
|
sort |
对指定类型数组(的指定范围)按数字升序进行排序。为了适应不同的数据类型，根据不同数据类型重载该方法。 |
|
toString |
返回指定数组内容的字符串表示形式。为了适应不同的数据类型，根据不同数据类型重载该方法。 |
|
deepEquals |
如果两个指定数组彼此是深层相等 的，则返回 true。该方法可应用于多维数组。 |
|
deepHashCode |
基于指定数组的“深层内容”返回哈希码。该方法可应用于多维数组。 |
|
deepToString |
返回指定数组“深层内容”的字符串表示形式。该方法可应用于多维数组。 |
|
|
|
实例：
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.print("填充数组：Arrays.fill(array, 5)：" + " ");
TestArrays.output(array);
// 将数组的第2和第3个元素赋值为8
Arrays.fill(array, 2, 4, 8);
System.out.print("将数组的第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.print("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");
TestArrays.output(array1);
// 对整个数组进行排序
Arrays.sort(array1);
System.out.print("对整个数组进行排序：Arrays.sort(array1)：");
TestArrays.output(array1);
// 比较数组元素是否相等
System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):" + " "+ Arrays.equals(array, array1));
int[] array2 = array1.clone();
System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):" + " "
+ Arrays.equals(array1, array2));
// 使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）
Arrays.sort(array1);
System.out.print("排序后的数组 ：");
TestArrays.output(array1);
System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)："
+ " " + Arrays.binarySearch(array1, 3));
// 如果不存在就返回负数
System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)："
+ " " + Arrays.binarySearch(array1, 9));
}
}
运行结果：
填充数组：Arrays.fill(array, 5)： 5 5 5 5 5
将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：5 5 8 8 5
对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：7 8 2 3 3 6 12 5 4
对整个数组进行排序：Arrays.sort(array1)：2 3 3 4 5 6 7 8 12
比较数组元素是否相等:Arrays.equals(array, array1): false
克隆后数组元素是否相等:Arrays.equals(array1, array2): true
排序后的数组 ：2 3 3 4 5 6 7 8 12
元素3在array1中的位置：Arrays.binarySearch(array1, 3)： 1
元素9在array1中的位置：Arrays.binarySearch(array1, 9)： -9
四、将数组转换为列表
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class ArrayToList {
static void printList(List<String> list){
for(String e : list)
System.out.print(" " + e);
System.out.println();
}
public static void main(String[] args) {
String[] strs = {"xue", "ma", "xiong", "feng", };
//方法一
List<String> strList = Arrays.asList(strs);
ArrayToList.printList(strList);
//方法二
List strList1 = new ArrayList<String>(strs.length);
for(String e : strs)
strList1.add(e);
ArrayToList.printList(strList1);
//方法三
List strList2 = new ArrayList();
Collections.addAll(strList2, strs);
ArrayToList.printList(strList2);
}
}
运行结果：
xue ma xiong feng
xue ma xiong feng
xue ma xiong feng
五、List转换为数组
方法一： ArrayList<String> list=new ArrayList<String>();
String[] strings = new String[list.size()];
list.toArray(strings);
方法二：ArrayList<String> list=new ArrayList<String>();
String strings[]=new String[list.size()];
for(int i=0,j=list.size();i<j;i++)
strings[i]=list.get(i);