Java数组，简简单单信手沾来~

最新推荐文章于 2024-05-18 16:42:38 发布

要一杯卡布奇诺

最新推荐文章于 2024-05-18 16:42:38 发布

阅读量178

点赞数 4

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_63200557/article/details/132286598

版权

——数组，一组相同数据类型的数据

一.一维数组

1.数组的基本概念

1）数组用于存储多个同一数据类型的数据

2）数组是数据类型【引用类型】

3）数组的形式：数据类型 + []

4）数组的下标从0开始

5）数组中的元素是通过下标进行访问的

6）数组的长度：数组名.length()

2. 一个小case快速了解数组

public class Test {
    public static void main(String[] args) {
          int[] arr1 = {1,2,3,4,5,6};//整型数组：只能存储整型数据
          //double[] arr2 = {1.2,2.3,3.45,5.6};//浮点数组：只能储存浮点型数据
          //char[] arr3 = {'a','b','c','d'.'e'};//字符数组：只能储存字符型数据
          
          //通过[]中的下标来访问数组
          System.out.println(arr1[0]);//访问第一个元素
          System.out.println(arr1[1]);//访问第二个元素
          System.out.println(arr1[2]);
          
          //求数组的长度：数组名.length
          System.out.println(arr1.length);//6
    }
}

3.数组的使用

1）初始化方式1：数据类型[ ] 数组名 = new 数据类型[大小];

public class Test {
    public static void main(String[] args) {
        //动态定义double数组，并且数组的大小为5
        double[] arr = new double[5];
        Scanner sc = new Scanner(System.in);
        
        //输入数据
        int i = 0;
        for(i=0;i<arr.length;i++)
            arr[i] = sc.nextDouble();

        //打印数据
        for(i=0;i<arr.length;i++)
            System.out.println(arr[i]);
    }
}

2）初始化方式2：数据类型[ ] 数组名 = {元素值1，元素值2，元素值3……}

public class Test {
    public static void main(String[] args) {
        //静态初始化数组
        int[] arr = {1,2,3,4,5,6};

        //打印数组中的数据
        int i = 0;
        for(i=0;i<arr.length;i++) {
            System.out.println(arr[i]);
        }
    }
}

4.数组的使用细节

1）数组是一组相同数据类型的组合

2）数组的数据类型一旦确定，不可改变

public class Test {
    public static void main(String[] args) {
        //数组是一组相同数据类型的组合
        int[] arr = {1,2,3,4,5,6};//全部是整型数据
        
        //数组的数据类型一旦确定，不可改变
        //int[] str = {1,2,3.4,6,6};//错误，整型数组只能储存整型数据，3.4是浮点型数据
        //int[] str = {'a',1,2,3};//错误，整型数组只能储存整型数据，'a'是字符
    }
}

3）数组创建后，若数据元素无赋值，则有默认值

int / short / byte / long : 0
float / double : 0.0    
char:'\u0000'        
boolean : false        
String : null
引用类型: null

4）数组的使用步骤

a.声明数组并开辟空间

b.给数组的各个元素赋值

c.使用数组

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //i.声明数组并开辟空间
        int[] arr = new int[5];
        
        //ii.给数组的各个元素赋值
        arr[0] = 1;//直接赋值
        arr[1] = 2;
        arr[2] = sc.nextInt();//输入赋值
        arr[3] = sc.nextInt();//输入赋值
        arr[4] = 5;
        
        //iii.使用数组
        int i = 0;
        for(i=0;i<arr.length;i++)
            System.out.println(arr[i]);
    }
}

5）数组的下标是从0开始

6）数组的下标必须在指定范围内使用，否则出现：下标越界异常

7）数组属于引用类型，数组型数据是对象

public class Test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};

        //数组的下标是从0开始
        System.out.println(arr[0]);

        //数组的下标必须在指定范围内使用，否则报错：下标越界异常
        //arr[6] = 0;//ArrayIndexOutOfBoundsException
        
        //7）数组属于引用类型，数组型数据是对象
        System.out.println(arr);//打印出arr数组的地址
    }
}

5.数组赋值

1）基本数据类型赋值，使用变量存储要存储的值即可

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = a;//把a的值赋给b
        System.out.println(b);//10
    }
}

2）数组之间的赋值是把数组的地址复制过来

