数组

数组

1、数组是什么。

2、数组有什么用。

3、数组怎么用。

4、数组的排序。

 

 

1、数组是什么。

　　数组是java中最基本的一种数据类型。数组是储存同一类型的数据的集合。数组分为一维数组、二维数组、多维数组。

　　数据类型分为：

　　·　　 基本类型：int（整数）、byte（字节）、float（单浮点）、double（双浮点）、long（整数）、boolean（布尔）、short（整数）、char（单字符）。

　　　　　　int：int 数据类型是32位、有符号的以二进制补码表示的整数，取值范围为-2^31至2^31-1。

　　　　　　bate：byte存储整型数据，占据1个字节(8 bits)，能够存储的数据范围是-128～+127。

　　　　　　float：float 数据类型是单精度、32位、符合IEEE 754标准的浮点数。

　　　　　　double：double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数。

　　　　　　long：long 数据类型是 64 位、有符号的以二进制补码表示的整数，取值范围为-2^63至2^63-1。、

　　　　　　boolean：boolean是java中的布尔型（逻辑型）数据类型，在java中boolean值只能是true和false，而不能用0和1代替，并且一定要小写。布尔值 true 代表“真”，false 代表“假”。一般关系运算符会返回布尔值的结果。另外，数值的 0、-0、特殊值的 null、NaN、undefined 以及空字符（""）都会被解释为 false ，其他值则会被解释为 true 。

　　　　　　short：short 数据类型是 16 位、有符号的以二进制补码表示的整数，取值范围 -2^15至2^15-1。、

　　　　　　char：char占2字节，16位。可以存放字符 注：只能放单个字符 用单引号''标识，只能放单个字符。

　　　　  引用类型：类、接口、数组。

 

2、数组有什么用。

　　在执行程序的过程中，经常需要储存大量的数据，例如，假设需要读取计算100个学生的数学成绩。计算他们的平均分。然后找出有多少个数大于平均分。为了完成这个任务，必须将全部的数据储存到变量中。必须声明100个变量，并且重复的书写100次几乎相同的代码，这样的编程方式视乎不太现实，这时候就需要一个高效的有条理的方法，java中提供了一种称为数组的数据结构类型，可以用它储存一个元素个数固定且元素类型形同的有序集，在现在这个例子中，可以将所有的100个数，储存在一个数组中，并且通过一个一维变量访问它。

 

3、数组怎么用。

　　定义一个一维数组：　　　

        数据类型[] 数组名 = {值,...};
        数据类型[] 数组名 = new 数据类型[长度];
        数据类型[] 数组名 = new 数据类型[]{值,...};
        数据类型[] 数组名;
        数组名 = new 数据类型[长度];
        数组名 = new 数据类型[]{值,...};

　定义二维数组：

        数据类型[][] 数组名 = {{值,...},...};
        数据类型[][] 数组名 = new 数据类型[行][列];
        数据类型[][] 数组名 = new 数据类型[][]{{值,...},...};
        数据类型[][] 数组名;
        数组名 = new 数据类型[行][列];
        数组名 = new 数据类型[][]{{值,...},...};

　需要注意的是一旦数组被创建，它的长度是固定的。　二维数组可以看成是储存数组的数组。

　　数组的使用：

　　访问一维数组的元素：数组名[下标]　　下标范围：0~数组名.length-1；

　　获取一维数组中能储存的元素总数：数组名.length（lenth是从1开始计数的）；

　　获取二维数组有多少行：数组名.length；

　　获取二维数组有多少某一行有多少列：数组名[行下标].length

　　获取二维数组中能储存的元素总数：

 

        new 数据类型[][]{{值,...},...}：数组名[行下标].length+...
        new 数据类型[行][列]：数组名.length*数组名[行下标].length

 

　　获取或者设置二维数组的某个位置的值：数组名[行下标][列下标]。

 

4、数组的排序

　　数组常用的排序有冒泡、选择、插入。

　　创建一个数组排序的类 

　　　　定义创建数组、打印数组的方法

import java.util.Random;

public class array {

