概要

  • 数组是一种引用数据类型
  • 数组是一组数据的集合,是一种容器
  • 数组中的元素类型可以是基本类型也可是引用数据类型,但同一个数组中只能有一种类型
  • 数组的长度在数组创建的时候就确定了,无法在创建后再次修改
  • 数组是由下标的,0表示第一个元素

    数组的创建

1.一维数组

  • 基本类型数组
  1. //动态初始化
  2. int[] intArr = new int[3]; //数组创建
  3. int[0]=1; //通过下标赋值
  4. //静态初始化
  5. int[] a = {1, 2, 3, 4};
  • 引用类型数组
  1. //动态初始化
  2. String[] stringArr = new String[3]; //数组创建
  3. stringArr[0] = new String(); //通过下标赋值
  4. //静态初始化
  5. String[] aa = {"a", "as", "asd"};

2.二维数组

当数组元素的类型是数组时就成了多维数组,二维数组的声明格式如下:

  1. 数组元素的数据类型[][] 变量名;
  2. 数组元素的数据类型 变量名[][];

数组的排序

1.冒泡排序

假设有5个数字3,1,6,2,5在一个int数组中,要求按从小到大排序输出
如何采用冒泡排序算法呢?冒泡排序的算法是这样的,首先从数组的最左边开始,
取出第0号位置(左边)的数据和第1号位置(右边)的数据,如果左边的数据大于右边的数据,
则进行交换,否而不进行交换。接下来右移一个位置,取出第1个位置的数据和第2个位置的数据,
进行比较,如果左边的数据大于右边的数据,则进行交换,否而不进行交换。沿着这个算法一直排序下去,
最大的数就会冒出水面,这就是冒泡排序。

  1. public class ArraySortTest01 {
  2. public static void main(String[] args) {
  3. int[] data = {3, 1, 6, 2, 5};
  4. for (int i = data.length - 1; i > 0; i--) {
  5. for (int j = 0; j < i; j++) {
  6. if (data[j] > data[j + 1]) {
  7. int temp = data[j];
  8. data[j] = data[j + 1];
  9. data[j + 1] = temp;
  10. }
  11. }
  12. }
  13. for (int aData : data) {
  14. System.out.println(aData);
  15. }
  16. }
  17. }

2.选择排序

选择排序对冒泡排序进行了改进,使交换次数减少,但比较次数仍然没有减少。
假设有5个数字3,1,6,2,5在一个int数组中,要求按从小到大排序输出
采用选择排序,选择排序是这样的,
先从左端开始,找到下标为0的元素,然后和后面的元素依次比较,如果找到了比下标0小的元素,
那么再使用此元素,再接着依次比较,直到比较完成所有的元素,最后把最小的和第0个位置交换。

  1. public class ArraySortTest02 {
  2. public static void main(String[] args) {
  3. int[] data = {3, 1, 6, 2, 5};
  4. for (int i = data.length - 1; i > 0; i--) {
  5. int max = 0;
  6. for (int j = 0; j < i; j++) {
  7. if (data[max] < data[j + 1]) {
  8. max = j + 1;
  9. }
  10. }
  11. if (max != i) {
  12. int temp = data[i];
  13. data[i] = data[max];
  14. data[max] = temp;
  15. }
  16. }
  17. for (int aData : data) {
  18. System.out.println(aData);
  19. }
  20. }
  21. }