Java数组从定义到操作全解析_Java

数组概述

数组的定义

数组是相同数据类型数据的有序集合。
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
其中，每一个数据称作一个数组元素，每一个数组元素可以通过下标访问它们。

数组声明创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量(定义)的语法：

datatype[] arrayrefvar;     //首选的方法
或
datatype arrayrefvar[];     //效果相同，但不是首选方法

java语言使用new操作符来创建数组，语法如下：

datatype[] arrayrefvar = new datatype[arraysize];
//                          数组范围[0-arraysize)

数组的元素时通过索引访问的，数组索引从0开始。
获取数组长度：

arrays.length

计算所有元素的和：

public class demo01 {
    public static void main(string[] args) {
        //基本数据类型：变量的类型 变量的名称 = 变量的值
        //数组类型：变量类型[] 数组名 = new 变量类型[数组大小]
        int[] nums;     //1.声明一个数组
        nums = new int[3];     //2.创建一个数组
        //int[] nums = new int[10]; //1.2.等价于
        //3.给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        system.out.println(nums);    //数组的地址
        //计算所有元素的和
        int sum = 0;
        //获取数组长度：array.length
        for (int i = 0; i <nums.length ; i++) {
            sum = sum + nums[i];
        }
        system.out.println("数组和为："+sum);
    }
}

内存分析

数组三种初始化

静态初始化

int[] a = {1,2,3};//静态初始化：创建 + 赋值；基本类型
man[] mans = {new man(1,1), new man(2,2)};//引用类型

动态初始化（包含默认初始化）

int[] a = new int[2];//声明+初始化
a[0] = 1;   //赋值
a[1] = 2;   //赋值

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

public class demo02 {
    public static void main(string[] args) {
        //静态初始化：创建 + 赋值
        int[] a = {1,2,3,4,5,6,7,8,9};
        system.out.println(a[0]);
        system.out.println("------------------");
        //动态初始化：包含默认初始化
        int[] b = new int[10];
        b[0] = 10;  //对数组0号位置赋值
        b[1] = 10;  //对数组1号位置赋值
        //遍历数组b，除了0、1号位，其余位被默认初始化
        for (int i : b) {
            system.out.print(i+"\t");
        }
    }
}

数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
其元素必须是相同类型，不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组边界

下标的合法区间：[0,length-1]，如果越界就会报错

public static void main(string[] args){
    int[] a = new int[2];
    system.out.println(a[2]);
}

arrayindexoutofboundsexception 数组下标越界异常

一维数组的基础操作

public class demo03 {
    public static void main(string[] args) {
        int[] arrays = {1,2,3,4,5};
        //打印全部的数组元素
        for (int i = 0; i < arrays.length; i++) {
            system.out.println(arrays[i]);
        }
        system.out.println("----------------");
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];
        }
        system.out.println("数组的元素和为："+sum);
        system.out.println("----------------");
        //查找数组内元素的最大值
        int max = arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            if (arrays[i]>max){
                max = arrays[i];
            }
        }
        system.out.println("数组内元素的最大值为："+max);
    }
}

总结：

数组是相同数据类型（数据类型可以为任意类型）的有序集合
数组也是对象。数组元素相当于对象的成员变量
数组长度是确定的，不可变的。如果越界，会报错（arrayindexoutofboundsexception）

数组使用

java从jdk 5开始引入： for-each（增强型for循环）

for(元素类型 变量名 : 遍历对象) {
    // 循环体
}

数组做方法入参（传数组打印）
数组作返回值（反转数组）

public class demo04 {
    public static void main(string[] args) {
        //例题：将数组反转并输出
        int[] arrays = {1,2,3,4,5};
        //ava从jdk 5开始引入for-each，缺点：不能通过下标访问元素进行修改
//        for (int array : arrays) {
//            system.out.println(array);
//        }
//        printarray(arrays);
        int[] reverse = reverse(arrays);    //数组作返回值
        printarray(reverse);    //数组做方法入参
    }
    //打印数组元素
    public static void printarray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            system.out.print(arrays[i]+" ");
        }
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //反转操作
        for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

多维数组

多维数组可以看成是数组的数组，比如二维数据就是一个特殊的一维数组，其每一个数组元素又都是一个一维数组。
二维数组

int a[][] = new int[2][5];

解析：以上二维数组a可以看成一个两行五列的数组。

二维数组的基础操作

