数组(array)：是一种用于存储多个相同数据类型的存储模型(可以理解为容器)

数组定义和静态初始化

数组的两种定义格式：

格式1：

数据类型[] 变量名;

范例： int[] arr; // 定义了一个int类型的数组，数组名是arr

格式2：

数据类型变量名[];

范例： int arr[]; 定义了一个int类型的变量，变量名是arr数组

public class Test {
public static void main(String args[ ]) {
    int[ ] s; // 声明数组；
    s = new int[10]; // 动态初始化。给数组分配空间；
    for (int i = 0; i < 10; i++) {  // 遍历数组
        s[i] = 2 * i + 1;//给数组元素赋值； 数组是对象，数组中的元素就是对象的属性
        System.out.println(s[i]);
        } 
    }
}

静态初始化

初始化时指定每个数组元素的初始值，由系统决定数组长度

格式：

数据类型[] 变量名 = new 数据类型[]{数据1,数据2,数据3,…};

范例：int[] arr = new int[]{1,2,3};

　　简化格式：

数据类型[] 变量名 = {数据1,数据2,数据3,…};

范例：int[] arr = {1,2,3};

动态初始化

　　动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

　　格式：

　　　　数据类型[ ] 变量名 = new 数据类型 [数组长度]; // new：开辟数组内存空间

　　范例：

　　　　int[] arr = new int[3]; 表示我们定义了一个int类型的数组，初始化为3个元素。

静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景
动态初始化：指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景
注意：两种初始化的方式是独立的，不可以混用

　　数组使用中的两个小问题

　　　　1：索引越界：访问了数组中不存在的索引对应的元素，造成索引越界问题

　　　　　　　　　　　　ArrayIndexOutOfBoundsException

　　　　2：空指针异常：对象不再指向堆内存，还想继续访问数据，访问失败

　　　　　　　　　　　　NullPointerException

　　　　3：null：空值，引用数据类型的默认值，表示不指向任何有效对象

数组的遍历

　　　　　　　　　数组特征：

　　　　　　①：索引从0开始

　　　　　　②：索引是连续的

　　　　　　③：索引逐一增加，每次加1

数组元素下标的合法区间：[0, length-1]。我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。

使用循环初始化和遍历数

