数组的定义和使用

 

 

数组的基本概念

如果说现在要求你定义100个整型变量，那么如果按照之前的做法，可能现在定义的的结构如下：

int i1, i2, i3, ... i100;

但是这个时候如果按照此类方式定义就会非常麻烦，因为这些变量彼此之间没有任何的关联，也就是说如果现在突然再有一个要求，要求你输出这100个变量的内容，意味着你要编写System.out.println()语句100次。

其实所谓的数组指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型，那么既然是引用数据类型，这里面实际又会牵扯到内存分配，而数组的定义语法有如下两类。

数组动态初始化：
声明并开辟数组：
数据类型 [ ] 数组名称 = new 数据类型 [ 长度 ] ; 
数据类型 [ ] 数组名称 = new 数据类型 [ 长度 ] ；
分布进行数组空间开辟（实例化）
| Tables | Are |
| ------------- |:-------------?
| 声明数组： | 数组类型 数组名称[] = null; | | | 数组类型 [] 数组名称 =null; | | 开辟数组空间： | 数组名称 =new` 数组类型[长度]; |
那么当数组开辟空间之后，就可以采用如下的方式的操作：

数组的访问通过索引完成，即：“数组名称[索引]”，但是需要注意的是，数组的索引从0开始，所以索引的范围就是0 ~ 数组长度-1，例如开辟了3个空间的数组，所以可以使用的索引是：0,1,2，如果此时访问的时候超过了数组的索引范围，会产生java.lang.ArrayIndexOutOfBoundsException 异常信息；
当我们数组采用动态初始化开辟空间后，数组里面的每一个元素都是该数组对应数据类型的默认值；
数组本身是一个有序的集合操作，所以对于数组的内容操作往往会采用循环的模式完成，数组是一个有限的数据集合，所以应该使用 for 循环。
在 Java 中提供有一种动态取得数组长度的方式：数组名称.length；
范例： 定义一个int型数组

public class ArrayDemo {
    public static void main(String args[]) {
        int data[] = new int[3]; /*开辟了一个长度为3的数组*/
        data[0] = 10; // 第一个元素
        data[1] = 20; // 第二个元素
        data[2] = 30; // 第三个元素
        for(int x = 0; x < data.length; x++) {
            System.out.println(data[x]); //通过循环控制索引
        }
    }
}

数组本身除了声明并开辟空间之外还有另外一种开辟模式。

范例： 采用分步的模式开辟数组空间

public class ArrayDemo {
    public static void main(String args[]) {
        int data[] = null; 
        data = new int[3]; /*开辟了一个长度为3的数组*/
        data[0] = 10; // 第一个元素
        data[1] = 20; // 第二个元素
        data[2] = 30; // 第三个元素
        for(int x = 0; x < data.length; x++) {
            System.out.println(data[x]); //通过循环控制索引
        }
    }
}

但是千万要记住，数组属于引用数据类型，所以在数组使用之前一定要开辟控件（实例化），如果使用了没有开辟空间的数组，则一定会出现 NullPointerException 异常信息：

public class ArrayDemo {
    public static void main(String args[]) {
        int data[] = null; 
        System.out.println(data[x]);
    }
}

这一原则和之前讲解的对象是完全相同的。

数组在开发之中一定会使用，但是像上面的操作很少。在以后的实际开发之中，会更多的使用数组概念，而直接使用，99%情况下都只是做一个 for 循环输出。

数组的冒泡排序

 

冒泡排序(Bubble Sort)是常用的数组排序算法之一，它以简洁的思想与实现方法而备受青睐，也是广大学习者最先接触的一种排序算法。

冒泡排序的基本思想是:对比相邻的元素值，如果满足条件就交换元素值，把较小的元素值移动到数组前面，把大的元素值移动到数组后面(也就是交换两个元素的位置)，这样数组元素就像气泡一样从底部上升到顶部。冒泡排序的算法比较简单，排序的结果稳定，但时间效率不太高。Java中的冒泡排序在双层循环中实现，其中外层循环控制排序轮数，总循环次数为要排序数组的长度减 1。而内层循环主要用于对比相邻元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少。

注意：

    1 循环圈数越来越少
    2 每次循环比较次数越来越少
    3 每次比较都从索引0和索引1开始

例如

public class BubbleSort{
    public static void main(String[] args){
        int[] arr1={5,2,1,3,6};
        Sort(arr1);
        printArray(arr1);
    }
    public static void Sort (int [] arr){
        //外层循坏用来控制数组循环的圈数
        for(int i =0;i<=arr.length-1;i++){
            //内层循环用来完成元素值的比较，把大的元素放在后面
            for(int j = 0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){//如果前者大于后者，交换位置
                    int temp = arr[j];
                    arr[j] = arr [j+1];
                    arr[j+1] = temp;
                }else{//否则继续下一步比较
                    continue;
                }
                
            }
            
        }
    }
        //格式化打印数组
        public static void printArray(int[] arr){
        System.out.print("[");
        for (int i = 0;i<arr.length;i++){
            if(i==arr.length-1){
                System.out.println(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }
    }
    
}