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];
comparable comparator
网上找的资料保留下一个类实现了
Camparable
接口则表明这个类的对象之间是可以
相互比较的，这个类对象组成的集合就可以直接使用
sort
方法排序。
Comparator
可以看成一种算法的实现，将算法和数据分离，
Comparator
也可以在下面两种环境
下使用：
1
、类的设计师没有考虑到比较问题而没有实现
Comparable
，可以通过
Comparator
来实现排序而不必改变对象本身
2
、
可以使用多种排序标准，
比如升序、
降序等
六、使用
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];