本文主要向大家介绍了JAVA语言基础之数组-数组常用操作，通过具体的内容向大家展示，希望对大家学习JAVA语言有所帮助。

3.2一维数组

3.2.1声明数组

数组类型[]  数组名称；int []   username;

或者

数组类型   数组名称[];int   username[];

3.2.2初始化一维数组

一维数组初始化有两种格式，一种是先声明再赋值，一种是直接声明并赋值

int []  array = new int[5];  //创建一个整型数组对象，长度为5；

int []  array = {1,2,3,4,5}; //创建一个整型数组对象，长度为5，并同时赋值；

用new 运算符来创建数组对象时，必须指定数组大小。创建数组对象时，仅仅是在内存中为数组变量分配指定大小的空间，并没有实际存储数据，这时数据会被自动赋初始值

//数字数组，初值是 0；//布尔数组，初值是false;//字符数组，初值是'\0';//对象数组，初值是null;

3.2.3访问一维数组

创建数组变量并赋值后，就可以访问数组中元素

class oneday

{

    public static void main(String[] args)

    {

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

        for(int i = 0;i<weeks.length;i++){

            System.out.print(weeks[i]+" ");

        }

    }

}

//结果 1 2 3 4 5 6 7

3.2.4修改一维数组元素

数组中元素值是可以改变的，在声明一个变量和创建一个数组对象后，可通过为数组中元素赋值方式，来修改数组中任一元素的值

class oneday

{

    public static void main(String[] args)

    {

        String[] students = {"张三","李四"};   //创建两个学生；

        int languageScore[] = new int[2];        //定义一个整型数组，保存两个同学的语文成绩

        languageScore[0] =97;                        //为第一个成绩赋值

        languageScore[1] =100;                        //为第二个成绩赋值

        System.out.println("张三："+languageScore[0]);

        System.out.println("李四："+languageScore[1]);

        }

    }

//结果：张三：97  李四：100

3.3数组常用操作

3.3.1数组长度

要获得数组长度，可以用数组本身length属性获得。

class oneday

{

    public static void main(String[] args)

    {

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

        int len = weeks.length;       //获取数组长度

        System.out.println("数组长度为："+len);

        }

    }//数组长度为：7

3.3.2数组填充

数组填充指的是将一个数组或数组指定元素用固定值添加到数组中，可以使用 Arrays 类提供的 fill 对数组填充

Arrays.fill(数组名，值);        //将值全部填充到数组

Arrays.fill(数组名，开始下标，结束下表，值);    //将值填充到开始下标到结束下标的部分

import java.util.Arrays;               //导入Arrays 类class oneday

{

    public static void main(String[] args)

    {

        int [] a = new int[5];    //定义一个整型数组a

        int [] b = new int[5];    //定义一个整型数组b        

        Arrays.fill(a,1);           //给数组a填充值 1

        Arrays.fill(b,2,4,0);     //给数组b下标2~4之间填充0

        //循环输出数组元素

        for(int i = 0;i<a.length;i++){

            System.out.print(a[i]+" ");

        }System.out.println();

        for(int i =0;i<b.length;i++){

            System.out.print(b[i]+" ");

        }System.out.println();

    }

    }// 1 1 1 1 1// 0 0 0 0 0

3.3.3数组复制

数组复制是将一个指定数组范围内的元素值复制到另一个数组中去，利用 Java 提供的 Arraycopy() 函数（方法）来进行数组的复制操作。

// Arraycopy (数组a,开始复制下标，复制到数组b，开始复制下标，复制长度);

eg:将数组a的元素从第二个开始复制到数组b的第二个元素开始中，复制5个长度

    import java.util.Arrays;               //导入Arrays 类

    class oneday

    {

        public static void main(String[] args)

        {

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

            int [] b ={11,12,13,14,15,16,17};

            System.arraycopy(b,1,a,1,5);

            System.out.println("复制后的a数组值为：");

            for(int i=0;i<a.length;i++){

                System.out.print(a[i]+" ");

            }

        }

    }// 复制后的a数组值为：//     1 12 13 14 15 16 7

3.3.4数组比较

数组之间可以比较，如果两个数组长度一样，并且相同位置的元素也一样，那么这两个数组相等；否则，不相等。可以使用 Arrays 提供的 equals 来判断两个数组是否相等。

// Arrays.equals(数组1，数组2)；

    import java.util.Arrays;               //导入Arrays 类

    class oneday

    {

        public static void main(String[] args)

        {

            int [] a = new int[5];

            int [] b = new int[5];

            Arrays.fill(a,1);    //给数组a填充1

            Arrays.fill(b,2,4,20);   //用20来填充数组b的下标2~4的部分

            if(Arrays.equals(a,b)){

                System.out.print("两个数组相等");

            }else{

                System.out.print("两个数组不等");

            }System.out.println();

        }

    }// 两个数组不等// Arrays.equals 返回值为 boolean

3.3.5数组排序

数组排序主要包括 sort 函数（方法）排序和冒泡排序

Arrays.sort(数组)；//或者

Arrays.sort(数组，开始下标，结束下标);

