Java数组

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

• 一维数组
• • 1.数组的基本概念及作用
  • 2.数组的创建
  • • 数组声明的两种方式
    • 数组创建的三种方式
    • 数组的长度
    • 注意事项
    • • 数组的输出方法
      • 各个数据类型的默认值
  • 3.数组的访问以及迭代
  • • 数组元素的访问
    • 数组的迭代
    • • 1.for循环
      • 2.增强for循环
  • 4.数组元素的两种排序方法
  • • 1.冒泡排序
    • 2.选择排序
• 二维数组
• • 1.定义
  • 2.声明
  • 3.创建
  • 4.迭代

数组是相同类型元素的集合

数组本身是引用数据类型,即对象.但是数组可以存储基本数据类型,也可以存储引用数据类型,数组中存放的数据类型,取决于声明数组时可以存储的数据类型.如:int []a;a数组就只能存储整型数据

1.数据类型 [] 数组名字;如: int [] a,b;

注:使用这种声明方式,a,b都是数组.

2.数据类型 数组名字 [];如: int a,b [];

注:这种声明方式,a是整型变量,b是数组

为了避免混淆,我们一般采用第一种声明方式

1.声明数组的同时,根据指定的长度分配内存,但数组中元素值都为默认的初始化值

如:int [] a = new int [10];//动态创建数组,没有给元素赋值,可以结合for循环给元素赋值,

import java.util.Arrays;

public class Class {
    public static void main (String[]args) {
            int  a [] = new int[10];
        for (int i = 0; i < 5; i++) {
            a[i] = i;
        }
        System.out.println(Arrays.toString(a));
    }
}

2.声明数组并且分配内存,同时使其初始化

如:int [] a = new int [] = {1,2,3,4,5};//静态创建数组,在创建的时候给每个元素赋值

3.与前一种方式相同,仅仅是语法相对简略

如:int a = {1,2,3,4,5};

int a = {1,2,3,4,5};

System.out.println(a.length);//输出a的长度

假如我们使用这种方式来输出数组

public class Class {
    public static void main(String[] args) {
        int a1[] = new int[5];
        System.out.println(a1);
    }
}

得到的结果是

很明显并不是我们想要的,其实直接输出的话,得到的一个地址,这个地址用十六进制表示

要达到我们想要的输出结果,也就是一串内容,应该这样去输出

import java.util.Arrays;

public class Class {
    public static void main(String[] args) {
        int a1[] = new int[5];
        System.out.println(Arrays.toString(a1));
    }
}

得到的结果是

这个结果才是我们想要的,这其中用到的是系统已经定义好的Array方法,我们直接拿来用即可.

import java.util.Arrays;

public class Class {
    public static void main (String[]args) {
        int  a1 [] = new int[5];
        char a2 [] = new char[5];
        float  a3 [] = new float[5];
        double  a4 [] = new double[5];
        boolean  a5 [] = new boolean [5];
        String  a6 [] = new String[5];
        System.out.println(Arrays.toString(a1));
        System.out.println(Arrays.toString(a2));
        System.out.println(Arrays.toString(a3));
        System.out.println(Arrays.toString(a4));
        System.out.println(Arrays.toString(a5));
        System.out.println(Arrays.toString(a6));
    }
}

由此可见:

int 默认0 char 默认空格 float/double默认0.0

String 默认null boolean默认false

首先我们看看数组在内存中的存储

上文说到,直接使用System.out.println(a);输出数组得到的是一个地址,这个地址其实就是a[0]也就是数组的首地址

数组的存储空间在内存中是连续的,而且空间数量一旦确定就不能更更改.数组的长度也是有限的,理论上是int类型的最大值,但实际上我们用不了那么大,而且如果内存中没有那么大的连续空间,也无法创建这个数组.

那我们数组元素访问方法:数组名[索引];如a[2];

数组的索引是从0开始的,而且索引的数据类型是整型.索引的最大长度和数组长度始终相差1(因为索引从0开始)

int []a = {1,2,3,4};
for(int i = 0;i

int [] a = {1,2,3,4};
for(int t:a){
    System.out.printlf(t);
}

import java.util.Arrays;

public class Class {
    public static void main(String[] args) {
        int[] a = {5, 6, 9, 4, 8, 7};
        for (int i = 0; i < a.length - 1; i++) {//i循环控制趟数
            for (int j = 0; j < a.length - 1 - i; j++) {//j循环控制比较次数
                if (a[j] > a[j + 1]) {
                    int t = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = t;//不符合的"沉底"
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

import java.util.Arrays;

public class Class {
    public static void main(String[] args) {
        int[] a = {5, 6, 9, 4, 8, 7};
        for (int i = 0; i < a.length - 1; i++) {//i确定第一个数是哪个数
            for (int j = i+1; j < a.length; j++) {//j控制比较次数
                if (a[i] > a[j]) {
                    int t = a[j];
                    a[j] = a[i];
                    a[i] = t;//符合要求交换
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

import java.util.Arrays;

public class Class {
    public static void main(String[] args) {
        int [] [] a = {{1,2,3},{1,2,3},{1,2,3}};
        for(int i = 0;i<a.length;i++){
            System.out.println(Arrays.toString(a[i]));
        }
    }
}

public class Class {
    public static void main(String[] args) {
        int [] [] a = {{1,2,3},{1,2,3},{1,2,3}};
        for(int i = 0;i<a.length;i++){
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j]);
            }
            System.out.println();
        }
    }
}