来源:Java核心技术、网上博客
目录
一、数组的概念
数组是一种数据结构, 用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。二维数组是指数组中的数组,二维数组的每一个元素是一个一维数组
二、定义数组的三种方式
1.一维数组
// 数据类型[] 数组名称 = new 数据类型 [长度];
int[] arr1 = new int[5];
int[] arr2 = new int[]{1,2,3,4,5};
int[] arr3 = {1,2,3,4,5};
注意:
- int[] 变量名也可以写成int 变量名[]
- 创建一个整形数组时,其中的元素会被默认初始化为0,boolean 数组的元素会初始化为 fals% 对象数组的元素则初始化为一个特殊值 null, 这表示这些元素(还)未存放任何对象。
2.二维数组
int[][] arr = new int[3][5];
int[][] arr = {{2,5},{1},{3,2,4},{1,7,5,9}};
三、数组的遍历
1.一维数组
数组的遍历有1.for, 2.while, 3.do…while, 4.增强for循环(foreach),4种方法,这里主要说明第4种。
for(数据类型 变量:数组(集合)){
输出(变量);
}
int[] a = {2,1,3,4};
for (int temp : a) {
System.out.println(temp);
}
2.二维数组
二维数组本质上和一维数组的遍历方式一致,主要搞清楚,什么代表行数,什么代表列数
int[][] arr = {{1,2},{3,4},{5,6}};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
四、数组的常用方法
操作数组的常用类是Arrays,注意不是Array
Array类主要提供了动态创建和访问 Java 数组的方法。
Arrays包含用来操作数组(比如排序和搜索)的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂
1.toString
返回指定数组的内容的字符串表示形式
// static String toString(Object[] a)
int[] arr3 = {1,2,3,4,5};
String s = Arrays.toString(arr3);
System.out.println(s);
2.aslist
返回由指定数组支持的固定大小的列表
static List asList(T… a)
String[] str = new String[]{"hello","java"};
List<String> strings = Arrays.asList(str);
注意:
- 看似这个方法返回一个List类型,但其实追踪到其源码
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
好像是返回了一个ArrayList集合,但是打开这个ArrayList发现这是Arrays自己包下的,所以这就导致了,这个集合不能进行add()、remove()、clear()等方法
- 该方法适用于对象型数据的数组(String、Integer…),如果是基本类型的数组则无法进行转换
System.out.println(Arrays.asList(new String[]{"a","b"}));
System.out.println(Arrays.asList(new Integer[]{3,4}));
System.out.println(Arrays.asList(new int[]{1,2}));
//输出
[a, b]
[3, 4]
[[I@1b6d3586]
- 该方法将数组与List列表链接起来:当更新其一个时,另一个自动更新
3.arraycopy
这个方法是System包下的,方法原型是
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
很显然这是一个本地方法,从src数组的下标为srcPos的索引开始,到后面length个元素放到dest数组的下标为destPos的索引开始的位置。注意:这里不能超出数组dest的最大存储空间,否则报ArrayIndexOutOfBoundsException异常
int[] a = new int[]{1,2,3,4,5};
int[] b = new int[]{6,7,8,9,0};
//将a数组下标为2的数开始,长度为3结束,复制到数组b下标为3的数开始,也就是输出为[6,7,8,3,4]
System.arraycopy(a,2,b,3,2);
for (int i = 0; i < b.length; i++) {
System.out.println(b[i]);
}
4.copyOf和copyOFRange方法
这两个方法是Arrays包下的。方法原型是:
- static short[] copyOf(short[] original, int newLength) (注意:这个方法有很多重载)
从数组的第一个元素开始复制,复制长度为length,若长度超过数组原长,则超出元素为默认值0
该方法返回一个数组
int[] c = Arrays.copyOf(a, 3);
for (int i = 0; i < c.length; i++) {
System.out.println(c[i]);
}
- public static double[] copyOfRange(double []original,int from,int to) (注意:这个方法有很多重载)
original下标为from的位置开始复制,到to-1的位置结束,返回一个长度为to-from的数组
5.数组的排序sort
这个方法是Arrays包下的
public static void sort(doule a[]) 将数组按升序全排序
public static void sort(doule a[],int start,int end);从索引为start到索引为end-1的位置,升序排序
int[] a = new int[]{5,4,3,7,2};
Arrays.sort(a);
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
但是如果要对该数组进行降序排序呢,可以使用sort的另外一个重载方法,传入一个实现了Comparator接口,重写了compare方法的实现类。方法原型是:
public static void sort(T[] a, Comparator<? super T> c)
//现了Comparator接口,重写了compare方法的实现类
class MyComparator implements Comparator<Integer> {
@Override
public int compare(Integer o1, Integer o2) {
return o1 > o2 ? -1 : 1;
}
}
public class demo1 {
public static void main(String[] args) {
Integer[] c = new Integer[]{3,2,7,1,5};
System.out.println();
Arrays.sort(c,new MyComparator());
for (int i = 0; i < c.length; i++) {
System.out.print(c[i] + " ");
}
}
}
当然也可以使用java.util.Collections包下的reverseOrder(),这个方法也返回一个Comparator实现类
Integer[] b = new Integer[]{3,2,7,1,5};
Arrays.sort(b,Collections.reverseOrder());
for (int i = 0; i < b.length; i++) {
System.out.print(b[i] + " ");
}
注意:这里的数组类型不能是基本数据类型,显然也用到了自动解装箱。
6.binarySearch
在数组中查找一个数的方法,看这个名字很显然使用了二分搜索算法,方法原型是
public static int binarySearch(double [] a,double number)
int a[] = {2,1,3,4};
int i = Arrays.binarySearch(a, 3);
System.out.println(i);
//输出结果是2
查看一下该方法的源码
// Like public version, but without range checks.
private static int binarySearch0(int[] a, int fromIndex, int toIndex,
int key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found
}