Java:数组的定义和使用

一.数组的定义

在Java SE中，数组是用来存储固定大小的相同类型数据的容器。它可以存储基本数据类型（如int、char、float等）或引用类型（如对象）。数组的长度一旦定义，无法动态更改。

1.数组的声明

 public static void main2(String[] args) {
        //数组定义的形式
        int[] array={1,2,3,4,5,6};
        int[] array1=new int[]{1,2,3,4,5,6};
        int[] array2=new int[10];
        int[] a;
        a=new int[10];
        /*int[] b;
        b={1,2,3,4,5,6};*///定义方法不正确

2.数组的访问

int[] arr = {1, 2, 3, 4, 5};
System.out.println(arr[0]);  // 输出第一个元素：1
System.out.println(arr[4]);  // 输出最后一个元素：5

3.数组的修改

arr[2] = 10;  // 将索引为2的元素修改为10
System.out.println(arr[2]);  // 输出10

4.数组的遍历

方法一：

 int[] array={1,2,3,4,5};
        String s=myTOingString(array);
        System.out.println(s);

myTOingString

    public static String myTOingString(int[] array) {
        String ret="[";
        for (int i = 0; i < array.length; i++) {
            ret+=array[i];
            if(i!= array.length-1){
                ret+=",";
            }
        }
        ret+="]";
        return ret;
    }

方法二：（foreach） 

    public static void main4(String[] args) {
        int[] array={1,2,3,4,5,6,};
        for (int x:array) {
            System.out.print(x+" ");
        }
    }

方法三：

   public static void main3(String[] args) {
        int[] array={1,2,3,4,5,6,};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

5.数组的长度

直接用数组名+.+length

int[] arr = {1, 2, 3, 4, 5};
System.out.println(arr.length);  // 输出数组的长度：5

二.数组是引用类型

1.什么是引用类型：

即使数组可以存储基本数据类型（如int[]存储整数），数组本身仍然是引用类型。与其他引用类型（例如对象）类似，数组变量存储的是数组在内存中的引用，而不是数组元素本身。 

 

 引用指向对象

array这个引用指向一个数组对象，而定义的blame则不是一个引用，所以无法指向对象。

2.深入理解

array1这个引用指向array2这个引用所指的对象

当2个引用同时指向一个对象的时候，通过任何一个引用都可以修改这个对象的值。

三.数组的使用

1.数组扩大两倍

    public static int[] blame1(int[] array){
        //把数组扩大两倍
        for (int i = 0; i < array.length; i++) {
            array[i]=array[i]*2;
        }
        return array;
    }
    public static int[] blame(int[] array){
        //数组中的每个数据扩大两倍
        int[] ret=new int[array.length];
        for (int i = 0; i < array.length; i++) {
            ret[i]=array[i]*2;
        }
        return ret;
    }
    public static void main7(String[] args) {
        int[] array={1,2,3,4,5,6};
        int[] ret=blame(array);
        System.out.println(Arrays.toString(ret));
        blame1(array);
        System.out.println(Arrays.toString(array));

2.数组的排序

2.1普通排序

    public static void main9(String[] args) {
        int[] array={2,64,5,34,7};
        System.out.println("排序前的数组");
        System.out.println(Arrays.toString(array));
        Arrays.sort(array);//可以用来排序
        System.out.println("排序后的数组");
        System.out.println(Arrays.toString(array));

        int array1=Arrays.binarySearch(array,1,5,34);//从1-3找34在第几位
        System.out.println(array1);
    }

2.2冒泡排序

   //冒泡排序
    public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            boolean flg=false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j]>array[j+1]){
                    int tem=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tem;
                    flg=true;
                }
            }
            if (flg==false)
                return;
        }

    }
    public static void main11(String[] args) {
        //排序前的数组
        int[] array={1,555,6,4,88,7,8,22};
        //排序后的数组
        bubbleSort(array);
        System.out.println(Arrays.toString(array));

    }

3.数组的查找

3.1普通查找

   //查找方式
    public static int findNum(int[] array,int key){
        for (int i = 0; i < array.length; i++) {
            if(array[i]==key){
                return i;
            }
        }
        return -1;
    }
    public static void main10(String[] args) {
        int[] array={1,2,3,4,8,9,55,15};
        System.out.println(findNum(array,2));
        System.out.println(binarySearch(array,8));

3.2二分查找

    //二分查找
    public static int binarySearch(int[] array,int key){
        int left=0;
        int right=array.length-1;
        while (left<=right){
            int mid=(right+left)/2;
            if(array[mid]==key){
                return mid;
            }else if(array[mid]>key){
                right=mid-1;
            }else {
                left=mid+1;
            }
        }
        return -1;
    }

4.数组的复制方法

    //数组的复制
    public static int[] copyArray(int[] array){
        int[] copy=new int[array.length];
        for (int i = 0; i < array.length; i++) {
            copy[i]=array[i];
        }
        return copy;
    }
    public static void main12(String[] args) {
        int[] array={5,6,3,4,2,1,55,};
        int[] copy=copyArray(array);//调用方法复制数组
        int[] copy1=Arrays.copyOf(array,array.length);//复制数组
        int[] copy2=Arrays.copyOfRange(array,1,3);//从1-3复制
        System.out.println(Arrays.toString(copy));
        System.out.println(Arrays.toString(copy1));
        System.out.println(Arrays.toString(copy2));
        int[] copy3=new int[array.length];
        System.arraycopy(array,0,copy3,0,array.length);
        System.out.println(Arrays.toString(copy3));
    }

System.arraycopy（）的源代码：

 

5.数组的比较

  public static void main13(String[] args) {
        int[] a1={1,2,3,6,5};
        int[] a2={1,2,3,6,5};
        System.out.println(a1==a2);//比较数组的地址是不同的
        boolean f=Arrays.equals(a1,a2);//比较数组中的值是相同的
        System.out.println(f);
    }

6.数组的填充 

    //数组的填充
    public static void main14(String[] args) {
        int[] array=new int[10];
        Arrays.fill(array,1,4,2);//从1-4用数字2填充
        System.out.println(Arrays.toString(array));
    }

四.二维数组

在Java SE中，二维数组是数组的数组，用来存储表格或矩阵形式的数据。它类似于一个矩阵，可以用来存储行和列的结构。二维数组本质上是一个引用数组，其中每个元素又是一个一维数组。

1.二维数组的声明

public static void main15(String[] args) {
        int[][] array=new int[][]{{14,1,1},{1,2,3}};
        int[][] array1=new int[1][2];
        int[][] array2=new int[1][];//可以不用管列

2.二维数组的遍历

2.1 Arrays.deepToString方法

        String s=Arrays.toString(array);
        String a=Arrays.deepToString(array);
        System.out.println(s);
        System.out.println(a);
        System.out.println(Arrays.toString(array[0]));
        System.out.println(Arrays.toString(array[1]));

2.2 for循环

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {//行的长度
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }

    }

2.3foreach 

for (int[] row : array) {
    for (int num : row) {
        System.out.print(num + " ");
    }
    System.out.println();  // 换行
}

3二维数组的长度

int rows = array.length;       // 行数
int cols = array[0].length;    // 第0行的列数

希望能对大家的学习有所帮助！！！