java数组

数组的概念:是一种容器,可以同时存放多个数据值。

数组的特点:
  1. 数组是一种引用数据类型
  2. 数组当中的多个数据,类型必须统一
  3. 数组的长度在程序运行期间不可改变

数组的初始化:在内存当中创建一个数组,并且向其中赋予一些默认值。

 

java的内存划分:

 

两种常见的初始化方式:
  1. 动态初始化(指定长度)
  2. 静态初始化(指定内容)

动态初始化数组的格式:
     数据类型[] 数组名称 = new 数据类型[数组长度];

解析含义:
  左侧数据类型:也就是数组当中保存的数据,全都是统一的什么类型
  左侧的中括号:代表我是一个数组
  左侧数组名称:给数组取一个名字
  右侧的new:代表创建数组的动作
  右侧数据类型:必须和左边的数据类型保持一致
  右侧中括号的长度:也就是数组当中,到底可以保存多少个数据,是一个int数字

public class Demo01Array {

    public static void main(String[] args) {
        // 创建一个数组,里面可以存放300个int数据
        // 格式:数据类型[] 数组名称 = new 数据类型[数组长度];
        int[] arrayA = new int[300];

        // 创建一个数组,能存放10个double类型的数据
        double[] arrayB = new double[10];

        // 创建一个数组,能存放5个字符串
        String[] arrayC = new String[5];
    }

}
View Code

 

 

 

动态初始化(指定长度):在创建数组的时候,直接指定数组当中的数据元素个数。
静态初始化(指定内容):在创建数组的时候,不直接指定数据个数多少,而是直接将具体的数据内容进行指定。

静态初始化基本格式:
数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, ... };

注意事项:
虽然静态初始化没有直接告诉长度,但是根据大括号里面的元素具体内容,也可以自动推算出来长度。

public class Demo02Array {

    public static void main(String[] args) {
        // 直接创建一个数组,里面装的全都是int数字,具体为:5、15、25
        int[] arrayA = new int[] { 5, 15, 25, 40 };

        // 创建一个数组,用来装字符串:"Hello"、"World"、"Java"
        String[] arrayB = new String[] { "Hello", "World", "Java" };
    }

}
View Code

 

 

使用静态初始化数组的时候,格式还可以省略一下。

标准格式:
  数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, ... };

省略格式:
  数据类型[] 数组名称 = { 元素1, 元素2, ... };

注意事项:
  1. 静态初始化没有直接指定长度,但是仍然会自动推算得到长度。
  2. 静态初始化标准格式可以拆分成为两个步骤。
  3. 动态初始化也可以拆分成为两个步骤。
  4. 静态初始化一旦使用省略格式,就不能拆分成为两个步骤了。

使用建议:
  如果不确定数组当中的具体内容,用动态初始化;否则,已经确定了具体的内容,用静态初始化。

 

public class Demo03Array {

    public static void main(String[] args) {
        // 省略格式的静态初始化
        int[] arrayA = { 10, 20, 30 };

        // 静态初始化的标准格式,可以拆分成为两个步骤
        int[] arrayB;
        arrayB = new int[] { 11, 21, 31 };

        // 动态初始化也可以拆分成为两个步骤
        int[] arrayC;
        arrayC = new int[5];

        // 静态初始化的省略格式,不能拆分成为两个步骤。
//        int[] arrayD;
//        arrayD = { 10, 20, 30 };
    }

}
View Code

 

直接打印数组名称,得到的是数组对应的:内存地址哈希值。
二进制:01
十进制:0123456789
16进制:0123456789abcdef

访问数组元素的格式:数组名称[索引值]
索引值:就是一个int数字,代表数组当中元素的编号。
【注意】索引值从0开始,一直到“数组的长度-1”为止。

public class Demo04ArrayUse {

    public static void main(String[] args) {
        // 静态初始化的省略格式
        int[] array = { 10, 20, 30 };

        System.out.println(array); // [I@75412c2f

        // 直接打印数组当中的元素
        System.out.println(array[0]); // 10
        System.out.println(array[1]); // 20
        System.out.println(array[2]); // 30
        System.out.println("=============");

        // 也可以将数组当中的某一个单个元素,赋值交给变量
        int num = array[1];
        System.out.println(num); // 20
    }

}
View Code

 

使用动态初始化数组的时候,其中的元素将会自动拥有一个默认值。规则如下:
  如果是整数类型,那么默认为0;
  如果是浮点类型,那么默认为0.0;
  如果是字符类型,那么默认为'\u0000';
  如果是布尔类型,那么默认为false;
  如果是引用类型,那么默认为null。

注意事项:
静态初始化其实也有默认值的过程,只不过系统自动马上将默认值替换成为了大括号当中的具体数值。

public class Demo05ArrayUse {

    public static void main(String[] args) {
        // 动态初始化一个数组
        int[] array = new int[3];

        System.out.println(array); // 内存地址值
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 0
        System.out.println(array[2]); // 0
        System.out.println("=================");

        // 将数据123赋值交给数组array当中的1号元素
        array[1] = 123;
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 123
        System.out.println(array[2]); // 0
    }

}
View Code

 

如何获取数组的长度,格式:
数组名称.length

这将会得到一个int数字,代表数组的长度。

数组一旦创建,程序运行期间,长度不可改变。

 

public class Demo03ArrayLength {

    public static void main(String[] args) {
        int[] arrayA = new int[3];

        int[] arrayB = {10, 20, 30, 3, 5, 4, 6, 7, 8, 8, 65, 4, 44, 6, 10, 3, 5, 4, 6, 7, 8, 8, 65, 4};
        int len = arrayB.length;
        System.out.println("arrayB数组的长度是:" + len);
        System.out.println("=============");

        int[] arrayC = new int[3];
        System.out.println(arrayC.length); // 3
        arrayC = new int[5];
        System.out.println(arrayC.length); // 5
    }

}
View Code

 

 

寻找数组中的最大值:

public class Demo05ArrayMax {

    public static void main(String[] args) {
        int[] array = { 5, 15, 30, 20, 10000, 30, 35 };

        int max = array[0]; // 比武擂台
        for (int i = 1; i < array.length; i++) {
            // 如果当前元素,比max更大,则换人
            if (array[i] > max) {
                max = array[i];
            }
        }
        // 谁最后最厉害,就能在max当中留下谁的战斗力
        System.out.println("最大值:" + max);
    }

}
View Code

 

寻找数组中的最小值:

public class Demo06ArrayMin {

    public static void main(String[] args) {
        int[] array = { 5, 15, 30, 20, 10000, -20, 30, 35 };

        int min = array[0]; // 比武擂台
        for (int i = 1; i < array.length; i++) {
            // 如果当前元素,比min更小,则换人
            if (array[i] < min) {
                min = array[i];
            }
        }
        System.out.println("最小值:" + min);
    }

}
View Code

 

将数组倒置:

public class Demo07ArrayReverse {

    public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50 };

        // 遍历打印数组本来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("============");

        /*
        初始化语句:int min = 0, max = array.length - 1
        条件判断:min < max
        步进表达式:min++, max--
        循环体:用第三个变量倒手
         */
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }

        // 再次打印遍历输出数组后来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}
View Code

 

posted @ 2021-01-14 00:06  薄眠抛却陈年事。  阅读(83)  评论(0编辑  收藏  举报