Java基础之数组-->>数组常用操作

2018-06-18 02:18:59来源：未知阅读 ()

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}};

	列下标0	列下标1	列下标2	列下标3
行下标0	10	20	30	40
行下标1	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
*/