①sort 函数（方法）是升序排序，可以将数组全部排序，也可以在指定范围内将元素排序。

    import java.util.Arrays;               //导入Arrays 类

    class oneday

    {

        public static void main(String[] args)

        {

            int [] a = {12,62,53,74,8};

            int [] b = {45,68,2,56,7};

            //将数组a全部排序            Arrays.sort(a);

            //将数组b第2个和第4个之间排序

            Arrays.sort(b,2,4);

            System.out.println("数组a排序后为：");

            //循环输出a元素

            for(int i = 0;i<a.length;i++){

                System.out.print(a[i]+" ");

            }

            System.out.println();

            System.out.println("数组b排序后为：");

            for(int i = 0;i<b.length;i++){

                System.out.print(b[i]+" ");

            }

        }

    }/*

数组a排序后为：

8 12 53 62 74

数组b排序后为：45 68 2 56 7 */

②冒泡排序法 ，又称为交换排序法。

    class oneday

    {

        public static void main(String[] args)

        {

            int [] a = {12,62,53,74,8};

            int temp;                         //定义一个中间量进行交换

            for(int i = 0;i<a.length;i++){

                for(int j = i;j<a.length;j++){

                    if(a[i]>a[j]){

                        temp = a[i];

                        a[i]=a[j];

                        a[j]=temp;

                    }

                }

            }

            System.out.println("数组a排序后：");

            for(int i=0;i<a.length;i++){

                System.out.print(a[i]+" ");

            }

        }

    }

/*

数组a排序后：

8 12 53 62 74*/

3.3.6在数组中搜索指定元素

使用 Arrays 提供的 binarySearch 函数来搜索指定元素

binarySearch(数组，指定元素);//或者

binarySearch(数组，开始位置，结束位置，指定元素);

binarySearch 方法返回值是 int 类型，指所在的下标

    class oneday

    {

        public static void main(String[] args)

        {

            int [] a = {12,62,53,74,8};

            int num1 = Arrays.binarySearch(a,53);

            System.out.println("53的下标为："+num1);

        }

    }//53的下标为：2

3.3.7把数组转换成字符串

任何数组类型都可以使用 Arrays 类的 toString 函数（方法）转换为字符串。

// toString(数组类型，数组名);

返回值为字符串类型

    class oneday

    {

        public static void main(String[] args)

        {

            int [] a = {12,62,53,74,8};

            double [] b = {3.68,56.44,99.51,12.3};

            //输出数组转换后的字符串

            System.out.println("int类型数组a转换成字符串为："+Arrays.toString(a));

            System.out.println("double类型数组b转换成字符串为："+Arrays.toString(b));

        }

    }/*

int类型数组a转换成字符串为：[12, 62, 53, 74, 8]

double类型数组b转换成字符串为：[3.68, 56.44, 99.51, 12.3]*/

3.4多维数组

3.4.1声明二维数组

数组类型 [] [] 数组名字;int [] [] num;

//或者

数组类型 数组名字 [] [];int num [] [];

3.4.2创建二维数组

创建二维数组对象有两种格式：

int [] [] num = new int[3][4];   //创建一个int类型的二维数组，长度为3和4；

String[][] username = new String[2][2] //创建一个string类型数组，长度为2和2

//或者//创建并赋值int [][] num = {{3,4,5},{6,7,8,9}};

String [][] username = {{"张三","李四"},{"赵二"，"老王"}};

3.4.3访问二维数组

创建数组变量并赋值后就可以访问二维数组，第一个下标为行索引，第二个下标为列索引

//int[] [] num1={{10,20,30,40},{50,60,70,80}};

    class oneday

    {

        public static void main(String[] args)

        {

            int[] [] num1={{10,20,30,40},{50,60,70,80}};

            System.out.println(num1[0][2]);

        }

    }//30

上述输出数组num1的第一行（下标为0）第三列（下标为2）的元素，输出值为：30

 3.4遍历二维数组

    import java.util.Arrays;               //导入Arrays 类

    class oneday

    {

        public static void main(String[] args)

        {

            int [] [] a={{1,2,3},{4,5,6},{7,8,9}};       //定义一个整型二维数组a

            int [] [] b=new int[3][3];                        //定义一个整型二维数组b                

            int k = 1;

            int i,j =0;

            for(i=0;i<b.length;i++){

                for(j=0;j<b[i].length;j++){

                    b[i][j]=k++;

                }

                //输出a数组；

                System.out.println("输出a数组");

                for(i=0;i<a.length;i++){

                    for(j=0;j<a[i].length;j++){

                        System.out.print(a[i][i]+" ");

                    }

                    System.out.println();

                }

                //输出b数组

                System.out.println("输出b数组");

                for(i=0;i<b.length;i++){

                    for(j=0;j<b[i].length;j++){

                        System.out.print(b[i][j]+" ");

                    }

                    System.out.println();

                }

            }

        }

    }

/*

输出a数组

1 1 1

5 5 5

9 9 9

输出b数组

1 2 3

0 0 0

0 0 0*/

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注编程语言JAVA频道！