数组(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”

本实例每次运行时结果都不相同，这就实现了随机产生数据的功能。该程序的运行结果如下：
生成的[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)); 
    }
}