数组

容器：是将多个数据存储到一起，每个数据成为该容器的元素。
数组：数组是存储长度固定的容器，保证多个数据的类型要一致。

数组的格式

1、数组存储的数据类型[] 数组名= new 数组存储的数据类型[长度]

String[] lang1=new String[8];

2、数组存储的数据类型[] 数组名= new 数组存储的数据类型[]{元素1，元素2，……}

int[] lang2=new int[]{1,2,3,4};

3、数组存储的数据类型[] 数组名= {元素1，元素2，……}

double[] lang2={1.2,2.6,3.9,};

数组的访问：

索引：每一个存储到数组的元素，都会有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
格式：数组名[索引编号]
数组长度：每个数组都有长度，而且是固定的，java中赋予了数组一个属性，可以获取到数组的长度.
语句为：数组名.length，属性length的执行结果是数组的长度，int类型的结果，
所以，数组索引编号为数组名.length-1
示例1：通过定义一个列表，将数组遍历的结果放进列表里，最后打印列表

package array;
import java.util.ArrayList;
import java.util.Arrays;
public class ArrayIndex {
    public static void main(String[] args) {
        System.out.println(array1());
        array2();
        System.out.println(array3());
    }
    public static ArrayList<Integer> array1() {
        int[] lang1 = new int[5];             //数组定义方式一
        lang1[0] = 2;
        lang1[1] = 3;
        lang1[2] = 4;
        lang1[3] = 5;
        lang1[4] = 6;
        ArrayList<Integer> list = new ArrayList<>();   //定义一个list列表
        for (int i = 0; i < lang1.length; i++) {
            list.add(lang1[i]);
        }
        return list;
    }
    public static void array2() {       //定义无返回值类型的方法，所以不用return
        double[] lang2 = {1.2, 2.3, 3.4, 4.5};       //数组定义方式二
        System.out.println(Arrays.toString(lang2));  //Arrays类中的toString方法。Arrays类位于java.util包下
    }
    public static ArrayList<String> array3() {
        String[] lang3 = new String[]{"wang", "xiao", "lang", "sha", "zi"};
        ArrayList<String> list = new ArrayList<>();//数组定义方式三
        for (int i = 0; i < lang3.length; i++) {       //通过for循环，遍历数组中的元素
            String b = lang3[i];
            list.add(b);
        }
        return list;
    }
}

输出结果：

示例2：将数组作为方法参数，直接定义数组并传值，调用方法

package array;
public class Array_1 {
    public static void main(String[] args){
        int[] array1={1,5,4,3,2};
        lang1(array1);
    }
    public static void lang1(int[] array1){    //将数组作为方法参数
        for (int i = 0; i <array1.length ; i++) {
            System.out.println(array1[i]);
        }
    }
}

数组内存图：

public class arrayindex1 {
    public static void main(String[] args) {
        int[] array1 = new int[4];
        System.out.println(array1);    //输出结果为[I@50cbc42f
    }
}

以上方法的输出是数组在内存中的地址，new出来的内容，都是在堆内存中存储的，而方法中array1保存的是数组的地址，只有输出array1[索引编号]。才会输出数组中对应的元素。

数组在内存中的存储：

程序的执行流程：
1、main方法进入方法栈执行
2、创建数组，JVM会在堆内存中开辟空间，存储数组
3、数组在内存中会有自己的内存地址，以十六进制数表示
4、数组中有4个元素，默认是0
5、JVM将数组的内存地址赋值给引用类型array1
6、变量array1保存的是数组内存中的地址，而不是一个具体的数值，因此是引用数据类型

数组的常见操作：

1、数组越界异常

public class ArrayIndex {
    public static void main(String[] args) {
       int[] langlang=new int[3]{1,2,3,4,5};
        System.out.println(langlang[6]);   //数组长度为3，但输出数组中第7个元素，所以抛出ArrayIndexOutOfBoundsException异常
    }
}

2、数据空指针异常

public class ArrayIndex {
    public static void main(String[] args) {
       int[] langlang=new int[]{1,2,3,4,5};
        langlang = null;
        System.out.println(langlang[2]);   //变量langlang不会再保存数组的内存地址，不允许再操作数组，抛出NullPointerException异常
    }
}

3、数组获取最大元素：

public class ArrayIndex {
    public static void main(String[] args) {
        int[] lang = {1, 3, 5, 6, 8, 2, 1, 5};
        int max = lang[0];
        for (int i = 0; i < lang.length; i++) {
            if (lang[i] > max) {
                max = lang[i];
            }
        }
        System.out.println(max);
    }
}

ArrayList类

定义
java.util.ArrayList是大小可变的数组的实现，存储在内的数据成为元素。此类提供一些方法和操作内部存储的元素。
ArrayList中可不断添加元素，其大小也自动增长。

java.util.ArrayList ：该类需要 import导入使后使用。
ArrayList：表示一种指定的数据类型，叫做泛型。在出现E的地方，使用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。

示例：

ArrayList<String>，ArrayList<Student>

ArrayList构造方法：

ArrayList<String> list = new ArrayList<String>();  //定义一个ArrayList构造方法

使用实例：

package array;
import java.util.ArrayList;
public class ArrayListStudents {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList();
        String student01="张三";
        String student02="李四";
        String student03="王五";
        list.add(student01);      //往list里添加定义好的数据
        list.add(student02);
        list.add(student03);
        System.out.println(list);
    }
}

ArrayList 常用方法和遍历

示例：

package array;
import java.util.ArrayList;
public class ArrayListStudents {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList();  //创建对象
        //往list里新增数据
        list.add("lang");
        list.add("yong");
        list.add("ling");
        //输出结果
        System.out.println(list);
        System.out.println("----------");
        //返回集合中元素的个数
        System.out.println("size:" + list.size());
        //list里删除数据
        System.out.println("remove:" + list.remove(0));
        //循环遍历输出
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

ArrayList如何存储基本数据类型

1、 ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似不能写
解决方法：基本数据类型转换为对应的包装类型。

转化为基本类型包装类示例（Integer）:

package array;
import java.util.ArrayList;
public class ArrayListStudents {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();  //创建对象,并将基本数据类型转换为基本类型的包装类
        //往list里新增数据
        list.add(1);
        list.add(2);
        list.add(3);
        //输出结果
        System.out.println(list);
        System.out.println("----------");
    }
}

练习： 生成6个1~99之间的随机整数,添加到集合,并遍历

package array;
import java.util.ArrayList;
import java.util.Random;
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> listtest = new ArrayList();
        Random random = new Random();   //生成一个随机数对象
        for (int i = 0; i < 6; i++) {
            int R = random.nextInt(99) + 1;   //随机生成1~99的数
            listtest.add(R);                         //将生成的随机数放进列表
    }
        for (int j = 0; j < listtest.size(); j++) {  //循环遍历输出
            System.out.println(listtest.get(j));
        }
    }
}

结果：