[PHP知识库]Java学习笔记----数组

对于数组本身属于引用型数据，其定义的语法如下：

• 声明并开辟数组

数据类型? 数组名称? []? =? new 数据类型? [长度]

数据类型? []? 数组名称? =? new 数据类型? [长度]

• 分布完成

声明数组：? ? ? ? 数据类型? 数组名称? []? =? null；

开辟数组：? ? ? ? 数组名称? =? new? 数据类型? [长度]

当数组开辟空间后，可以采用“数组名称[下标[索引]]”的形式进行访问，所有数组的下标都是从0开始的。Java为了方便数组的输出，提供了一个“数组名称.length”的属性，从而得到数组的长度。

例.定义数组

public class ArrayDemo {
    public static void main(String args[]){
        int data[] = new int[3];              //声明并开辟一个长度为3的数组
        data[0] = 10;                         //设置数组内容
        data[1] = 20;
        data[2] = 30;
        for (int x = 0;x < data.length;x++){  //循环输出数组
            System.out.print(data[x] + "、");
        }
    }
}

10、20、30、

数组本身属于引用数据类型，所以在数组的操作中依然可以进行内存空间的引用传递

例.数组的引用传递

public class ArrayDemo {
    public static void main(String args[]){
        int data[] = new int[3];              //声明并开辟一个长度为3的数组
        data[0] = 10;                         //设置数组内容
        data[1] = 20;
        data[2] = 30;
        int temp[] = data;                    //数组引用传递
        temp[0] = 99;                         //修改数组内容
        for (int x = 0;x < data.length;x++){  //循环输出数组
            System.out.print(data[x] + "、");
        }
    }
}

99、20、30、

以上的例子可见，在数组的使用过程中，首先是开辟新的数组，然后为数组中的每一个元素进行赋值，这种形式的操作属于数组动态数据化

数组中也提供了静态初始化的操作，即数组定义的同时就设置好了相应的数据内容，格式如下：

• 简化格式

数据类型? 数组名称? []? =? {值，值，值.....};

• 完整格式

数据类型? 数组名称? []? =? new? 数据类型? []? {值，值，值.....};

例.数组的静态初始化

public class ArrayDemo {
    public static void main(String args[]){
        int data[] = new int [] {1,2,3,4,5};
        for (int x = 0;x < data.length;x++){
            System.out.print(data[x] + "、");
        }
    }
}

1、2、3、4、5、

二维数组：用于保存多行多列的数据

基本定义语法如下：

动态初始化：数据类型? 数组名称[][]? =? new? 数据类型[行的个数][列的个数];

静态初始化：数据类型? 数组名称[][]? =? 数据类型[][]{{值，值，值.....},{值，值，值.....}};

public class ArrayDemo {
    public static void main(String args[]){
        int data[][] = new int[][]{
            {1,2,3},{4,5,6},{7,8,9}
        };
        for (int x = 0; x < data.length;x++){
            for (int y = 0; y < data.length; y++){
                System.out.print(data[x][y] + "\t");
            }
            System.out.println();
        }
    }
}

1       2       3
4       5       6
7       8       9

数组与方法参数的传递：若一个方法想要接收参数，则对应的参数类型必须是数组

例.一个数组传递的程序

public class ArrayDemo {
    public static void main(String args[]){
        int data[] = new int[] {1,2,3};
        change(data);         //引用传递，等价于：int temp[] = data
        for (int x = 0;x < data.length; x++){
            System.out.print(data[x] + "、");
        }
    }
    /**
     * 此方法的主要功能是进行数组数据的改变操作
     * @param temp 要进行改变内容的数组引用
     */
    public static void change(int temp[]){
        for (int x = 0; x < temp.length; x++){
            temp[x] *= 2;
        }
    }
}

2、4、6、

例.实现一个数组排序

• 原始数据：2、1、9、0、5、3、7、6、8；
• 一次排序：1、2、0、3、5、7、6、8、9；
• 二次排序：1、0、2、3、5、6、7、8、9；
• 三次排序：0、1、2、3、5、6、7、8、9；

