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