    // 生成一个乱序的，指定长度的原始数组的方法
    public static int[] createSrcarray(int len) {
        // 初始化要排序的数组中的值
        int[] base = new int[len];
        // 循环遍历数组 b 并给数组中的元素赋值 赋值为随机数
        for (int i = 0; i < base.length; i++) {
            Random ran = new Random();
            // 调用随机对象，每次循环的生成一个0~100间的随机数
            int value = ran.nextInt(100);
            // 给数组中的指定位置填上随机值：
            base[i] = value;
        }
        // 返回
        return base;
    }

    // 打印出数组中的元素的方法
    public static void printArray(int[] ia) {
        // 判断 如果要打印的数组为 null（空），则不打印
        if (null == ia) {
            // 停止调用
            return;
        }
        // 循环遍历 ia数组，并打印出来
        for (int i = 0; i < ia.length; i++) {
            // 输出 空格 + ia数组
            System.out.print("  " + ia[i]);
        }
        // 输出 字符串 空格
        System.out.println(" ");
    }
}

　　冒泡排序：

    // 冒泡排序的方法
    public static int[] maopao(int[] x) {
        for (int i = 0; i < x.length; i++) {
            // 循环遍历 x数组 的其余元素
            for (int j = i + 1; j < x.length; j++) {
                if (x[i] > x[j]) {
                    // 互换
                    int temp = x[i];
                    x[i] = x[j];
                    x[j] = temp;
                }
            }
        }
        // 返回
        return x;
    }

　　选择排序：

// 选择排序的方法
public static int[] xuanze(int[] x) {
    // 循环 遍历 x数组
    for (int i = 0; i < x.length; i++) {
        int lowerIndex = i;
         // 找出最小的一个索引
        for (int j = i + 1; j < x.length; j++) {
            // 若x[j]<x[i] 则抛出小循环 x[i] ，x [j] 互换。已经循环对比过的不再对比，没对比过的继续循环。
            if (x[j] < x[lowerIndex]) {
                lowerIndex = j;
           }
       }
       // 交换
       int temp = x[i];
       x[i] = x[lowerIndex];
       x[lowerIndex] = temp;
   }
　　// 返回
   return x;
}

　　插入排序：

// 插入排序的方法
public static int[] caru(int[] x) {
    // 循环遍历 x[i]数组长度-1次
    for (int i = 1; i < x.length; i++) {
        // 循环x[j] 数组
        for (int j = i; j > 0; j--) {
            // 判断 若前面一位大于后面一位则互换位置
            if (x[j] < x[j - 1]) {
                // 交换
                int temp = x[j];
                x[j] = x[j - 1];
                x[j - 1] = temp;
            }
        }
    }
    // 返回
    return x;
}

 定义一个主方法，然后测试一下三种排序。

    // 数组排序测试
    // 程序入口 ：测试冒泡，选择，插入，三种排序方式
    public static void main(String[] args) {
        // 冒泡排序
        // 取得要排序的原数组
        int[] srcA = createSrcarray(5);
        System.out.println("***冒泡排序前数组的值顺序：");
        printArray(srcA);
        System.out.println("----冒泡排序的结果");
        int[] tem = maopao(srcA);
        printArray(tem);
        // 选择排序
        // 取得要排序的原数组
        srcA = createSrcarray(6);
        System.out.println("***选择排序前的数组的值排序：  ");
        printArray(srcA);
        System.out.println("----选择排序的结果：");
        tem = xuanze(srcA);
        printArray(tem);
        // 插入排序
        // 取得要排序的原数组
        srcA = createSrcarray(7);
        // 输出
        System.out.println("***插入排序前的顺序：：");
        printArray(srcA);
        System.out.println("---插入排序的结果：");
        tem = caru(srcA);
        printArray(tem);
    }

　　运行一下：

***冒泡排序前数组的值顺序：
  79  2  76  52  3 
----冒泡排序的结果
  2  3  52  76  79 
***选择排序前的数组的值排序： ： 
  85  29  14  37  6  73 
----选择排序的结果：
  6  14  29  37  73  85 
***插入排序前的顺序：
  61  97  63  31  3  18  22 
---插入排序的结果：
  3  18  22  31  61  63  97