JavaSE数组

JavaSE数组

一、数组概念

1. 在Java内存中开辟一片连续空间，存储多个类型相同数据的容器。
1. 数组一当定义好，长度固定不可以改变；

二、数组的定义及初始化

1. 定义数组：

   1. 数据类型 [] 数组名;//推荐使用
   

   2. 数据类型 数组名[];
   

   int[] array;
   int array1[];
   

   1. 数据类型：基本数据类型和引用类型；
   2. 数组名：符合标识符规则；所创建的数组名数据类型为引用数据类型（用于存储数组元素在内存中的地址）
   3. []：表示数组的符号；
   

2. 初始化：给定义的数组在内存中开辟空间，给每个空间赋初始值；

   1. 数组只有初始化后才可以使用

   2. 数组初始化方式：

      1. 动态初始化：定义的数组的同时使用new关键字创建一个数据类型并赋予长度

         //数据类型 [] 数组名=new 数据类型[长度];
          int[] array=new int[10];
         

      2. 静态初始化：定义的数组的同时使用new关键字创建一个数据类型在后面使用{}赋值；（值写下花括号内，用逗号隔开）

         //数据类型 [] 数组名=new 数据类型[]{元素1,元素2，....,元素n};
          int[] array=new int[]{1,10,2,20,50,40,30,15,18};
         

         //简化写法    通常使用
         数据类型 [] 数组名={元素1,元素2，....,元素n};
          int[] array={1,10,2,20,50,40,30,15,18};
         

         /*练习*/
         public static void main(String[] args) {
             /**
             *定义数组动态初始化
              */
             int[] array=new int[3];//定义一个数组Array，动态初始化；
             /* 循环便利数组输出值*/
             for (int i=0;i<array.length;i++){
                 System.out.print(array[i]);
             }
             System.out.println();
             /**
              * 定义数组静态初始化
              */
             System.out.println("________________分隔符___________________");
             int[] array1=new int[]{1,2,3,4,5,6};
             /*循环便利数组输出值*/
             for (int j=0;j<array1.length;j++){
                 System.out.print(array1[j]);
             }
         
         }
         

   3. 数组赋值：

      1. 数组元素值得操作；

         1. 数组元素值得获取：数组名 [索引值]

            System.out.print(array[0]);//打印索引为0的元素值
            

            //循环遍历数组元素中的值
            for (int i=0;i<array.length;i++){
                 System.out.print(array[i]);
             }
            

         2. 对元素值进行修改（显式赋值）：

            数组名 [下标]=值；
               array[0]=15;//将数组array[0]中的元素修改为5
            

      2. 数组对象以元素在内存中的分布：

         [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CwhFwbF9-1664441458705)(F:\学习资料\Java全栈\JavaSE\图\堆栈解释.png)]

         1. 创建的对象Array存放在栈中。

         2. 声明的数据及空间大小存放在堆中。

3. 数组的使用

   1. 一个对象可以被多个引用变量所引用
   2. ArrayIndexOutOfBoundsException（数组越界异常）：数组中元素超出定义的个数；
   3. NullPointerException（空指针异常）：应用变量没有指向任何的堆内存中的对象；
   4. 不能同时对同一个数组进行动态和静态赋值；编译报错

三、数组的特征

1. 元素：数组容器中的每个数据称为元素；
2. 数组的length属性：数组容器的长度，也就是数组中元素的个数；可以通过数组名.length取到数组中的数组长度；
3. 索引（下标）：数组中的每个元素都有一个唯一的编号，编号从0开始，到数组元素长度减一结束；
4. 索引与元素是一一对应的关系
5. 数组中的元素是可以被操作的
6. 在堆内存中创建一个对象，默认初始化为0；

四、数组的应用

1. 数组的遍历：将数组打印输出到控制台

   public static void main(String[] args) {
           Scanner scan=new Scanner(System.in);
           /*数组的遍历：遍历数组接收数值并将数组的值打印输出到控制台*/
           int array[]=new int[5];
           for(int i=0;i<array.length;i++){
               System.out.println("请输入数值：");
               array[i]=scan.nextInt();
           }
           System.out.print("{");
           for (int j=0;j<array.length;j++){
               if(j !=array.length-1){
                   System.out.print(array[j]+",");
               }else{
                   System.out.print(array[j]);
               }
           }
           System.out.println("}");
       }
   

2. 数组的最值

3. 数组的逆序

4. 数组的查表法

5. 数组元素的自查

   package JavaSE;
   import java.util.Scanner;
   public class ArrayDemo2 {
       public static void main(String[] args) {
           Scanner scan=new Scanner(System.in);//创建扫描器
           Array shuzu=new Array();//声明Array类，创建shuzu
           System.out.print("请输入数组元素的个数：");//接收数组个数
           int a=scan.nextInt();
           int array[]=new int[a];//创建数组
           int t=0;
           if(t==0){
               System.out.println(shuzu.OutArray(array));//调用循环遍历接收数组
               System.out.println("===============================================");
               System.out.println("循环遍历后输出数组：");//调用循环遍历输出数组
               shuzu.PrintArray(array);
               System.out.println("===============================================");
               System.out.println("数组中最大值为："+shuzu.max(array));//调用循环遍历求最值方法
               System.out.println("===============================================");
               System.out.println("逆序输出数组：");//逆序输出数组
               shuzu.ni(array);
           }else{
               System.out.println("请重新输入！");
           }
   
   
   
   
       }
   }
   

   package JavaSE;
   import java.util.Scanner;
   public class Array {
       /*循环接收数组*/
       public int OutArray(int a[]){
           Scanner scan=new Scanner(System.in);//接收数值
           /*循环从键盘接收数值，赋值给数组元素*/
           if(a.length<1){
               return 1;
           }else{
               for(int i=0;i<a.length;i++){
                   System.out.print("请输入数值：");
                   a[i]=scan.nextInt();
               }
               return 0;
           }
   
       }
       /*数组遍历*/
       public void PrintArray(int[] a){
           System.out.print("{");
           for (int j=0;j<a.length;j++){
               if(j !=a.length-1){
                   System.out.print(a[j]+",");
               }else{
                   System.out.print(a[j]);
               }
           }
           System.out.println("}");
   
       }
   
       /*数组最值*/
       public int max(int a[]){
           int max=a[0];
           for(int i=0;i<a.length;i++){
               if(a[i]>max){
                   max=a[i];
               }
           }
           return max;
       }
       /*数组逆序输出*/
       public void ni(int[] a){
           for(int i=0;i<a.length/2;i++){
               int temp = a[i];
               a[i] = a[a.length-1-i];
               a[a.length-1-i] = temp;
           }
          this.PrintArray(a);//调用打印数组
   
       }
   }