JAVA学习笔记(五)- 数组

数组创建

数组

/*
 * 数组
 */
public class Test
{
    public static void main(String[] args)
    {
        int age;//声明
        age = 20;//赋值

//      int[] arrs;//声明了一个数组。array
//      int arrs2[];
//      float[] fs = new float[5];默认元素的值为0.0
//      char[] cs = new char[5];‘\u0000‘
//      String[] strs = new String[5];null

        //数组创建形式1
        //创建一个数组，且数组的长度为5.int[]表示数组元素为int类型数组。
        //此时，使用int类型的默认值，填充数组元素。
        int[] arrs1 = new int[5];

        //数组创建形式2
        //创建一个元素类型为int的数组，且长度为3
        //注意：此种形式不能指定数组长度
        int[] arrs2 = new int[]{1, 2, 3};

        //数组创建形式3
        //数组的静态创建形式。静态创建数组的形式不能先声明，再赋值
        //创建一个元素类型为int的数组对象，且数组长度为3
        int[] arrs3 = {3, 4, 5};

//      int[] arrs4;
//      arrs4 = {1, 2, 3};
        int[] arrs5;
        arrs5 = new int[5];
        int[] arrs6;
        arrs6 = new int[]{1, 2, 3, 4};
    }
}

数组的创建

/*
 * 数组的创建
 */
public class Test
{
    public static void main(String[] args)
    {
        //数组创建
        //特点：使用元素类型的默认值填充
        int[] arrs1 = new int[5];
        //特点：不指定数组的长度，数组的长度由{}中初始化的元素数决定
        int[] arrs2 = new int[]{1, 2, 3};
        //特点：静态创建数组，必须在声明的同时为其初始化。有｛｝中初始化的元素数决定数组长度
        int[] arrs3 = {1, 2, 3, 4, 5};

        //动态数组和静态数组
        //动态创建数组后，对于数组的名字可以重新赋值
        int[] arrs4;
        arrs4 = new int[5];

        //静态创建数组，则不能先声明，再创建
//      int[] arrs5;
//      arrs5 = {1, 2, 3};
//      arrs2 = {2, 3, 4};
        arrs3 = arrs1;

        String[] strs = new String[5];
    }
}

数组内存分析

数组的内存结构分析

/*
 * 基本数据类型和数组的内存结构分析
 *      Java中，数据的内存包含堆内存(heap)和栈内存(堆栈)(stack)
 */
public class Test
{
    public static void main(String[] args)
    {
        //如果为基本数据类型的变量，则直接在栈上分配内存，且值保存在栈中。
        int i = 10;
        i = 100;
        int j = i;

        //引用类型
        //引用数据类型，声明在栈上开辟内存空间，创建在堆上开辟一块内存空间，且真实值在堆上存储
        //通过=，将堆上开辟的内存空间，存放在声明的栈的内存中。
        int[] arrs = new int[5];
        //每次new的时候，都会在堆上重新分配内存空间
        arrs = new int[3];

        int[] arrs2 = arrs;

        arrs = new int[2];

        int[] arrs3 = null;

    }
}

操作数组

/*
 * 操作数组
 *  就是操作数组的元素，为元素赋值或者取得元素的值。
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = new int[5];

        //获得数组的长度
        System.out.println(arrs.length);

        //通过索引，为数组中的元素赋值
        arrs[0] = 10;
        arrs[1] = 10;
        arrs[2] = 10;
        arrs[3] = 10;
        arrs[4] = 10;

        //通过索引，遍历数组中的值
        for(int index = 0; index < arrs.length; index++)
        {
            System.out.println(arrs[index]);
        }

        //如果使用数组下标超过了其表示的范围，则在运行的时候，会报
        //java.lang.ArrayIndexOutOfBoundsException
        System.out.println(arrs[arrs.length]);
    }
}

使用循环，为数组赋值，并遍历数组元素的值

/*
 * 使用循环，为数组赋值，并遍历数组元素的值
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = new int[10];

        //使用循环，为数组赋值
        for(int i = 0; i < arrs.length; i++)
        {
            arrs[i] = i;
        }

        //使用循环，遍历数组
        for(int i = 0; i < arrs.length; i++)
        {
            System.out.println(arrs[i]);
        }
    }
}

实现数组的拷贝

/*
 * 实现数组的拷贝
 */
public class Test
{
    public static void main(String[] args)
    {
        //原数组
        int[] src = {1, 2, 3, 4, 5};

        //实现数组拷贝，必须有一个新数组
        int[] dest = new int[src.length];

        //将原数组中每个索引赋值给目标数组中对应的索引。
        for(int i = 0; i < src.length; i++)
        {
            dest[i] = src[i];
        }

        //遍历目标数组
        for(int i = 0; i < dest.length; i++)
        {
            System.out.println(dest[i]);
        }
    }
}

求数组中的最大值