（1）基础code实现

public class ArrayDemo {
    public static void main(String args[]){
        int data[] = new int[] {2,1,9,0,5,3,7,6,8};
        System.out.print("排序前的数据：");
        print(data);
        for (int x = 0;x < data.length;x++){
            for (int y = 0;y < data.length - 1;y++){
                if(data[y] > data[y+1]){
                    int t = data[y];
                    data[y] = data[y+1];
                    data[y+1] = t;
                }
            }
        }
        System.out.print("排序后的数据：");
        print(data);
    }
    /**
     * 此方法的主要功能是进行数组数据输出操作，输出完成后悔追加一个换行
     * @param temp 要进行改变内容的数据引用
     */
    public static void print(int temp[]){
        for (int x = 0;x < temp.length;x++){
            System.out.print(temp[x] + "、");
        }
        System.out.println();
    }
}

排序前的数据：2、1、9、0、5、3、7、6、8、
排序后的数据：0、1、2、3、5、6、7、8、9、

（2）改善设计：将主方法的程序简化，其余方法封装

public class ArrayDemo {
    public static void main(String args[]){
        int data[] = new int[] {2,1,9,0,5,3,7,6,8};
        sort(data);
        print(data);
    }
    public static void sort(int arr[]){
        for (int x = 0;x < arr.length;x++){
            for (int y = 0;y < arr.length - 1;y++){
                if(arr[y] > arr[y+1]){
                    int t = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = t;
                }
            }
        }
    }
    public static void print(int temp[]){
        for (int x = 0;x < temp.length;x++){
            System.out.print(temp[x] + "、");
        }
        System.out.println();
    }
}

0、1、2、3、5、6、7、8、9、

例.实现数组的转置（首尾交换）

对一维数组：

原始数据：1、2、3、4、5、6、7、8

转置后：? ? 8、7、6、5、4、3、2、1

思路一：首先定义一个新的数组，将原始数组按照倒序的方式插入到新的数组中，最后改变原始数组的引用，将其指向新的数组空间

public class ArrayDemo {
    public static void main(String args[]){
        int data[] = new int[] {1,2,3,4,5,6,7,8};
        int temp[] = new int[data.length];
        int foot = data.length - 1;
        for (int x=0; x<temp.length; x++){
            temp[x] = data[foot];
            foot--;
        }
        data = temp;
        print(data);
    }
    public static void print(int arr[]){
        for (int x=0; x<arr.length; x++){
            System.out.print(arr[x] + "、");
        }
    }
}

8、7、6、5、4、3、2、1、

以上的代码实现了转置的操作，但是代码里会产生垃圾，在代码开发的过程中应该尽可能减少产生垃圾空间

思路二：利用算法，在一个数组上完成转置操作，此时需要判断数组长度是奇数还是偶数的情况

• 数组长度为偶数，转换次数为：数组长度 / 2；

原始数组：? ?1、2、3、4、5、6

一次转置：? ? 6、2、3、4、5、1；

二次转置：? ? 6、5、3、4、2、1；

三次转置：? ? 6、5、4、3、2、1；

• 数组长度为奇数，转换次数为：数组长度 / 2 取整数；

原始数组：? ?1、2、3、4、5、6、7；

一次转置：? ? 7、2、3、4、5、6、1；

二次转置：? ? 7、6、3、4、5、2、1；

三次转置：? ? 7、6、5、4、3、2、1；

public class ArrayDemo {
    public static void main(String args[]){
        int data[] = new int[] {1,2,3,4,5,6,7};
        reverse(data);              //转置函数
        print(data);                //输出函数
    }
    /**
     * 实现数组的转置操作
     * @param arr 要进行转置的数组引用
     */
    public static void reverse(int arr[]){
        int len = arr.length / 2;
        int head = 0;
        int tail = arr.length - 1;
        for(int x = 0;x < len;x++){
            int temp = arr[head];
            arr[head] = arr[tail];
            arr[tail] = temp;
            head++;
            tail--;
        }
    }
    public static void print(int temp[]){
        for (int x = 0; x <temp.length; x++){
            System.out.print(temp[x] + "、");
        }
    }
}