public class Test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};
        int[] arr1 = arr;//把arr的地址赋给arr1

        //两者地址（hashcode)相同
        System.out.println(arr);//[I@4eec7777
        System.out.println(arr1);//[I@4eec7777

        arr1[0] = 10;//对数组中值的修改会使指向这个数组的另外一个数组的值也随着改变
        System.out.println(arr[0]);//10
        System.out.println(arr1[0]);//10
    }
}

6.数组拷贝

把一个数组的内容复制到另一个数组

public class Test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};
        int[] str = new int[arr.length];

        int i = 0;
        for(i=0;i<arr.length;i++) {
            str[i] = arr[i];
        }

        for(i=0;i<arr.length;i++) {
            System.out.print(str[i] + " "); // 1 2 3 4 5 6 7
        }
    }
}

7.数组扩容

当数组的空间不够时，对数组进行动态扩容

注：底层使用Arrays.copyOf()方法进行扩容

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = {1,2,3,4,5,6,7};
        char ch = '0';

        do {
            int[] str = new int[arr.length + 1];//进行扩容
            int i = 0;
            for(i=0;i<arr.length;i++) {
                str[i] = arr[i];
            }
            System.out.println("请输入要添加的数据：");
            str[arr.length] = sc.nextInt();

            arr = str;
            for(i=0;i<arr.length;i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println();//换行

            System.out.println("是否要继续添加数据(y/n)：");
            ch = sc.next().charAt(0);
            if(ch == 'n')
                break;
        }while(true);
    }
}

二.二维数组

1.二维数组的基本概念

1）概念：二维数组本质上是以数组作为数组元素的数组，即“数组的数组”

2）定义形式：数据类型[常量表达式][常量表达式] 数组名；

2.一个小case让你快速了解二维数组

public class Test {
    public static void main(String[] args) {
        int[][] arr = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

        System.out.println("二维数组的元素个数为：" + arr.length);//3，即3个一维数组

        //遍历二维数组
        //arr.length --> 二维数组中的第一维(行)的长度
        //arr[i].length --> 二维数组中第二维(列)的长度
        int i,j;
        for(i=0;i<arr.length;i++) {//二维数组的元素个数
            for(j=0;j<arr[i].length;j++) {//一维数组的元素个数
                //进行遍历输出
                System.out.print(arr[i][j] + " ");//1 2 3 4 5 6 7 8 9 10 11 12 
            }
        }
    }
}

3.二维数组的使用

初始化方式1：数据类型[ ][ ] 数组名 = new 数据类型[大小][大小];

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //初始化方式1:数组中的值都是默认值0，需要我们输入值在数组中去
        int[][] arr = new int[3][5];
        //System.out.println(arr[0][0]);//0

        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = sc.nextInt();//输入数据
            }
        }

        //输出数据
        //arr.length --> 二维数组中的第一维(行)的长度
        //arr[i].length --> 二维数组中第二维(列)的长度
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
        }
    }
}

初始化方式2：列数不确定

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //动态初始化:数组中的值都是默认值0，需要我们输入值在数组中去
        int[][] arr = new int[3][];
        //System.out.println(arr[0][0]);//0
        arr[0] = new int[1];//使用二维数组的第一维的第1个元素给二维数组的第二维开辟1个整型空间
        arr[1] = new int[2];//使用二维数组的第一维的第2个元素给二维数组的第二维开辟2个整型空间
        arr[2] = new int[3];//使用二维数组的第一维的第3个元素给二维数组的第二维开辟3个整型空间

        Scanner sc = new Scanner(System.in);
        //输入数据
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = sc.nextInt();
            }
        }

        //输出数据
        //arr.length --> 二维数组中的第一维(行)的长度
        //arr[i].length --> 二维数组中第二维(列)的长度
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
        }
    }
}

初始化方式3：数据类型[ ][ ] 数组名 =

{

{数据值1,数据值2……}, {数据值1,数据值2……}, {数据值1,数据值2……}

……}

public class Test {
    public static void main(String[] args) {
        //初始化方式3
        //数据类型[][] 数组名 = {{数据值1,数据值2……},{数据值1,数据值2……},{数据值1,数据值2……}……}
        int[][] arr = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};//3行4列

        //遍历arr中的值
        //arr.length --> 二维数组中的第一维(行)的长度
        //arr[i].length --> 二维数组中第二维(列)的长度
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
        }
    }
}

