数组是一个容器，长度在初始化时进行定义，一但定义，长度就不可以改变，数组中存放的都是相同类型的数据。
一维数组(以整型数组为例，其余类型可以直接将int替换为你想要的数据类型就可以)： 1.int []a; 2.int a[];
Java中的数组必须进行初始化之后才可以使用，所谓初始化就是为定义的数组分配内存空间，并为每个元赋值
一维数组(以整型数组为例，其余类型可以直接将int替换为你想要的数据类型就可以)： 1.动态初始化：int []a = new int[n],n表示数组长度，是大于0 的整数 2.静态初始化：int []a = new int[]{1,2,3}; int []a={1,2,3};
索引：数组会自动为存储进来的元素进行索引的分配，从0开始，最大的索引为数组的长度减一。 格式：数组名[索引]
import java.util.Scanner; public class Demo { public static void main(String[] args) { //一维数组的定义 int []arr = new int[]{1,2}; int []arr2={5,6}; //遍历通过索引输出输出数组中的元素 for (int i = 0; i < arr.length; i++) { System.out.printf(arr[i]+" "); } System.out.println(); for (int i = 0; i < arr2.length; i++) { System.out.printf(arr2[i]+" "); } } } /** * 输出结果 * 1 2 * 5 6 * Process finished with exit code 0 */ import java.util.Scanner; //动态为数组进行赋值 public class Demo { //break和continue案例 public static void main(String[] args) { //一维数组的定义 int []arr = new int[5]; //创建Scanner对象进行输入操作 Scanner sc = new Scanner(System.in); System.out.println("请输入5个数："); for (int i = 0; i <arr.length ; i++) { arr[i]=sc.nextInt(); } System.out.println("数组中存储的是："); for (int i : arr) { System.out.printf(i+" "); } } } /** * 输出结果 请输入5个数： 3 5 2 4 3 数组中存储的是： 3 5 2 4 3 * Process finished with exit code 0 */二维数组可以理解为存储的元素为一维数组的一维数组；
以int类型为例： 1.int [][]a; 2.int [] a[]; 3.int a[][] 后面两种不推荐使用哦！ 二维数组的初始化方式： 1.int [][]a = new int [n][m];(动态) 2.int [][]a = new int [][]{{1,2},{2,3},{3,4}};(静态) 3.int [][]a = {{1,2},{2,3},{3,4}};(静态)
Arrays类包含用于操作数组的各种方法（如排序和搜索）。
1.asList
@Test public void Demo1(){ /*asList(T... a)返回由指定数组支持的固定大小的列表 * 该方法若参数出入数组，则返回的是一个泛型为一维数组类型的List集合 * */ int [][]a = new int[][]{{1,2,3,4},{2,3,4,5}}; List<int[]> ints = Arrays.asList(a); for (int[] anInt : ints) { System.out.println(Arrays.toString(anInt)); } //直接传入int，char等类型的常量会返回一个对应类型作为泛型的list List<Integer> integers = Arrays.asList(1, 2, 3); } /** * [1, 2, 3, 4] * [2, 3, 4, 5] */2.binarySearch（二分查找）,返回类型为int binarySearch的重载有很多，挑两个来说
@Test public void Demo2(){ /* binarySearch(byte[] a, byte key) 第一个参数代表在哪个数组（该数组必须是有序的）中进行查找，第二个参数表示在数组中查找什么值 使用二进制搜索算法搜索指定值的指定字节数组。 折半查找，若找到，则返回对应的索引，否则返回一个负数 */ byte []b = {4,1,2,3,6}; Arrays.sort(b); System.out.println(Arrays.binarySearch(b,(byte)6));//4 System.out.println(Arrays.binarySearch(b,(byte)5));//-5，数组中存在比5大的数，将这个第一个大于5得数的坐标变成负数再减一就可以作为返回值 System.out.println(Arrays.binarySearch(b,(byte)10));//-6,10大于数组中所有元素，所以返回的是数组长度取负数，再减一 } @Test public void Demo3(){ /* * binarySearch(byte[] a, int fromIndex, int toIndex, byte key) * 使用二进制搜索算法搜索指定值的指定字节数组的范围。 * 找到就返回对应的索引 * */ byte []b = {3,5,28,10,19,26,24,11};//3,5,10,11,19,24,26,28 Arrays.sort(b); System.out.println(Arrays.binarySearch(b,1,5,(byte)10));//2, System.out.println(Arrays.binarySearch(b,1,5,(byte)20));//-6 System.out.println(Arrays.binarySearch(b,1,5,(byte)30));//-6,在给定数组索引范围内，没有这个值，就将右边的索引取反减一 }2.copyOf（拷贝）,返回类型为数组
@Test public void Demo6(){ /*copyOf(int[] original, int newLength) 使用 false （如有必要）复制指定的数组，截断或填充，以使副本具有指定的长度。 original：原数组，即用于被copy的数组 newLength:新数组的长度 将已有数组的元素拷贝到一个新的数组，拷贝的长度自己定义，若超过现有长度，则补位数据类型的默认值 */ int []a={2,3,4,5,6,7,8,910}; int[] ints = Arrays.copyOf(a, 8); for (int anInt : ints) { System.out.println(anInt); } System.out.println("a==ints:"+(ints==a));//双等于号是比较地址 System.out.println("Arrays.equals():"+(Arrays.equals(a,ints)));//这里比较数值 char []c = {'c','r','f','g','h','j','i'}; char[] chars = Arrays.copyOf(c, 10); for (char aChar : chars) { System.out.print(aChar+",");//c,r,f,g,h,j,i, , , ,123 } System.out.println("123"); } @Test public void Demo8() { /*copyOfRange(int[] original, int from, int to) 将指定数组的指定范围复制到新数组中。 original:被拷贝的数组， from：拷贝开始的索引 to：to-1为拷贝的最后一个元素的索引，实际操作是无法拷贝到to的 */ int []a = {1,2,3,4,5,6,7,8,9}; int[] ints = Arrays.copyOfRange(a, 1, 5);//实际是将1-4索引对应的元素拷贝到新的数组中 for (int anInt : ints) { System.out.println(anInt); } }**3deepEquals(Object[] a1, Object[] a2)
@Test public void Demo9() { /* deepEquals(Object[] a1, Object[] a2) 如果两个指定的数组彼此 深度相等 ，则返回 true*/ String[] s1 = {"123","456","789"}; String[] s2 = {"123","456","789"}; String[] s3 = {"123","456"}; System.out.println(Arrays.deepEquals(s1,s2)); System.out.println(Arrays.deepEquals(s1,s3)); String [][]s4={{"123","456","789"},{"123","456","789"},{"123","456","789"}}; String [][]s6={{"123","456","111"},{"123","456","789"},{"123","456","789"}}; String [][]s7={{"123","456","111"},{"123","456","789"},{"123","456","789"}}; String [][]s5 = {{"123","456","789"}}; System.out.println(Arrays.deepEquals(s4,s5)); System.out.println(Arrays.deepEquals(s4,s6));//false,并且两个数组中所有对应的元素对都相等，则两个数组引用被认为是相当相等的。 System.out.println(Arrays.deepEquals(s7,s6));//比较值，多维数组展开后进行比较，有一个不同，则为false }4.deepToString
@Test public void Demo11() { /* deepToString(Object[] a) 返回指定数组的“深度内容”的字符串表示形式。*/ String[] s1 = {"123","456","789"}; String [][]s5 = {{"123","456","789"},{"123","456","7"}}; System.out.println(Arrays.toString(s1));//[123, 456, 789] System.out.println(Arrays.toString(s5));//[[Ljava.lang.String;@30946e09, [Ljava.lang.String;@5cb0d902] //上述运行结果可知，toString可以返回一维数组的字符串表示形式，对于多维的，只是返回第一维展开的地址 //deepToString可以将多维数组展开 System.out.println(Arrays.deepToString(s5));//[[123, 456, 789], [123, 456, 7]] }4.fill
@Test public void Demo12() { /* fill(int[] a, int val) 将指定的int值分配给指定的int数组的每个元素,原数组中若有值，则进行替换 fill(int[] a, int fromIndex, int toIndex, int val) 将指定的int值分配给指定的int数组的指定范围的每个元素。 */ int []a = {1,2,3,4,5}; Arrays.fill(a,8); for (int i : a) { System.out.print(i+" "); } System.out.println(); Arrays.fill(a,0,3,77);//值赋值给索引是0-2的 for (int i : a) { System.out.print(i+" "); } } /** * 8 8 8 8 8 * 77 77 77 8 8 */5.sort(底层为快排)
/* sort(int[] a) 按照数字顺序排列指定的数组。 sort方法可以对各种类型的数据进行排序，只要实现Comparable接口即可进行比较 */ @Test public void Demo15() { int []a = {7,5,6,8,9,2}; Arrays.sort(a); System.out.println("排序后的结果为："); for (int i : a) { System.out.printf(i+" "); } /** * 排序后的结果为： * 2 5 6 7 8 9 */ }