当前聚焦：Java数组详解 java语言中使用数组的方法

数组

数组的定义

(相关资料图)

数组的声明创建

必须先声明数组变量，才可以在程序中使用数组

int[] array; //首选的方法int array[];

java语言中使用new操作符来创建数组

int[] array = new int[10];

数组的元素是通过索引访问的，数组索引从0开始。：array[0]获取数组长度 ：arrays.length

例:

public class ArrayDemo01 {public static void main(String[] args) {int[] nums; //1、声明一个数组        nums = new int [10]; //2、创建一个数组        int sum = 0;        //3、给数组赋值        for (int i = 0; i<NUMS.LENGTH ;="" i++)="" {nums[i]= (i+1);        }        //4、计算所有元素的和        for (int i = 0; iSystem.out.print(nums[i]+" ");        }        System.out.println();        //5、获取数组长度 array.length        for (int i = 0; isum = sum + nums[i];        }        System.out.println("和为 "+sum);    }}//执行结果1 2 3 4 5 6 7 8 9 10 和为 55Java 的 for each 循环Java可以用一个功能来依次处理数组中的每个元素（其他类型的元素集合亦可）而不必为指定下标值分心。     这种增强的for循环格式为：for (变量类型 新变量名:数组名)      System.out.println(新变量名);int[] a = {1, 3, 8};for (int element: a)    System.out.println(element);//执行结果138

打印数组 a 的每一个元素，一个元素占一行。     (优势)这个循环应该被读作“循环a中的每一个元素”(for each element in a)。当然，传统的for循环也可以获得的同样的效果，但是需要花费精力去关心下标的起始值和终止值。 去关心下标的起始值和终止值。

内存分析

三种初始化

静态初始化

int [] a = {1,2,3,4,5,6};

动态初始化

int [] b = new int[10]; b[0]=1; b[1]=2;

数组的默认初始化

数组为引用类型，元素相当于类的实例变量，因此数组如果被分配了空间，其中的每个元素也被按照实力变量同样的方式被隐式初始化。

数组的四个基本特点

其长度是确定的。数组一旦被创建，大小不能改变。其元素必须是相同类型数组中的元素可以是任何的类型，包括引用类型和基本类型数组变量为引用类型，可以看其为对象。数组中元素看其为对象的成员变量。数组本身就是对象，Java中对象在堆中，故数组无论是原始类型还是其他对象类型，数组对象本身都在堆中。

数组边界

下标的合法区间：[0,lenght-1]数组就是相同类型的有序集合数组也是对象，数组元素相当于对象的成员变量数组长度的确定，不可变的，如果越界，报错：java.lang.ArrayIndexOutOfBoundsException:数组越界错误

数组的使用

public class ArrayDemo04 {public static void main(String[] args) {int[] nums = {1,2,3,4,5,6,7,8,9,10};//用for-each 增强型循环遍历数组，但是不可以操控下标值        for (int num : nums) {System.out.print(num+" ");        }        System.out.println();        System.out.println("=======================================");        int[] fan = resever(nums);        print(nums);        System.out.println();        print(fan);    }//反转数组    public static int[] resever(int[] arrays){int[] result = new int[arrays.length];        for (int i = 0,j=result.length-1; i<ARRAYS.LENGTH ;="" {result[j] = arrays[i];        }        return result;    }//输出数组方法    public static void print(int[] arrays){for (int i = 0; i<ARRAYS.LENGTH ;="" i++)="" {System.out.print(arrays[i]+" ");        }    }}//执行结果1 2 3 4 5 6 7 8 9 10 =======================================1 2 3 4 5 6 7 8 9 10 10 9 8 7 6 5 4 3 2 1多维数组二维数组int a[][] = new int[2][5];练习：public class ArrayDemo05 {public static void main(String[] args) {//定义二维数组        int[][] a = {{1,3,4},{2,7,6},{7,5,3},{8,5,3}};        //遍历二维数组        for (int i = 0; i <A.LENGTH ;="" i++)="" {for (int j = 0; j System.out.print(a[i][j]+" ");            }            System.out.println();        }    }}Arrays类数组的工具类 ava.util.Arrays;对数据对象进行基本操作查看JDK帮助文档Arrays类中的方法都是static修饰的静态方法，在使用的时候可以使用类名进行调用，不用使用对象来调用（是不用不是不能）常用功能给数组赋值： 通过fill方法给数组排序： 通过sort方法，按升序比较数组：通过equals方法比较数组中元素是否相等。查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。练习：public class ArrayDemo06 {public static void main(String[] args) {int[] a = {1,3,42,7,7,5,38,5,3};        //遍历数组        System.out.println(Arrays.toString(a));        //排序，升序        Arrays.sort(a);        System.out.println(Arrays.toString(a));        //给数组赋值        Arrays.fill(a,2,7,22);//第2到第7之间元素被22填充        System.out.println(Arrays.toString(a));    }}

冒泡排序

外层循环：决定排序趟数

内层循环：决定该趟的比较次数。

练习：

package com.array;import java.util.Arrays;public class ArrayDemo07 {public static void main(String[] args) {int[] arrays = {3, 2, 5, 89, 8, 4, 10, 32, 167};        sort(arrays);        System.out.println(Arrays.toString(arrays));    }    public static void sort(int[] array) {int max = array[0];        int t = 0;        //外层循环决定排序多少趟。        for (int i = 0; i < array.length - 1; i++) {boolean flag = false;            //内层循环决定每趟比较多少次            for (int j = 0; j < array.length - 1-i; j++) {if (array[j] < array[j + 1]) {t = array[j];                    array[j] = array[j + 1];                    array[j + 1] = t;                    flag = true;                }                if (flag == false ){break;                }            }        }    }}//执行结果[167, 89, 32, 10, 8, 5, 4, 3, 2]

稀疏数组

例：

package com.array;import java.util.Arrays;public class ArrayDemo08 {public static void main(String[] args) {//定义初始数组        int[][] begin = new int[10][10];        begin[2][3] = 1;        begin[3][4] = 2;        begin[4][5] = 3;        //输出初始数组        System.out.println("起始数组：");        for (int i = 0; i<BEGIN.LENGTH ;="" i++)="" {for (int j = 0; jSystem.out.print(begin[i][j]+"\t");            }            System.out.println();        }        System.out.println("=============================");        //*****转换成稀疏数组            //1、先获取有效值        int sum=0;        for (int i = 0; ifor (int j = 0; jif (begin[i][j]!=0){sum++;                }            }        }           //2、创建稀疏数组。        int[][] over = new int[sum+1][3];        over[0][0]=10;        over[0][1]=10;        over[0][2]=sum;           //3、赋值        int count = 0;        for (int i = 0; i<BEGIN.LENGTH ;="" i++)="" {for (int j = 0; jif (begin[i][j]!=0){count++;                    over[count][0]=i;                    over[count][1]=j;                    over[count][2]=begin[i][j];                }            }        }        //输出稀疏数组        System.out.println("输出稀疏数组：");        for (int i = 0; i<OVER.LENGTH ;="" i++)="" {for (int j = 0; j<OVER[0].LENGTH ;="" {System.out.print(over[i][j]+"\t");            }            System.out.println();        }        System.out.println("=============================");        //返回原数组          //创建一个数组；        int[][] array = new int[over[0][0]][over[0][1]];        //赋值        for (int i = 1; i<OVER.LENGTH ;="" i++)="" {array[over[i][0]][over[i][1]]=over[i][2];        }        //输出数组        System.out.println("输出还原的数组：");        for (int i = 0; i<ARRAY.LENGTH ;="" i++)="" {for (int j = 0; j<ARRAY[0].LENGTH ;="" {System.out.print(array[i][j]+"\t");            }            System.out.println();        }    }}//执行结果起始数组：0000000000000000000000010000000000200000000003000000000000000000000000000000000000000000000000000000=============================输出稀疏数组：10103231342453=============================输出还原的数组：0000000000000000000000010000000000200000000003000000000000000000000000000000000000000000000000000000