/*
 * 求数组中的最大值
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = {9, 2, 4, 9, 7, 1, 6};

        //定义一个变量，默认该变量中存放的值为最大值
        int max = arrs[0];

        //表示最大值的索引
        int maxIndex = 0;

        //循环数组
        for(int index = 1; index < arrs.length; index++)
        {
            if(arrs[max] < arrs[index])
            {
                max = arrs[index];
                maxIndex = index;
            }
        }

        System.out.println(max);
        System.out.println(maxIndex);
    }
}

练习：

/*
 * 题目：
 * int[] arrs = {8, 7, 9, 3, 5, 6, 1, 2};查找数组中是否包含5这个元素，
 * 如果不包含，则程序结束。如果包含，则在第一次5所在位置的前面，插入一个值，该值为10。
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = {8, 7, 9, 3, 5, 6, 1, 2, 5};

        //1-先判断数组中是否存在5这个元素。如果不存在，则程序退出，如果存在，则返回第一次出现5的索引。

        //定义一个标识索引的变量，该变量如果为-1，则表示不包含5；如果不是-1，则包含5.
        int index = -1;

        //遍历数组，判断是否包含5，如果包含，则得到第一次出现5的索引
        for(int i = 0; i < arrs.length; i++)
        {
            //依次取得每个元素，判断是否等于5
            if(arrs[i] == 5)
            {
                //如果条件成立，则将5所在位置的索引赋值给index变量
                index = i;

                //因为取得的是第一次出现5的位置，所以，一旦出现5，则终止循环
                break;
            }
        }

        //2-通过index的值，判断是否包含5
        //此时如果index等于-1，表示数组中不包含5；否则，包含5.
        if(index != -1)
        {
            //此时，创建一个新数组，且该数组比arrs数组长度+1
            int[] newArrs = new int[arrs.length + 1];

            //将arrs数组中index索引位置前的元素，赋值给newArrs
            for(int i = 0; i < index; i++)
            {
                newArrs[i] = arrs[i];
            }

            //在5所在索引位置前，插入10.
            newArrs[index] = 10;

            //将arrs数组中index所在位置之后的元素，赋值给newArrs中index之后的元素
            for(int i = index; i < arrs.length; i++)
            {
                newArrs[i + 1] = arrs[i];
            }

            //将新数组赋值给原数组
            arrs = newArrs;
        }

        for(int i = 0; i < arrs.length; i++)
        {
            System.out.println(arrs[i]);
        }
    }
}

/*
 * 题目：
 * int[] arrs = {8, 7, 9, 3, 5, 6, 1, 2};查找数组中是否包含5这个元素，
 * 如果不包含，则程序结束。如果包含，将数组中5的位置修改成10
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = {8, 7, 9, 3, 5, 6, 1, 2, 5};

        //1-先判断数组中是否存在5这个元素。如果不存在，则程序退出，如果存在，则返回第一次出现5的索引。

        //定义一个标识索引的变量，该变量如果为-1，则表示不包含5；如果不是-1，则包含5.
        int index = -1;

        //遍历数组，判断是否包含5，如果包含，则得到第一次出现5的索引
        for(int i = 0; i < arrs.length; i++)
        {
            //依次取得每个元素，判断是否等于5
            if(arrs[i] == 5)
            {
                //如果条件成立，则将5所在位置的索引赋值给index变量
                index = i;

                //因为取得的是第一次出现5的位置，所以，一旦出现5，则终止循环
                break;
            }
        }

        //2-通过index的值，判断是否包含5
        //此时如果index等于-1，表示数组中不包含5；否则，包含5.
        if(index != -1)
        {
            arrs[index] = 10;
        }

        for(int i = 0; i < arrs.length; i++)
        {
            System.out.println(arrs[i]);
        }
    }
}

排序

冒泡排序

/*
 * 冒泡排序
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = {8, 7, 9, 3, 5, 6, 1, 2};
        int[] arrs2 = {8, 7, 9, 3, 5, 6, 1, 2};
        for(int i = 0; i < arrs.length - 1; i++)
        {
            for(int j = 0; j < arrs.length -1 - i; j++)
            {
                if(arrs[j] > arrs[j + 1])
                {
                    int temp = arrs[j];
                    arrs[j] = arrs[j + 1];
                    arrs[j + 1] = temp; 
                }
            }
        }

        Arrays.sort(arrs2);

        //foreach或增强for循环
        //JDK1.5之后。
        for(int i : arrs2)
        {
            System.out.print(i + "  ");
        }

    }
}

二维数组

二维数组的创建

/**
 *  二维数组
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs1 = {1, 2, 3, 4, 5};
        String[] arrs2 = {"aaa", "bbb", "ccc", "ddd"};

        //二维数组的创建：
        //1-表示arrs3对象是一个一维数组，且该一维数组的类型是int[],默认值为null;
        //arrs3.length值为3
        int[][] arrs3 = new int[3][];

        //2-表示arrs4是一个一维数组，且该数组元素的类型是int[],
        //3表示arrs4的长度，4表示arrs4中，每个元素(一维数组)的长度
        int[][] arrs4 = new int[3][4];

        //3-
        int[][] arrs5 = new int[][]{{1, 2}, {3}, {4, 5, 6, 7}};

        //4-
        int[][] arrs6 = {{1, 2}, {1, 1, 1, 1}, {1}, {2, 2}};

        System.out.println(arrs6.length);

        for(int[] arrs : arrs6)
        {
            System.out.println(arrs[0]);
        }
    }
}

public class Test
{
    public static void main(String[] args)
    {
        int[][] arrs = {{1, 1, 1}, {2, 2}, {3}, {4, 4, 4, 4, 4}};

        //该数组arrs的元素类型为int[]，所以，其长度为int[]的个数
        System.out.println("数组的长度" + arrs.length);

        System.out.println(arrs[1][0]);

        //遍历数组
        for(int i = 0; i < arrs.length; i++)
        {
            for(int j = 0; j < arrs[i].length; j++)
            {
                System.out.print(arrs[i][j] + "\t");
            }

            System.out.println();
        }
    }
}