public class Test {
    public static void main(String[ ] args) {
        int[ ] a = new int[4]; // 动态初始化
//初始化数组元素的值
        for(int i=0;i<a.length;i++){
            a[i] = 100*i;
        }
//读取元素的值
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
}

for-each 循环

for-each 专门用于读取数组或容器中所有的元素。

public class Test {
    public static void main(String[ ] args) {
        String[ ] ss = { \"aa\", \"bbb\", \"ccc\", \"ddd\" }; // 【静态初始化】定义一个字符串数组
        for (String temp : ss) {
            System.out.println(temp);
        }
    }
}

for-each 增强 for 循环在遍历数组过程中不能修改数组中某元素的值。
for-each 仅适用于遍历，不涉及有关索引（下标）的操作。

数组常见操作之获取最大值

public class ArrayTest {
    public static void main(String[] args) {
//定义数组
        int[] arr = {12, 45, 98, 73, 60};
//定义变量max存储最大值，取第一个数据为变量的初始值
        int max = arr[0];
//将这个max初始值与数组中剩余数据逐个比对，每次比对将最大值覆盖到变量max中
        for (int i=1; i<arr.length; i++) {
            if(arr[i] > max) {
                max = arr[i];
            }
        }
//循环结束后输出变量max的值
        System.out.println(\"max:\" + max);
    }
}

数组常见操作之元素打乱

public class ArrayTesttwo {
    public static void main(String[] args) {
//定义数组
        int[] arr = {12, 45, 98, 73, 60}; // 静态初始化一个整型数组
        Random r = new Random();  // 生成随机数
        for (int i = 0; i < arr.length; i++) {
            int index = r.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
//遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

关于random类的一些方法

import java.util.Random;

public class Test06 {
    public static void main(String[] args) {
        Random r = new Random();
        double d1 = r.nextDouble(); // 生成[0,1.0]区间的小数
        double d2 = r.nextDouble() * 7; // 生成[0,7.0]区间的小数 
　　　　 // 如果是加“+”，则区间里面的数都要加“例如 * 7 改为 + 1，区间里面为99，--则最终区间范围为：1-100”

　　　　 double d2 = r.nextDouble() + 1;  // 则最终区间范围为：1-100

        int i1 = r.nextInt(10); // 生成[0,10]区间的整数
        int i2 = r.nextInt(18) - 3; // 生成[-3,15)区间的整数
        long l1 = r.nextLong(); // 生成一个随机长整型值
        boolean b1 = r.nextBoolean(); // 生成一个随机布尔型值
        float f1 = r.nextFloat(); // 生成一个随机浮点型值
        System.out.println(\"生成的[0,1.0]区间的小数是：\" + d1);
        System.out.println(\"生成的[0,7.0]区间的小数是：\" + d2);
        System.out.println(\"生成的[0,10]区间的整数是：\" + i1);
        System.out.println(\"生成的[-3,15]区间的整数是：\" + i2);
        System.out.println(\"生成一个随机长整型值：\" + l1);
        System.out.println(\"生成一个随机布尔型值：\" + b1);
        System.out.println(\"生成一个随机浮点型值：\" + f1);
        System.out.print(\"下期七星彩开奖号码预测：\");
        for (int i = 1; i < 8; i++) {
            int num = r.nextInt(9); // 生成[0,9]区间的整数
            System.out.print(num);
        }
    }
}

本实例每次运行时结果都不相同，这就实现了随机产生数据的功能。该程序的运行结果如下：
生成的[0,1.0]区间的小数是：0.8773165855918825
生成的[0,7.0]区间的小数是：6.407083074782282
生成的[0,10]区间的整数是：5
生成的[-3,15]区间的整数是：4
生成一个随机长整型值：-8462847591661221914
生成一个随机布尔型值：false
生成一个随机浮点型值：0.6397003
下期七星彩开奖号码预测：0227168

数组的拷贝

　　System.arraycopy（object src，int srcpos，object dest， int destpos，int length）

　　该方法可以将 src 数组里的元素值赋给 dest 数组的元素，其中 srcpos 指定从 src 数组的第几个元素开始赋值，

　　length 参数指定将 src 数组的多少个元素赋给 dest 数组的元素

public class Test {
    public static void main(String args[ ]) {
　　　　　// 一个静态初始化数组，一个赋有值，一个动态初始化数组，只分配数组内存空间
        String[ ] s = {\"阿里\",\"字节\",\"京东\",\"搜狐\",\"网易\"};
        String[ ] sBak = new String[6];
        System.arraycopy(s,0,sBak,0,s.length);
        for (int i = 0; i < sBak.length; i++) {
            System.out.print(sBak[i]+ \"\\t\");
        }
    }
}

java.util.Arrays 类

Arrays 类包含了：排序、查找、填充、打印内容等常见的数组操作。

import java.util.Arrays;
public class Test {
    public static void main(String args[ ]) {
        int[ ] a = { 1, 2 }; // 静态初始化一个2个元素的int型
        System.out.println(a); // 打印数组引用的值；
        System.out.println(Arrays.toString(a)); // 打印数组元素的值；
    }
}

直接打印a，出来的是其地址；Arrays.toString(a)直接遍历打印出数组的元素

此处的 Arrays.toString()方法是 Arrays 类的静态方法，不是前面讲的 Object 的 toString() 方法。

使用 Arrays 类对数组元素进行排序

import java.util.Arrays;

class Test {
    public static void main(String args[]) {
        int[] a = {1, 2, 323, 23, 543, 12, 59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a); // sort(); 排序方法 将指定数组按升序排序。
        System.out.println(Arrays.toString(a));
    }
}

使用 Arrays 类对数组进行填充

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] a = {1, 2, 323, 23, 543, 12, 59};
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 2, 4, 100); //把数组a中的2到4索引的元素替换为100;     
        System.out.println(Arrays.toString(a)); 
    }
}

来源：https://www.cnblogs.com/e-link/p/16645068.html
本站部分图文来源于网络，如有侵权请联系删除。

java中的一维数组