public class demo05 {
    public static void main(string[] args) {
        int[][] array = {{1,2,3},{4,5,6},{7,8,9},{10,11,12},{13,14,15}};
        //1.遍历二维数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                system.out.println(array[i][j]);
            }
        }
        system.out.println("-------------------");
        //2.取二维数组的所有元素和
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                sum += array[i][j];
            }
        }
        system.out.println("数组的所有元素和为："+sum);
        system.out.println("-------------------");
        //3.取二维数组中元素的最大值
        int result = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] > result){
                    result = array[i][j];
                }
            }
        }
        system.out.println("二维数组中元素的最大值为："+result);
        system.out.println("-------------------");
        //4.打印二维数组的第一行数据
        //方法一：
        system.out.println(array[0]);
        system.out.println(array[0][0]);
        system.out.println(array[0][1]);
        system.out.println(array[0][2]);
        system.out.println("-------------------");
        //方法二：
        printarray(array[0]);
    }
    public static void printarray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            system.out.print(arrays[i]+" ");
        }
    }
}

arrays类

数组的工具类java.util.arrays
由于数组对象本身并没有什么方法可以供我们调用，但api中提供了一个工具类arrays供我们使用，从而可以对数据对象进行一些基本的操作。
arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）
具有以下常用功能：
- 给数据赋值：通过fill方法。
- 对数组排序：通过sort方法，按升序。
- 比较数组：通过equals方法比较数组中元素值是否相等。
- 查找数组元素：通过binarysearch方法能对排序号的数据进行二分查找法操作。

import java.util.arrays;
public class demo06 {
    public static void main(string[] args) {
        int[] a = {45,132,864,16,4,6,889,456,2};
        system.out.println(a); //[i@1b6d3586
        //用arrays提供的方法（tostring）打印数组的元素
        system.out.println(arrays.tostring(a));
        //通过自己创建的方法（printarray）来打印数组的元素
        printarray(a);
        //-----------------------------------
        system.out.println();
        //用arrays提供的方法对数组进行排序后输出
        arrays.sort(a); //对数组进行排序:默认升序
        system.out.println(arrays.tostring(a));
        //-----------------------------------
        //用arrays提供的方法对数组进行填充
        arrays.fill(a,0);   //数组填充
        system.out.println(arrays.tostring(a));
        arrays.fill(a,2,4,1);//对数组中的[2,4)位进行填充
        system.out.println(arrays.tostring(a));
    }
    public static void printarray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if (i==0){
                system.out.print("[");
            }
            if (i==a.length-1){
                system.out.print(a[i]+"]");
            }else {
                system.out.print(a[i]+", ");
            }
        }
    }
}

例题：冒泡排序

八大排序：直接插入排序、希尔排序、简单选择排序、堆排序、冒泡排序、快速排序、归并排序、基数排序；冒泡排序是最出名的排序算法之一；
俩层循环，外层冒泡轮数，里层依次进行俩数之间的比较
冒泡排序算法时间复杂度是o(n^2)

import java.util.arrays;
public class demo07 {
    public static void main(string[] args) {
        /*
            冒泡排序：思路
            1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
            2.每一次比较，都会产生出一个最大或者最小的数字
            3.下一轮则可以少一次排序(array.length-1-i)
            4.依次循环，直到结束！
        */
        int[] a = {2,6,13,57,87,64,135,6,5};
        int[] sort = sort(a);
        system.out.println(arrays.tostring(sort));
    }
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;
        //外层循环，判断数组需要进行多少次
        for (int i = 0; i < array.length-1; i++) {
            //内层循环，依次比较相邻的两个数，如果第一个数比第二个数大，则交换位置(每一轮确定一个最大值)
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j]>array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
}

优化冒泡排序

import java.util.arrays;
public class demo08 {
    public static void main(string[] args) {
        //demo07冒泡排序优化
        /*
            冒泡排序
            1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
            2.每一次比较，都会产生出一个最大或者最小的数字
            3.下一轮则可以少一次排序(array.length-1-i)
            4.依次循环，直到结束！
        */
        int[] a = {2,6,13,57,87,64,135,6,5};
        int[] sort = sort(a);
        system.out.println(arrays.tostring(sort));
    }
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;
        //外层循环，判断数组需要进行多少次
        for (int i = 0; i < array.length-1; i++) {
            boolean flag = false;//通过flag标志位减少没有意义的比较
            //内层循环，依次比较相邻的两个数，如果第一个数比第二个数大，则交换位置(每一轮确定一个最大值)
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j]>array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;    //进行了换位flag则变成true
                }
            }
            //没有进入内循环判断，说明该序列已经是有序的了，则可以跳出循环
            if (flag==false){
                break;
            }
        }
        return array;
    }
}

到此这篇关于java数组详解：从定义到操作全解析的文章就介绍到这了,更多相关java数组定义内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！