• Java 数组（Arrays）相关

    1.什么是数组？

    • 数组是相同类型数据的有序集合
    • 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
    • 其中，每一个数据称作一个数组元素，每个数组元素可用通过一个下标来访问它们。

    2.数组的声明和创建

    数组的四个基本特点：

    • 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
    • 其元素必须是相同类型，不允许出现混合类型。
    • 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
    • 数组变量属引用类型，数组也可以看成是对象，数组中的每一个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保持原始类型还是其他对象类型，数组对象本身是在堆中的。
    1. package org.psmaxwell.array;
    2.  
    3. public class ArrayDemo01 {
    4.     //变量的类型  变量的名字 = 变量的值;
    5.     //数组类型
    6.  
    7.     public static void main(String[] args) {
    8.         int[] nums; // 1.定义
    9.  
    10.         nums = new int[10];  //2.创建一个数组
    11.  
    12.         //3.给数组元素中赋值
    13.         nums[0] = 1;
    14.         nums[1] = 2;
    15.         nums[2] = 3;
    16.         nums[3] = 4;
    17.         nums[4] = 5;
    18.         nums[5] = 6;
    19.         nums[6] = 7;
    20.         nums[7] = 8;
    21.         nums[8] = 9;
    22.         nums[9] = 10;
    23.  
    24.         //计算所有元素的和
    25.         int sum = 0;
    26.         //获取数组长度： arrays.length
    27.  
    28.         for (int i = 0; i < nums.length; i++) {
    29.             sum = sum + nums[i];
    30.         }
    31.         System.out.println("总和为："+sum);
    32.     }
    33. }

    3.三种初始化及内存分析

     

     

    1. 静态初始化：
    2. int[] a = {1, 2, 3};
    3. Man[] mans = {new Man(1,1),new Man(2,2)};
    1. 动态初始化：
    2. int[] a = new int[2];
    3. a[0]=1;
    4. a[1]=2;

    数组的默认初始化：
    数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

    1. package org.psmaxwell.array;
    2.  
    3. public class ArrayDemo02 {
    4.     public static void main(String[] args) {
    5.         // 静态初始化: 创建 + 赋值
    6.         int[] a = {1,2,3,4,5,6,7,8,9};
    7.         System.out.println(a[0]);
    8.  
    9.         //动态初始化
    10.         int[] b = new int[10];
    11.         b[0] = 10;
    12.  
    13.         System.out.println(b[0]);
    14.         System.out.println(b[1]);
    15.         System.out.println(b[2]);
    16.         System.out.println(b[3]);
    17.     }
    18. }

    4.下标越界及小结

    1. package org.psmaxwell.array;
    2.  
    3. public class ArrayDemo02 {
    4.     public static void main(String[] args) {
    5.         // 静态初始化: 创建 + 赋值
    6.         int[] a = {1,2,3,4,5,6,7,8,9};
    7.         System.out.println(a[0]);
    8.  
    9.         for (int i = 0; i < a.length; i++) {
    10.             System.out.println(a[i]);
    11.         }
    12.  
    13.         //动态初始化： 包含默认初始化
    14.  //       int[] b = new int[10];
    15.  //       b[0] = 10;
    16.  //       b[1] = 10;
    17.  
    18.  //       System.out.println(b[0]);
    19.  //       System.out.println(b[1]);
    20.  //       System.out.println(b[2]);
    21.  //       System.out.println(b[3]);
    22.     }
    23. }

    5. 数组的使用

    • 普通的FOR循环
    •  FOR-Each循环
    • 数组作方法入参
    • 数组作返回值
    1. package org.psmaxwell.array;
    2.  
    3. public class ArrayDemo04 {
    4.     public static void main(String[] args) {
    5.         int[] arrays = {1,2,3,4,5};
    6.  
    7. //        //jdk 1.5 没有下标
    8. //        for (int array : arrays) {
    9. //            System.out.println(array);
    10. //        }
    11.  
    12. //        printArray(arrays);
    13.  
    14.         int[] reverse = reverse(arrays);
    15.         printArray(reverse);
    16.     }
    17.  
    18.     // 打印数组元素
    19.     public static void printArray(int[] arrays){
    20.         for (int i = 0; i < arrays.length; i++) {
    21.             System.out.print(arrays[i]+" ");
    22.         }
    23.     }
    24.  
    25.     //反转数组
    26.  
    27.     public static int[] reverse(int[] arrays) {
    28.         int[] result = new int[arrays.length];
    29.  
    30.         //反转的操作
    31.         for (int i = 0,j=result.length-1;i< arrays.length; i++,j--) {
    32.             result[j] = arrays[i];
    33.         }
    34.  
    35.         return result;
    36.     }
    37. }

    6.二维数组

    1. package org.psmaxwell.array;
    2.  
    3. public class ArrayDemo05 {
    4.     public static void main(String[] args) {
    5.         //[4][2]
    6.         /**
    7.          * 1,2   array[0]
    8.          * 2,3   array[1]
    9.          * 3,4   array[2]
    10.          * 4,5   array[3]
    11.          */
    12.         int[][] array = {{1,2},{2,3},{3,4},{4,5}};
    13.         for (int i = 0; i < array.length; i++) {
    14.             for (int j = 0; j < array[i].length; j++) {
    15.                 System.out.println(array[i][j]);
    16.             }
    17.         }
    18.  
    19. //        System.out.println(array[0][0]);
    20. //        System.out.println(array[0][1]);
    21. //        System.out.println(array[1][0]);
    22. //        System.out.println(array[1][1]);
    23. //        System.out.println(array[2][0]);
    24. //        System.out.println(array[2][1]);
    25. //        System.out.println(array[3][0]);
    26. //        System.out.println(array[3][1]);
    27.     }
    28.  
    29.     // 打印数组元素
    30.     public static void printArray(int[] arrays){
    31.         for (int i = 0; i < arrays.length; i++) {
    32.             System.out.print(arrays[i]+" ");
    33.         }
    34.     }
    35. }

     7.Arrays类讲解

    1. package org.psmaxwell.array;
    2.  
    3. import java.util.Arrays;
    4.  
    5. public class ArrayDemo06 {
    6.     public static void main(String[] args) {
    7.  
    8.         int[] a = {1,2,3,4,9000,1123,231,42,633,67,74};
    9.  
    10.        // System.out.println(a); //[I@e9e54c2
    11.  
    12.         //打印数组元素Arrays.toString
    13. //        System.out.println(Arrays.toString(a));
    14. //        printArray(a);
    15.  
    16.         Arrays.sort(a); //数组进行自动排序
    17.         System.out.println(Arrays.toString(a));
    18.     }
    19.  
    20.     public static void printArray(int[] a){
    21.         for (int i = 0; i < a.length; i++) {
    22.             if(i==0){
    23.                 System.out.print("[");
    24.             }
    25.             if(i== a.length-1){
    26.                 System.out.println(a[i]+"]");
    27.             }else{
    28.                 System.out.print(a[i]+", ");
    29.             }
    30.  
    31.         }
    32.     }
    33. }
    1. package org.psmaxwell.array;
    2.  
    3. import java.util.Arrays;
    4.  
    5. public class ArrayDemo06 {
    6.     public static void main(String[] args) {
    7.  
    8.         int[] a = {1,2,3,4,9000,1123,231,42,633,67,74};
    9.  
    10.        // System.out.println(a); //[I@e9e54c2
    11.  
    12.         //打印数组元素Arrays.toString
    13. //        System.out.println(Arrays.toString(a));
    14. //        printArray(a);
    15.  
    16.         Arrays.sort(a); //数组进行自动排序
    17.         System.out.println(Arrays.toString(a));
    18.         
    19.     }
    20.  
    21.     public static void printArray(int[] a){
    22.         for (int i = 0; i < a.length; i++) {
    23.             if(i==0){
    24.                 System.out.print("[");
    25.             }
    26.             if(i== a.length-1){
    27.                 System.out.println(a[i]+"]");
    28.             }else{
    29.                 System.out.print(a[i]+", ");
    30.             }
    31.  
    32.         }
    33.     }
    34. }

    8.冒泡排序

    1. package org.psmaxwell.array;
    2.  
    3. import java.util.Arrays;
    4.  
    5. public class ArrayDemo07 {
    6.     public static void main(String[] args) {
    7.         int[] a = {1,3,5,6,7,3,8,9,22,32,21,88};
    8.         int[] sort = sort(a);   //调用完我们自己写的排序方法以后，返回一个排序后数组
    9.  
    10.         System.out.println(Arrays.toString(sort));
    11.  
    12.     }
    13.     // 冒泡排序
    14.     //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    15.     //2.每一次比较，都会产生一个最大，或者最小数字
    16.     //3.下一轮则可以少一次排序
    17.     //4.依次循环，直到结束。
    18.  
    19.     public static int[] sort(int[] array){
    20.         //临时变量
    21.         int temp = 0;
    22.         //外层循环，判定我们这个要走多少次？
    23.         for (int i = 0; i < array.length-1; i++) {
    24.             boolean flag = false; // 通过flag标识位减少没有意义的比较  优化
    25.  
    26.             //内层循环，比价判定两个数，如果第一个数，比第二个数大，则交换位置。
    27.             for (int j = 0; j < array.length-1-i; j++) {
    28.                 if(array[j+1]>array[j]){
    29.                     temp = array[j];
    30.                     array[j] = array[j+1];
    31.                     array[j+1] = temp;
    32.                     flag = true;
    33.                 }
    34.             }
    35.             if(flag==false){
    36.                 break;
    37.             }
    38.         }
    39.         return array;
    40.  
    41.     }
    42. }

    9.稀疏数组

    1. package org.psmaxwell.array;
    2.  
    3. public class ArrayDemo08 {
    4.     public static void main(String[] args) {
    5.         //1.创建一个二维数组 11*11    1：黑棋  2：白棋
    6.         int[][] array1 = new int[11][11];
    7.         array1[1][2] = 1;
    8.         array1[2][3] = 2;
    9.         //输出原始数组
    10.         System.out.println("输出原始的数组:");
    11.  
    12.         for (int[] ints : array1) {
    13.             for (int anInt : ints) {
    14.                 System.out.print(anInt+"\t");
    15.             }
    16.             System.out.println();
    17.         }
    18.         System.out.println("===========================");
    19.         //转换为稀疏数组
    20.         //获取有效值的个数
    21.         int sum = 0;
    22.         for (int i = 0; i < 11; i++) {
    23.             for (int j = 0; j < 11; j++) {
    24.                 if(array1[i][j]!=0){
    25.                     sum++;
    26.                 }
    27.             }
    28.         }
    29.         System.out.println("有效值的个数："+sum);
    30.  
    31.  
    32.         //2.创建一个稀疏数组的数组
    33.         int[][] array2 = new int[sum+1][3];
    34.  
    35.         array2[0][0] = 11;
    36.         array2[0][1] = 11;
    37.         array2[0][2] = sum;
    38.  
    39.         //遍历二维数组，将非零的值，存放稀疏数组中。
    40.         int count=0;
    41.         for (int i = 0; i < array1.length; i++) {
    42.             for (int j = 0; j < array1[i].length; j++) {
    43.                 if (array1[i][j]!=0){
    44.                     count++;
    45.                     array2[count][0] = i;
    46.                     array2[count][1] = j;
    47.                     array2[count][2] = array1[i][j];
    48.                 }
    49.             }
    50.         }
    51.  
    52.         // 输出稀疏数组
    53.         System.out.println("稀疏数组");
    54.  
    55.         for (int i = 0; i < array2.length; i++) {
    56.             System.out.println(array2[i][0]+"\t"
    57.                     +array2[i][1]+"\t"
    58.                     +array2[i][2]+"\t");
    59.         }
    60.  
    61.         System.out.println("===========================");
    62.         System.out.println("还原");
    63.         //1.读取稀疏数组
    64.         int[][] array3 = new int[array2[0][0]][array2[0][1]];
    65.  
    66.         //2.给其中的元素还原它的值
    67.         for (int i = 1; i < array2.length; i++) {
    68.             array3[array2[i][0]][array2[i][1]] = array2[i][2];
    69.         }
    70.  
    71.         //3.打印
    72.         System.out.println("输出还原的数组:");
    73.  
    74.         for (int[] ints : array3) {
    75.             for (int anInt : ints) {
    76.                 System.out.print(anInt+"\t");
    77.             }
    78.             System.out.println();
    79.         }
  • 相关阅读:
    开发常用的 Linux 命令知识积累
    WalkMe的数字用户体验到底是啥
    淘宝详情接口调用示例
    存储大实验，游戏A Slower Speed of Light的开发
    辅导技巧-学习笔记
    JAVA入坑之Junit测试与断言
    批量给每一段文字 段落加上符号
    TELEC认证标准是什么？
    Java线程发生IO阻塞时的线程状态
    李宏毅2023机器学习作业HW06解析和代码分享
  • 原文地址：https://blog.csdn.net/u011868279/article/details/126296375