JAVA数组（1）

1.1.1 数组基础

数组（Array）是相同数据类型的数据的有序集合。

数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个数组元素（item），每个数组元素可以通过一个下标/索引（index）来访问它们。

数组是引用数据类型。

数组的三个特点

【1】数组的长度是确定的。数组一旦申请完空间，长度不能发生变化，用length属性访问。

【2】数组的元素都是同一数据类型的。

【3】数组是有序的。每个元素通过下标/索引从0开始。

1.1.2 内存空间分类（c）

内存分为两类

栈（stack）内存：基本数据类型分配在栈内存，栈内存空间不需要开发者回收，系统会自动回收。栈内存占空间整个内存空间的比例较小。

堆（heap）内存：引用数据类型分配在堆内存，堆内存一定要开发者通过new来申请，开发者申请的内存使用完成后一定要回收。jvm中有专门的垃圾回收机制（gc）回收使用完的堆内存。堆内存占整个内存空间的比例较大。

1.2 数组的声明声明数组有两种方式

（1）数据类型 [ ] 变量 //推荐写法

（2）数据类型变量 [ ]

案例：声明一个数组申请空间并赋值

public class New01{
   public static void main(String[] args){
       //声明一个数组
       int a;
       //声明数组变量
       int[] arr;
       //给数组变量分配空间
       arr = new int[5];
       //给每个空间赋值
       arr[0] = 10;
       arr[1] = 20;
       arr[2] = 30;
       arr[3] = 40;
       arr[4] = 50;
       //访问元素
       System.out.println(arr[0]);
       System.out.println(arr[1]);
       System.out.println(arr[2]);
       System.out.println(arr[3]);

   }
}

1.2.1 数组的内存空间

1.2.2 数组声明的其他方式

标准的声明和赋值方法过于复杂，可以使用简写的方式如下

数据类型 [ ] arr = new int [ ] {值1,值2,......};

jvm 根据后面值得个数申请空间并把值赋值到对于空间。案例如下

public class New02{
   public static void main(String[] args){
       //[1]数组的声明方式
       //int[] arr = new int[5];
       //arr[0] = 10;
       //arr[1] = 20;
       //System.out.println(arr);
       //[2]值声明
       int[] arr2;
       arr2 = new int[]{10,20,30,40,50};
       //int[] arr2 = new int[]{10,20,30,40,50};
       System.out.println(arr2.length);
       System.out.println(arr2[2]);
       //[3]数组的字面量声明
       //字面量声明不支持分开赋值
       /*
       int[] arr3;
       arr3 = {10,20,30,40,50};
       */
       int[] arr3 = {10,20,30,40,50};
       System.out.println(arr3.length);
       System.out.println(arr3[4]);



   }
}

1.2.3 数组的遍历

public class New03{
   public static void main(String[] args){
       int[] arr = {10,20,30,40,50};
       for(int i=0;i<arr.length;i++){
           System.out.println("arr["+i+"]"+"="+arr[i]);
           //数组的遍历写法
       }
   }
}

1.3 数组的常用算法

1.3.1 插入算法一个数组有序，添加一个元素后，数组依然有序。

public class New07{
   public static void main(String[] args){
       //一个有序的数组，向该数组中添加一个元素，数组依然有序。
       int[] arr = {1,3,7,9,12,20,0};
       int t = 0;
       //【1】找位置
       int loc = -1;//表示t应该添加到的位置。
       for(int i=0;i<arr.length;i++){
           if(arr[i] >= t){
               loc = i;
               break;
           }
       }
       System.out.println("loc = "+loc);

       if(loc < 0){//没找到合适的位置
           arr[arr.length-1] = t;
       }else{
           //【2】依次后移
           for(int j=arr.length-1;j>loc;j--){
               arr[j] = arr[j-1];
           }
           //【3】添加插入的值
           arr[loc] = t;
       }
       //验证
       for(int i=0;i<arr.length;i++){
           System.out.print(arr[i]+"\t");
       }
   }
}

1.3.2 删除算法

一个有序的数组，删除一个元素后依然有序。

public class New08{
   public static void main(String[] args){
       //删除算法
       int[] arr = {1,3,7,9,12,20};
       int t = 1;
       //【1】找位置
       int loc = -1;
       for(int i=0;i<arr.length;i++){
           if(t == arr[i]){
               loc = i;
               break;
           }
       }
       //【2】移动元素
       if(loc<0){
           System.out.println(t+"在数组中不存在");
       }else{
           for(int j=loc;j<arr.length-1;j++){
           arr[j] = arr[j+1];
           }
           arr[arr.length-1] = 0;
       }
       //验证
       for(int i=0;i<arr.length;i++){
           System.out.print(arr[i]+"\t");
       }
   }
}
1.3.3 冒泡排序算法

案例如下

public class New09{
   public static void main(String[] args){
       int[] arr = {9,4,2,452,242,345,1};
       int tmp = 0;
       for(int i=0;i<arr.length;i++){
           for(int j=0;j<arr.length-1;j++){
               if(arr[j]>arr[j+1]){
                   tmp = arr[j];
                   arr[j] = arr[j+1];
                   arr[j+1] = tmp;
               }
           }
       }
       for(int i=0;i<arr.length;i++){
           System.out.print(arr[i]+"\t");
       }
   }
}

猜你喜欢