java数组+二位数组+冒泡排序

java数组

数组用于存储大量同一类型的数据
1、数组的定义
数据类型 数组名字[] = new 数据类型[长度];
2、数组是一个连续的内存模型，会吧一整块内存平均分配成N(长度)等分，为没一个等分的内存设置了一个下标， 下标从0开始，
数组名[下标] = 值；

//定义一个数组
        int ages[] = new int[80];
        //数组赋值
        ages[0] = 100;
        ages[1] = 25;

        //批量赋值
        for(int i=0; i<80; i++) {
            ages[i] = 39;

        }
        //取出数组的值
        System.out.println(ages[0]);
        System.out.println(ages[2]);
        System.out.println(ages[79]);

        //循环取值
        for(int j=0; j<80; j++) {
            System.out.println("ages["+j+"]=" + ages[j]);
        }

我们的数据类型是可以任意使用
//定一个数组，用于存储3个的名字
String mignzi[] = new String[3];
//定义一个数组，用于存储40个人的体重。
double tizhong[] = new double[40];
还包括以后我们自定义的数据类型，，，

上述的叫一维数组，对于数组，有N维数组，N维数组的定义是 以N-1维数组为元素的数组叫N维数组。
我们只研究二维数组，
二位数组的定义：
int arr[][] = new int[4][3];

int liudehua[][] = new int[5][4];
        for(int i=0; i
            for(int j=0; j
                liudehua[i][j] = i + j; 
            }
        }

        for(int i=0; i<5; i++) {
            for(int j=0; j<4; j++) {
                System.out.print(liudehua[i][j] + "\t");
            }
            System.out.println();
        }

由于我们在循环的时候， 下标一不小心就会出错，造成访问的时候越界，所以我们数组提供了防止越界的方式，通过代码获取数组的长度

        int liudehua[][] = new int[5][4];
        System.out.println(liudehua.length);  //5
        System.out.println(liudehua[0].length); //4

对于我们二位数组就是一个行列结果，比较好理解的，但是实用性不高，

一维数组数据排序：
冒泡排序：

int arr[] = {11,3,30,42,35,6};
        //3 6 11 30 35 42
        /**
        3 11
        3 11 30
        3 11 30 42
        3 11 30 35 42
        3 11 30 35 6 【42】

    for(int j=0; j<6; j++) {
            for(int i=0 ;ilength-1-j; i++) {  //i ==4
                if(arr[i] > arr[i+1]) {  //arr[5]
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }