Java数组

数组的声明和创建

声明

• 声明数组变量的语法

   dataType[] arrayRefVar;//首选方法，数组类型[] 数组名
   dataType arrayRefVar[];//c、c++类型方法，不推荐

• Java使用new操作符来创建数组

   dataType[] arrayRefVar=new dataType[arraySize];

• 数组元素通过索引访问，索引从0开始

• 获取数组长度：

   array.length

• 列子

 public class Demo1 {
     public static void main(String[] args) {
         int[] nums;//声明一个数组
         nums=new int[10];//创建一个数组，长度为10
         nums[0]=10;//为第一个数赋值，未赋值数会默认值
         System.out.println(nums[0]);
         System.out.println(nums[1]);
     }
 }

Java内存分析及数组初始化

内存分析

数组初始化

• 静态初始化

 int[] nums={1,2,3}
 Man[] men={new Man(),new Man()};

• 动态初始化，动态初始化在new对象时总包含默认初始化

 int[] nums=new int[2];
 nums[0]=2;

• 默认初始化

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

数组的基本特点与下标越界

数组的基本特点

• 其长度是确定的。数组一旦被创建，其大小就不可改变

• 其元素必须是相同类型，不允许出现混合类型

• 数组中的元素可以是任何数据类型，包括基本类型和引用类型

• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。Java中对象是在堆中的。

数组的边界

• 数组下标的合法区间：[0,length-1]，越界就会报错

• 报错内容ArrayIndexOutOfBoundsException

数组使用

For-Each循环

 public class Demo1 {
     public static void main(String[] args) {
         int[] nums= {2,4,6,7,8};
         //普通方法遍历数组输出,也可以使用数组名.for快速输入代码
         for(int i=0;i<nums.length;i++){
             System.out.print(nums[i]+" ");
         }
         System.out.println();
         //使用For-Each输出，IDEA快捷键:数组名.for
         for (int num : nums) {
             System.out.print(num+" ");
         }
     }
 }

数组作方法入参

 public class Demo1 {
     public static void main(String[] args) {
         int[] nums= {2,4,6,7,8};
         printNums(nums);//数组当参数传递
     }
     static void printNums(int[] nums){
         for (int num : nums) {
             System.out.print(num+" ");
         }
     }
 }

数组作返回值

 public class Demo1 {
     public static void main(String[] args) {
         int[] nums= {2,4,6,7,8};
         int[] reverse=reverse(nums);
         for (int i : reverse) {
             System.out.println(i);
         }
     }
     //数组作返回值
     static int[] reverse(int[] nums){
         int[] result=new int[nums.length];
         for (int i = 0,j=result.length-1; i < result.length; i++,j--) {
             result[i]=nums[j];
         }
         return (result);
     }
 }

二维数组

• 二维数组创建

   int array[][]=new int[2][5];//两行五列的数组
   int[][] array=new int[2][5];
   int[][] array={{1,2},{2,3},{3,4}}//三行两列

   public class Demo1 {
       public static void main(String[] args) {
           int[][] array={{1,2},{2,3},{3,4},{4,5}};
           for (int[] ints : array) {
               for (int anInt : ints) {
                   System.out.print(anInt);
               }
               System.out.println();
           }
       }
   }

Array类使用

• 数组的工具类为java.util.Arrays

• 具体使用方法可以查看JDK帮助文档

• Arrays类中的方法都是使用static修饰的静态方法，在使用时可以直接使用类名调用，不用使用对象调用

• 常用功能

  • 赋值：fill方法

  • 排序：sort方法

  • 比较：equals方法比较数组中元素是否相等

  • 查找：通过binarySearch方法对排序好的数组进行二分查找法操作

 import java.util.Arrays;
 public class Demo1 {
     public static void main(String[] args) {
         int[] array={12,3,5,34,123};
         System.out.println(Arrays.toString(array));//Array.toString输出数组
         //Array.sort()对数组进行排序，升序
         Arrays.sort(array);
         System.out.println(Arrays.toString(array));
         //Array.fill()对数组进行填充
         Arrays.fill(array,0);//用0填充数组
         System.out.println(Arrays.toString(array));
         Arrays.fill(array,2,4,3);//对数组第2-3号填充为3
         System.out.println(Arrays.toString(array));
 ​
     }
 }

冒泡排序法

• 冒泡排序法使用两层循环，外层冒泡轮数，里层依次比较

• 算法的时间复杂度O(n2)

import java.util.Arrays;
 public class Demo1 {
     public static void main(String[] args) {
         int[] array={12,34,45,2,16};
         int[] sort=sort(array);
         System.out.println(Arrays.toString(sort));
     }
     public static int[] sort(int[] array){
         int temp=0;
         //外层循环
         for(int i=0;i<array.length-1;i++){
             boolean flag=false;//状态变量，若排好序即跳出循环减少循环次数
             //内层循环
             for(int j=0;j<array.length-1-i;j++){
                 if(array[j+1]<array[j]){
                     temp=array[j];
                     array[j]=array[j+1];
                     array[j+1]=temp;
                     flag=true;
                 }
             }
             if (flag==false){
                 break;
             }
         }
         return array;
     }
 }

稀疏数组

• 当一个数组中大部分元素为0，或者为同一数值时，可以用稀疏数组来保存该数组

• 稀疏数组的处理方式为：

  • 记录数组一共有几行几列，有多少个不同值

  • 把具有不同值的元素的行、列和值记录在一个小规模矩阵中

  • 如

  

import java.util.Arrays;
 public class Demo1 {
     public static void main(String[] args) {
         //创建原数组
         int[][] array=new int[6][7];
         array[0][3]=22;
         array[0][6]=15;
         array[1][1]=11;
         array[1][5]=17;
         array[2][3]=-6;
         array[3][5]=39;
         array[4][0]=91;
         array[5][2]=28;
         //输出原数组
         int sum=0;
         System.out.println("原数组为：");
         for (int[] ints : array) {
             for (int anInt : ints) {
                 System.out.print(anInt+"\t");
                 if(anInt!=0){
                     sum+=1;
                 }
             }
             System.out.println();
         }
         System.out.println("有效值个数为："+sum);
         //数组稀疏化
         System.out.println("================");
         int[][] array1=new int[sum+1][3];
         array1[0][0]=6;
         array1[0][1]=7;
         array1[0][2]=sum;
         int count=0;
         for (int i = 0; i < array.length; i++) {
             for (int j = 0; j < array[i].length; j++) {
                 if(array[i][j]!=0){
                     count++;
                     array1[count][0]=i;
                     array1[count][1]=j;
                     array1[count][2]=array[i][j];
                 }
             }
         }
         //输出稀疏化数组
         System.out.println("稀疏数组为：");
         for (int[] ints : array1) {
             System.out.print(ints[0]+"\t"+ints[1]+"\t"+ints[2]+"\t");
             System.out.println();
         }
     }
 }