4.二维数组的细节讨论

1）二维数组的声明方式：int[ ][ ] arr 或 int[ ] arr[ ] 或 int arr[ ][ ]

//二维数组的声明方式：int[ ][ ] arr 或 int[ ] arr[ ] 或 int arr[ ][ ]
//int arr[][] = new int[3][5];//声明方式1：C语言的声明类型
//int[] arr[] = new int[3][5];//声明方式2
int[][] arr = new int[3][5];//声明方式3:Java最常用的声明方式

2）二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可相同，也可不同

public class Test {
    public static void main(String[] args) {
        //两个一维数组的长度不相同：第一个长度是2，第二个长度是4
        int[][] arr = {{1, 2}, {1, 3, 4, 5}};

        //遍历输出
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
        }
    }
}

5.杨辉三角

1）第一个元素和最后一个元素均是1

2）中间元素均是上一行元素左右元素的和

public class Test {
    public static void main(String[] args) {
        int[][] tangle = new int[12][];
        for (int i = 0; i < tangle.length; i++) {
            tangle[i] = new int[i + 1];//开辟空间
            for (int j = 0; j < tangle[i].length; j++) {
                if (j == 0 || j == tangle[i].length - 1) {
                    tangle[i][j] = 1;
                } else {
                    tangle[i][j] = tangle[i - 1][j] + tangle[i - 1][j - 1];//中间元素
                }
            }
        }

        //输出杨辉三角
        for (int i = 0; i < tangle.length; i++) {
            for (int j = 0; j < tangle[i].length; j++) {
                System.out.print(tangle[i][j]);
            }
            System.out.println();//换行
        }
    }
}

三.基本排序

1.冒泡排序

1）思想：对待排序数组进行从前向后的依次比较相邻元素的值，如果发现有逆序的数则进行交换，使值较大的/较小的逐渐从前向后移动。

2）时间复杂度：O(n^2)

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[6];
        int i = 0;
        for(i=0;i<arr.length;i++)
            arr[i] = sc.nextInt();

        bubbleSort(arr);//进行冒泡排序
        for(i=0;i<arr.length;i++) {
            System.out.print(arr[i] + " ");
        }
    }

    /**
     * 冒泡排序实现
     */
    public static void bubbleSort(int[] arr) {
        int i,j;
        for(i=0;i<arr.length - 1;i++) {
            for(j=0;j < arr.length - i - 1;j++) {
                //进行比较交换
                if(arr[j] > arr[j+1]) {
                    int temp = arr[j];//临时变量帮助交换
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

四.基本查找

1.顺序查找

1）思想：从给定的一组数据找查找待查找的数据，判断这组数据中是否存在这个待查找的数据

2）时间复杂度：O(n)

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int searchData = 7;//待查找值

        int res = find(arr,searchData);//顺序查找
        if(res == 0)
            System.out.println("要查找的值" + searchData + "不存在");
        else
            System.out.println("要查找值的下标是：" + res);
    }

    /**
     * 顺序查找
     * @param arr
     * @param searchData
     * @return 数组下标
     */
    public static int find(int[] arr, int searchData) {
        int i = 0;
        for(i=0;i<arr.length;i++) {
            //进行比较
            if(arr[i] == searchData)
                return i;
        }
        return 0;
    }
}

2.二分查找

1）思想：从有序的数据中，查找目标值，每次取有序数据的一半，然后和目标值进行比较，若大于，则往左边的找，若小于，则往右边找；往复循环，一直到找不到或找到情况

2）时间复杂度：O(logN)

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = {1,2,3,4,5,6,7,8,9,10};//有序数组
        int searchData = 7;//待查找值

        int res = binarySearch(arr,searchData);//二分查找
        if(res == 0)
            System.out.println("要查找的值" + searchData + "不存在");
        else
            System.out.println("要查找值的下标是：" + res);
    }

    public static int binarySearch(int[] arr, int searchData) {
        int left = 0;
        int right = arr.length - 1;

        while(left <= right) {
            //每次mid都要在查找范围的中间
            int mid = left + (right - left) / 2;
            //进行比较
            if(arr[mid] > searchData) {
                right = mid - 1;
            } else if(arr[mid] < searchData) {
                left = mid + 1;
            } else {
                return mid;//返回下标
            }
        }
        return 0;//没有查找到
    }
}