7、6、5、4、3、2、1、

对以上的例子中实现了方法接收数组的操作，而方法本身也可以返回数组

例. 方法返回数组

public class ArrayDemo {
    public static void main(String args[]){
        int data[] = init();            //接收数组
        print(data);
        System.out.println(("数组长度：" + init().length));
    }
    public static int[] init(){         //方法返回数组
        return new int[]{1,2,3};
    }
    public static void print(int temp[]){
        for(int x = 0; x <temp.length; x++){
            System.out.print(temp[x] + "、");
        }
        System.out.println();
    }
}

1、2、3、
数组长度：3

数组的操作方法

1.数组复制：将一个数组的部分内容复制到另外一个数组中，其语法如下：

System.arraycopy(源数组名称，源数组复制开始索引位置，目标数组名称，目标数组复制开始索引位置，长度）

例.实现数组复制

• 数组A：1、2、3、4、5、6、7、8；
• 数组B：11、22、33、44、55、66、77、88；
• 将数组A的部分内容替换到数组B中，数组B的最终结果为：11、22、5、6、7、66、77、88；

☆System.arraycopy是内置函数，用于数组的复制

public class ArrayDemo{
    public static void main(String args[]){
        int dataA[] = new int[]{1,2,3,4,5,6,7,8};
        int dataB[] = new int[]{11,22,33,44,55,66,77,88};
        System.arraycopy(dataA,4,dataB,2,3);        //数组复制
        print(dataB);
    }
    public static void print(int temp[]){
        for(int x = 0; x <temp.length; x++){
            System.out.print(temp[x] + "、");
        }
        System.out.println();
    }
}

11、22、5、6、7、66、77、88、

2.数组排序：按照从小到大的顺序排序，其基本语法如下：

java.util.Arrays.sort（数组结构）

例.实现排序

public class ArrayDemo{
    public static void main(String args[]){
        int data[] = new int[]{3,6,1,2,8,0};
        java.util.Arrays.sort(data);        //数组排序
        print(data);
    }
    public static void print(int temp[]){
        for(int x = 0; x <temp.length; x++){
            System.out.print(temp[x] + " ");
        }
        System.out.println();
    }
}

0 1 2 3 6 8

对象数组：表示一个引用类型里面嵌套其他的引用类型

• 格式：对象数组的动态初始化

类名称? 对象数组名称? =? new? 类名称? [长度]

• 格式：对象数组的静态初始化

类名称? 对象数组名称? =? new? 类名称[]{实例化对象，实例化对象.....}

例.对象数组的动态初始化

class Book{
    private String title;
    private double price;
    public Book(String t,double p){
        title = t;
        price = p;
    }
    //setter、getter无参构造略
    public String getInfo(){
        return "书名：" + title + ";价格：" + price;
    }
}

public class ArrayDemo{
    public static void main(String args[]){
        Book books[] = new Book[3];                  //开辟一个长度为3的数组，内容为null
        books[0] = new Book("Java",79.8);            //对象数组的每个数据都要分别实例化
        books[1] = new Book("Jsp",68.8);
        books[2] = new Book("Python",88.3);
        for(int x = 0; x <books.length; x++){
            System.out.println(books[x].getInfo());
        }
    }
}

例.对象数组的静态初始化

class Book{
    private String title;
    private double price;
    public Book(String t,double p){
        title = t;
        price = p;
    }
    //setter、getter无参构造略
    public String getInfo(){
        return "书名：" + title + ";价格：" + price;
    }
}

public class ArrayDemo{
    public static void main(String args[]){
        Book books[] = new Book[]{
                new Book("Java",79.8),
                new Book("Jsp",66.3),
                new Book("Python",99.8)};
        for(int x = 0; x <books.length; x++){
            System.out.println(books[x].getInfo());
        }
    }
}

书名：Java;价格：79.8
书名：Jsp;价格：66.3
书名：Python;价格：99.8