Java_3 数组

1.数组概述

数组是具有相同数据类型的一组数据的集合。由基本数据类型组成的数组是对象。一维数组的每个基本单元都是基本数据类型的数据，二维数组就是每个单元是一维数组的一维数组，依此类推。

2.一维数组

一维数组的使之是一组相同类型数据的集合，当需要在程序中处理一组数据或者传递一组数据时，可以应用到这种类型的数组。

2.1 创建一维数组

数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型，即声明数组。

两种声明方式：

数组元素类型  数组名字[];
数组元素类型[]  数组名字;

声明数组后，还不能访问他的任何元素，因为声明数组仅仅是给出数组名字和元素的数据类型，要真正使用数组还要为其分配内存空间，且分配内存空间时必须指明数组的长度。

数组名字 = new 数组元素类型[数组元素的个数];

二者合并执行

数组元素类型 数组名[] = new 数组元素类型[数组元素个数];

2.2 初始化一维数组

数组可以与基本类型一样进行初始化操作，数组的初始化可分别初始化数组中的每个元素。
初始化数组时可以省略new运算符和数组的长度，编译器将根据初始值的数量来自动计算数组的长度，并创建数组。

两种初始化方式

int arr2[] = {34,23,12,6}
int arr[] = new int[]{1,2,3,4,5}

2.3 获取一维数组的最小值

public class MinNum{
    public static void main(String[] args){
        int[] num = {2,4,7,1,6,34};
        System.out.println("输出一维数组：");
        for(int i = 0;i<num.length;i++){
            System.out.print(num[i]+"  ");
        }
        int min = num[0];
        for(int j = 0;j<num.length-1;j++){
            if(min > num[j+1]){
                min = num[j+1];
            }
        }
        System.out.println("\n 一维数组的最小值是："+num);
    }
}

3.多维数组

3.1 二维数组

3.1.1 两种声明方式

数组元素类型 数组名字[][];
数组元素类型[][] 数组名字;
例：
a = new int[2][];
a[0] = new int[2];
a[1] = new int[3];

3.1.2 二维数组初始化

type arrayname[][] = {value1,value2````valuen};

例：int myarr[][] = {{12,0}{45,10}}
myarr[1][1] = 10;

例：在项目中创建Matrix类，在主方法中编写代码实现输出一个3行4列且所有元素都是0的矩阵。

