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"};
System.out.println(Arrays.asList(A));
}
}
运行结果为：
[H, e, l, l, o];
五、数组中的排序
使用内置的排序方法，就可以对任意的基本类型数组排序，也可以对任意的对象数组进行排序，只要该对象实现了Comparable接口或具有相关联的Comparator接口
例：
已经数组String[] A = {"A","B","c","D","e","f","G","H

"};现对数组A进行排序，要求忽略大小写排序？
分析：String默认的排序方法，第一步是将大写字母开头的词均放在小写字母头的词的前面，然后才进行排序。
如：String[] A = {"A","B","c","D","e","f","G","H"};
Arrays.sort(A);
System.out.println(Arrays.asList(A));
运行结果为：[A, B, D, G, H, c, e, f];
如果想忽略大小写，可以通过自定义排序方式来实现：
如：
public class Practice1 implements Comparator{
public static void main(String[] args){
String[] A = {"A","B","c","D","e","f","G","H"};
Arrays.sort(A,new Practice1());
System.out.println(Arrays.asList(A));
}
public int compare(Object o1, Object o2) {
String s1 = (String)o1;
String s2 = (String)o2;
return s1.toLowerCase().compareTo(s2.toLowerCase());
}
}
运行结果为：[A, B, c, D, e, f, G, H];
六、使用Arrays.binarySearch()执行快速查找。
例：快速查找数组A中的元素？
public class Practice{
public static void main(String[] args){
String[] a = {"a","d","e","w","f"};
Arrays.sort(a);
System.out.println(Arrays.asList(a));
int index1 = Arrays.binarySearch(a, "f");
System.out.println("要查找的值存在的时候：" + index1);
int index2 = Arrays.binarySearch(a, "n");
index2 = -index2 - 1;
System.out.print("当不存在的时候输出该值最可能存在的位置：" + index2);
}
}
注意：不要对未排序的数组使用binarySearch();
七、Arrays.copyOf()用法,这个方法是将原数组快速复制成一个新数组。如果新数组的长度小于旧数组的长度，将截取一部分旧数组中的元素，复制给新数组，
反之，如果大于旧数组的长度，则将以0，null，或false给予补充。
例：快速复制数组？
public class Practice{
public static void main(String[] args){
String[] a = {"a","d","e","w","f"};
String[] b = new String[4];
String[] c = new String[5];
String[] d = new String[6];
b = Arrays.copyOf(a, b.length);
c = Arrays.copyOf(a, c.length);
d = Arrays.copyOf(a, d.length);
System.out.println("b数组的元素：" + Arrays.asList(b));
System.out.println("c数组的元素：" + Arrays.asList(c));
System.out.println("d

数组的元素：" + Arrays.asList(d));
}
}
运行结果为：
b数组的元素：[a, d, e, w]
c数组的元素：[a, d, e, w, f]
d数组的元素：[a, d, e, w, f, null]
八、Arrays.copyOfRange()用法，这个方法与前面介绍的Arrays.copyOf()的用法相似，下面来通过具体实例讲解。
例：如何将原数组指定复制一个新数组？
public class Practice{
public static void main(String[] args){
String[] a = {"a","d","e","w","f"};
String[] b = new String[4];
b = Arrays.copyOfRange(a, 2, 4);
System.out.println("b数组的元素：" + Arrays.asList(b));
}
}
运行结果为：
b数组的元素：[e, w];
相信读者已知道其中用法了吧，type[] N = Arrays.copyofRange("原数组",i,j)就是复制原数组赋值给新的数组N,指定从索引i到j;
九、Arrays.deepToString()用法，这个方法的用法同Arrays.asList()的用法相似,此方法是为了将多维数组转换为字符串而设计的；
下面通过例子来看一下它们的相同点。
例：输出已知数组a中的元素。
public class Practice{
public static void main(String[] args){
String[] a = {"a","d","e","w","f"};
System.out.println("用Arrays.asList()方法输出：" + Arrays.asList(a));
System.out.println("用Arrays.deepToString()方法输出：" + Arrays.deepToString(a));;
}
}
运行结果为：
用Arrays.asList()方法输出：[a, d, e, w, f]。
用Arrays.deepToString()方法输出：[a, d, e, w, f]。
十、Arrays.deepEquals()的用法。
说明：此方法与 Arrays.equals(Object[],Object[]) 方法不同，此方法适用于任意深度的嵌套数组。
如果两个数组引用均为 null，或者它们引用了包含相同元素数量的数组，并且两个数组中的所
有相应元素对都是深层相等的，则认为这两个数组引用是深层相等的。
例：已知三个三维数组间的比较。
public class Practice{
public static void main(String[] args){
String[][][] d = new String[2][2][2];
d[1][1][1] = "a";
String[][][] e = new String[3][3][3];
e[1][1][1] = "a";
String[][][] f = new String[2][2][2];
f[1][1][1] = "a";
String[][][] g = new String[2][2][2];
g[1][1][1] = "ab";

System.out.println("--------------------------");
System.out.println("输出equals()方法与deepEquals()方法的区别；");
System.out.println("数组d与数组f进行比较： " + d.equals(f));
System.out.println("数组d与数组f进行

比较： " + Arrays.deepEquals(d, f));
System.out.println("--------------------------");

//下面输出比较结果
System.out.println("=================================");
System.out.println("数组d与数组e进行比较： " + Arrays.deepEquals(d, e));
System.out.println("数组d与数组g进行比较： " + Arrays.deepEquals(d, g));
System.out.println("=================================");
}
}
运行结果为：
--------------------------
输出equals()方法与deepEquals()方法的区别；
数组d与数组f进行比较： false
数组d与数组f进行比较： true
--------------------------
=================================
数组d与数组e进行比较： false
数组d与数组g进行比较： false
=================================
十一、Collections.reverseOrder()用法(反转自然的顺序)；
例：用除了循环外的另一方式逆向输出已知数组a？
public class Practice{
public static void main(String[] args){
String[] a = {"a","b","c"};
Arrays.sort(a,Collections.reverseOrder());
System.out.println(Arrays.asList(a));
}
}
运行结果为：[c, b, a];