第二十一节（数组概要， 一维、二维数组的声明和使用，数组的排序，数组的查找，）...

一维数组：
1：/*
    数组：
    
        1. 数组是一种引用类型
        
        2. 数组是一种简单的数据结构，线性的机构
        
        3. 数组是一个容器，可以用来存储其他元素，
        
        4. 数组也是可以存储任意数据类型的元素
        
        5. 数组分为：
        
            一维数组，二维数组，三维数组，多维数组
            
        6. 数组中的存储的元素类型 是统一的
        
        7. 数组的长度是不可变的，数组一旦创建长度就是不可变的，固定的

        声明数组语法：
        
            <1>. 数组元素的类型[] 变量名称
            
            <2>. 数组元素的类型 变量名称[]

*/
public class ArrayTest01{

    public static void main(String[] args){
        
        // 声明一个一维数组，用来存储int类型
        int[] i = {1,2,3,4,5}; // 这种方式称之为“静态初始化的一维数组”
        
        // boolean 类型的数组
        boolean[] j = {true,false,true,false};
        
        // String类型数组
        String[] strs = {"中山学院","农业学院","我就是吃西葫芦"};
        
        // byte数组
        byte[] k = {1,2,3};
        
        // char数组
        char[] m = {'a','b','c'};
        
        // Object数组
        Object o1 = new Object();
        Object o2 = new Object();
        Object o3 = new Object();
        
        Object[] bojs = {o1,o2,o3};
        
        
    }
    
    
}


2：/*
    
     第一种：使用 new 操作符来创建数组

     格式为：new 数组元素的数据类型 [数组元素的个数]
     
     

*/
public class ArrayTest02{
    
    public static void main(String[] args){
        
        // 声明一个int类型的数组，长度为 5
        // 数组中的元素，必须为int类型
        int[] data = new int[5];
        
        // 给数组中的元素赋值，如果不赋值默认为 该类型的默认值 如果是int类型就为 0；
        
        // 赋值： 变量名[下标] 下标从0开始
        data[0] = 16;
        data[1] = 17;
        data[2] = 10;
        data[3] = 90;
        data[4] = 50;
        
        // 输出数组中的元素，变量名[下标]
        System.out.println(data[0]);
        System.out.println(data[1]);
        System.out.println(data[2]);
        System.out.println(data[3]);
        System.out.println(data[4]);
        
        System.out.println("--------------------------------------");
        
        System.out.println("数组的长度为："+data.length);
        
        for(int i = 0; i < data.length; i ++){
            System.out.println("下标为："+ i +" 的值：" + data[i]);    
        }
        
        // 输出数组中的指定的值
        System.out.println("data[2] = " + data[2]);
        
        // 报错：ArrayIndexOutOfBoundsException
        // 数组的下标越界
        System.out.println("data[6] = " + data[6]);
        
        // 不能赋值成功，数组中的类型必须是 一种类型
        data[1] = "aaaa";
        
    }

}


/*
    修正 空指针异常

*/
3：public class ArrayTest04{

    public static void main(String[] args){
        
        // 声明引用类型的数组
        Student[] student = new Student[2];
        
        // 方式一：
        
        // 初始化数组元素为 Student对象    
        student[0] = new Student();
        student[0].id = 100;
        student[0].name = "ming";
        
        student[1] = new Student();
        student[1].id = 200;
        student[1].name = "keke";        
        
        
        System.out.println("id[0] = "+student[0].id + "  name[0] = " + student[0].name);
        System.out.println("id[1] = "+student[1].id + "  name[1] = " + student[1].name);
            
            
        // 方式二：
        // 可以采用另外的方式来赋值
        
        Student arry = new Student();
        arry.id = 1111;
        arry.name = "ming";
        student[0] = arry;
            
        Student keke = new Student();
        keke.id = 2222;
        keke.name = "Keke";
        student[1] = keke;        
    
        System.out.println("----------------------------------------------");
    
        for(int i = 0; i < student.length; i ++){
            System.out.println("id = " + student[i].id + " name = " + student[i].name);
        }
    
    
    }


}

class Student{
    
    int id;
    
    String name;

}

二维数组：
1：/*
    二维数组特点：
    
        1. 二维数组 是一个特殊的一维数组
        2. 特殊的一维数组，特殊在这个一维数组中每一个元素都是“一维数组”
    
        

*/
public class ArrayTest01{
    
    public static void main(String[] args){
        
        // 声明一个二维数组
        int[][] m = new int[2][3];
        
        // 对二维数组赋值
        m[0][0] = 1;
        m[0][1] = 2;
        m[0][2] = 3;
        
        m[1][0] = 4;
        m[1][1] = 5;
        m[1][2] = 6;
        
        System.out.println(m[0].length);
        
        // 输出二维码
        // 纵向循环在外
        for(int i = 0; i < m.length; i++){
            // 对一维数组m[i]进行遍历
            for(int j = 0; j < m[i].length; j++){
                System.out.println(m[i][j]);    
            }
        }
        
        /*
            当 i = 0, i < 2 满足条件，
            j = 0, j < 3 满足条件 输出：m[0][0] 最终输出：1; j++
            j = 1, j < 3 满足条件 输出：m[0][1] 最终输出：2; j++
            j = 2, j < 3 满足条件 输出：m[0][2] 最终输出：3; j++
            j = 3, j < 3 不满足条件，跳出循环 break； i++
            
            当 i = 1, i < 2 满足条件，
            j = 0, j < 3 满足条件 输出：m[1][0] 最终输出：4; j++
            j = 1, j < 3 满足条件 输出：m[1][1] 最终输出：5; j++
            j = 2, j < 3 满足条件 输出：m[1][2] 最终输出：6; j++            
            j = 3, j < 3 不满足条件，跳出循环 break； i++
            
            当 i = 2, i < 2 不满足条件，跳出外层循环 break； 结束Over ！
            
        */
        
        
        
        
    }

}



2：
/*
    多维数组: 当数组元素的类型是数组时就成了多维数

*/
public class ArrayTest03{

    public static void main(String[] args){
        
        int[][] a = new int[][]{{1,2,3},{5,6,7},{7,8,9}};
        
        m(a);        
        
    }
    
    // 遍历
    public static void m(int[][] a){
        for(int i = 0; i < a.length; i++){
            for(int j = 0; j < a[i].length; j++){
                System.out.println(a[i][j]);
            }
            System.out.print("\n");
        }        
    }
    
}

/*
     冒泡排序算法：
     
         int 类型的数组 ： 3 1 6 2 5

*/
public class BubbleSort{

    public static void main(String[] args){
        
        int[] a = {3,1,6,2,5};
        
        //System.out.println("数组的长度："+a.length);
        
        m(a);
        
        /*
        // 开始排序
        for(int i = a.length-1; i > 0; i--){
            for(int j = 0; j < i; j++){
                if(a[j] > a[j+1]){
                    // 交换位置
                    int temp;
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }    
            }
        }
        // 遍历
        for(int i = 0; i < a.length; i++){
            System.out.println(a[i]);    
        }
        */
        
    }
    
    public static void m(int[] a){
        for(int i = a.length-1; i > 0; i--){
            for(int j = 0; j < i; j++){
                if(a[j] > a[j+1]){
                    // 交换位置
                    int temp;
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }    
            }
        }
        // 遍历
        for(int i = 0; i < a.length; i++){
            System.out.println(a[i]);    
        }
    }
    
    
}

 

转载于:https://www.cnblogs.com/Deng1185246160/p/4232279.html