public class Matrix {
    public static void main(String[] args){
        int a[][] = new int[3][4];
        System.out.println("输出3行4列的数组：");
        for(int i = 1;i<a.length;i++){
            for(int j = 0;j<a[i].length;j++){
                System.out.print(a[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

3.2 三维数组

三维数组使用三个中括号，初始化三维数组时，由三层大括号进行初始化，使用时也更加麻烦，需要三层for循环。

例

在项目中创建Ransack类，在类的主方法中创建三维数组，并将三维数组在控制台输出。

public class Ransack{
    public static void main(String[] args){
        int arr[][][] = new int[][][]{  //创建三维数组
        {{1,2,3},{4,5,6}},
        {{7,8,9}{10,11,12}},
        {{13,14,15}{16,17,18}}
        };
        for(int = 0;i<arr.length;i++){
            System.out.println("三维数组的第"+(i+1)+"个元素是一个"+arr[0].length+"维数组，内容如下：");
            for(int j = 0;j<arr[0].length;j++){
                    System.out.print(arr[i][j][k]+"\t");
                }
                System.out.println();
            }
        }
    }
}

3.3 范例：对矩形进行转置运算

所谓矩形的转置运算就是将矩阵的行列互换，把a[i][j]的值存储在元素a[j][i]的位置，转换前是m×n维矩阵，转换后则是n×m维矩阵。
在项目中创建ArrayRowColemnSwap类，在类的主方法中声明二维矩阵，然后将此矩阵进行转置运算，并将结果输出到控制台。

public class ArrayRowColumnSwap{
    public static void main(String[] args){
        int arr[][] = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
        System.out.println("转置前的矩阵是：");
        printArray(arr);
        int arr2[][] = new int[arr.length][arr.length];
        for(int i = 0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                arr2[j][i] = arr[i][j];
            }
        }
        System.out.println("转置后的矩阵是：");
        printArray(arr2);
    }
    private static void printArray(int[][] arr){
        for(int i = 0;i<arr.length;i++){
            for(int j = 0;j<arr.length;j++){
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}

3.4 范例：求方阵的迹

方阵的迹，即方阵主对角线上所有元素的和，迹同时也是方阵的所有特征值之和。

例：

在项目中创建Trace类，在类的主方法中创建二维方阵，然后求出方阵的迹，并在控制台将结果输出。

public class Trace{
    public static void main(String[] args){
        int arr[][] = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
        int tr = 0;
        System.out.println("方阵arr[][]是：");
        for(int i = 0;i<arr.length;i++){
            for(int j = 0;j<arr.length;j++){
                System.out.print(arr[i][j]+"  ");
            }
            System.out.println();
        }
        for(int i=0;i<arr.length;i++){
            tr+=arr[i][i];
        }
        System.out.println("方阵 arr[][]的迹是："+tr);
    }
}

4.数组的基本操作

java.util包的Arrays类包含用来操作数组（如排序和搜索）的各种方法。

4.1 遍历数组

在遍历数组时，通常使用for循环类实现。
在遍历数组时，使用foreach语句更简单，该语句并不是一个新的语法，而是for循环的简化格式。

例：

public class Tautog{
    public static void main(Strig[] args){
        int arr2[][] = {{3,4,3},{1,2}};
        System.out.println("二维数组中的元素是：");
        for(int x[]:arr2){
            for(int e:x){
                System.out.print(e+"  ");
            }
            System.out.println();
        }
    }
}

4.2 填充替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成任意类的数组元素的替换。fill()有两种参数类型。

1.fill(int[] a,int value)方法

该方法可将指定的int值分配给int型数组的每个元素。
语法格式：
fill(int[] a ,intvalue)
a:要进行元素替换的数组
value：要存储数组中所有元素的值
返回值：填充后的数组

2.fill(int[] a,intformIndex,int toIndex,int value)

该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromIndex（包括）一直到toIndex（不包括）。

如果fromIndex = = toIndex，则填充范围为空。

语法格式：
fill(int() a,int fromIndex,int toIndex,int value)
a：要进行填充的数组。
fromIndex：要使用指定值填充的第一个元素的索引（包括）。
toIndex：要使用指定值填充的最后一个元素的索引（不包括）。
value：要存储数组所有元素的值。
返回值：替换元素后的数组。

如果指定位置大于或者等于要填充的数组长度，则会报出数组越界异常（ArrayIndexOutOf-BoundsException）

4.3 对数组进行排序

通过Arrays类的静态sort()方法实现对数组的排序，sort()方法提供了多种的重载形式，可对任意类型的数组进行升序排序。
语法格式：
Arrays.sort(object)
object：指进行排序的数组名称。
返回值：排序后的数组。

import java.util.Arrays;
public class Taxis{
    public static void main(String[] args){
        int arr[] = new int[]{23,22,14,35,45,8,18};
        System.out.println("原一维数组是：");
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]+"  ");
        }
        Arrays.sort(arr);
        System.out.println("\n升序排列后的数组是：");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"  ");
        }
    }
}

Java语言中的String类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面。

4.4 复制数组

Arrays类的copy()方法与copyOfRange()方法可实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

1.copyOf()方法

该方法提供了很多种重载形式，来满足不同类型数组的复制。
copyOf(arr,int newlength)
arr：要进行复制的数组。
newlength：int型常量，指复制后的新数组的长度。如果新数组的长度大于数组arr的长度，则用0填充（根据复制数组的类型类决定填充的值，整型数组用0填充，char型数组则会使用null来填充）；如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取至满足新数组长度为止。
返回值：复制后的数组。

2.copyOfRange()方法

语法格式如下：
copyOfRange(arr,int formIndex,int toIndex)
arr：要进行复制的数组对象。
formIndex：指定开始复制数组的索引位置。formIndex必须是在0至整个数组的长度之间。新数组包括索引是formIndex的元素。
toIndex：要复制范围的最后索引位置。可以大于数组arr的长度。新数组不包括索引是toIndex的元素。
返回值：复制指定位置后的数组。

4.5 对比一维、二维数组所占内存

在项目中创建OneArrayMemory类，在类的主方法中使用一维、二维数组存储相同的数据，在控制台输出他们所占的内存。

public class OneArraysMemory{
    public static void main(String[] args){
        int num1 = 1024*1024*2;
        int[] arr1 = new int[num1];
        for(int i = 0;i<arr1.length;i++){
            arr1[i] = i;
        }
        //获取占用内存总数，并将单位转化为MB
        long menmory1 = Runtime.getRuntime().totalMemory()/1024/1024;
        System.out.println("用一维数组存储占用内存总量为："+memory1);
        int num2 = 1024*1024;
        int[][] arr2 = new int[num2][2];
        for(int i = 0;i<arr2.length;i++){
        arr2[i][0]=i;
        arr2[i][1]=i;
        }
        //获得占用内存总数，并将单位转换为MB
        long memory2 = Runtime.getRuntime().totalMemory()/1024/1024;
        System.out.println("用二维数组存储占用内存总量为："+memory2);
    }
}

4.6 直接插入排序

public class Sclect {
    //定义数组遍历操作
    public static void lastArr(int[] arr){
        for (int i : arr) {
            System.out.print(i+"  ");
        }
    }
    //调换操作
    public static void change(int[] arr,int firstIndex,int lastIndex){
        int tmp = arr[firstIndex];
        arr[firstIndex]=arr[lastIndex];
        arr[lastIndex]=tmp;
    }
    //选择排序
    public static void sclect(int arr[]){
    //外层循环控制比较的轮数n-1;
        for(int i=0;i<arr.length-1;i++){
            int p=i;
            for(int j=i+1;j<arr.length;j++){
                //判断当前p的元素是否大于j对应的元素
                if(arr[p]<arr[j]){
                    p=j;
                }
            }
            if(i!=p)
                change(arr, i, p);
        }
    }
    public static void main(String[] args) {
        // 初始化一个数组
        int arr[]=new int[5];
        Scanner in = new Scanner(System.in);
        System.out.println("请输入5名学生的成绩：");
        for(int i=0;i<arr.length;i++){
            arr[i] = in.nextInt();
        }
        sclect(arr);
        System.out.print("学生成绩按降序排列为：");
        lastArr(arr);
    }
}

4.7 冒泡排序

import java.util.Scanner;
public class Bubbling {
        //冒泡排序
    public static void bubbling(int[] arr){
        for(int i=1;i<arr.length;i++){
            for(int j=0;j<arr.length-i;j++){
            if(arr[j]>arr[j+1]){
                change(arr, j, j+1);
                }
            }
        }
    }
        //数组调换
    public static void change(int[] arr,int firstIndex,int lastIndex){
        int tmp = arr[firstIndex];
        arr[firstIndex]=arr[lastIndex];
        arr[lastIndex]=tmp;
    }
        //输出操作
    public static void lastArr(int[] arr){
        for(int i=0;i<arr.length;i++)
            System.out.print(arr[i]+"  ");
    }
    public static void main(String[] args){
        //输入五个数据
        Scanner in = new Scanner(System.in);
        int arr[]=new int[5];
        System.out.print("请输入需要排序的5个数据：");
        for(int i=0;i<arr.length;i++){
            arr[i] = in.nextInt();
        }
        System.out.println("排序前的数组顺序：");
        lastArr(arr);
        bubbling(arr);
        System.out.println("\n排序后的数组顺序：");
        lastArr(arr);
    }
}

4.8 二分法查找

public class Binary {

    public static void search(int[] arr,int tmp){
        //数组的下标最高位和最低位
        int hight=arr.length-1;
        int low=0;
        while(low<=hight){
            int p=(hight+low)/2;
            if(arr[p]==tmp){
                System.out.println("\n"+p);
                break;
            }
            else if(arr[p]>tmp)
                hight = p-1;
            else
                low = p+1;
        }
    }
    public static void main(String[] args) {

        int arr[]={1,5,5,3,8,4,10,33,45};
        Arrays.sort(arr);
        for (int i : arr) {
            System.out.print(i+"  ");
        }
        search(arr,5);
    }
}