首页 > > 程序设计 > Java技术 >

夯实Java基础（一）——数组

2019-08-16 10:38:12来源：博客园阅读 ()

夯实Java基础（一）——数组

1、Java数组介绍

数组(Array)：是多个相同类型元素按一定顺序排列的集合。

数组是编程中最常见的一种数据结构，可用于存储多个数据，每个数组元素存放一个数据，通常我们可以通过数组元素的索引来访问数组元素。包括为数组元素赋值和取出数组元素的值。

数组的基本特性：

①、数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。

②、创建数组对象会在内存中开辟一整块连续的空间，而数组的引用是这块连续空间的首地址。

③、数组一旦初始化完成，数组在内存所占用的空间将被固定下来，因此数组的长度不可变。

④、数组可以直接通过下标的方式来调用，下标从0开始。

2、数组的定义

①、静态初始化：初始化时显示指定每个元素的初始值，由系统决定数组长度

数据类型 [ ]  数组名称 = new 数据类型 [ ]{ 元素1，元素2，...}
或

数据类型 [ ]  数组名称 = { 元素1，元素2，...}

这种方式声明数组的同时直接给定了数组的元素，数组的大小由给定的数组元素个数决定。

②、动态初始化：初始化时候程序员只指定数组长度，由系统元素分配初始值。

数据类型 [ ]  数组名称 = new 数据类型 [数组长度]
或

数据类型  数组名称[ ] = new 数据类型 [数组长度]

这种方式推荐将 [ ] 放在数组名称的前面，这样比较直观。

注意：动态初始化，确定了数组长度，就算没有显式的赋值，那么他也有它们基本数据类型的默认值，如int默认值是0，String默认值为null。

③、简单示例：

//声明一个元素为1,2,3的int型数组
int[] arr=new int[]{1,2,3};
int[] arr1={1,2,3};
//声明一个长度为3的数组
int[] arr2=new int[3];

④、错误写法：

//未指定数组长度
int [] arr1=new int[];
//数组前面[]不能写长度
int [5] arr2=new int[5];
//静态初始化不能写长度
int [] arr3=new int[3]{1,2,3};

以上的写法都是错误的，在编译时会报错。

⑤、访问数组元素以及给数组元素赋值

数组是存在下标索引的，通过下标可以获取指定位置的元素，数组下标是从0开始的，也就是说下标0对应的就是数组中第1个元素，可以很方便的对数组中的元素进行存取操作。

//声明一个长度为3的数组
int[] arr=new int[3];
//给arr第1个元素赋值1
arr[0]=1;
//给arr第2个元素赋值2
arr[1]=2;
//输出
System.out.println(arr[0]);
System.out.println(arr[1]);

上面的arr数组，我们只能赋值三个元素，也就是下标从0到2，如果你访问 arr[3] ，那么会报数组下标越界异常。

⑥、数组遍历

数组有个 length 属性，是记录数组的长度的，我们可以利用length属性来遍历数组。

//声明一个元素为1,2,3的int型数组
int[] arr=new int[]{1,2,3};
//遍历arr数组
for (int i = 0; i < arr.length; i++) {
     System.out.println(arr[i]);
}
// 使用增强for循环foreach进行遍历
for (int i : arr) {
      System.out.println(i);
}
//使用Arrays.toSting(数组名)进行遍历
System.out.println(Arrays.toString(arr));

3、数组使用示例

①、将数组元素反转：

public class ArrayTest {
    public static void main(String[] args) {
        String[] str=new String[]{"AA","BB","CC","DD","EE","FF","GG"};
        System.out.println("反转前：");
        for (int i = 0; i < str.length; i++) {
            System.out.print(str[i]+"\t");
        }
        for(int i=0;i<str.length/2;i++){
            String temp=str[i];
            str[i]=str[str.length-i-1];
            str[str.length-i-1]=temp;
        }
        System.out.println();
        System.out.println("反转后：");
        for (int i = 0; i < str.length; i++) {
            System.out.print(str[i]+"\t");
        }
    }
}

②、线性查找：

public class ArrayTest1 {
    public static void main(String[] args) {
        String[] str=new String[]{"AA","BB","CC","DD","EE","FF","GG"};
        String dest="BB";
        boolean isFlag=true;
        for (int i = 0; i < str.length; i++) {
            if (dest.equals(str[i])){
                System.out.println("找到了元素，位置在"+(i+1));
                isFlag=false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("对不起，没有找到");
        }
    }
}

③、提到数组都离不开一个经典的排序——冒泡排序

public class ArrayTest2 {
    public static void main(String[] args) {
        int[] arr=new int[]{56,12,32,98,78,45,-45,3,55,-16};
        for (int i = 0; i < arr.length; i++) {
            for (int j=0;j<arr.length-1-i;j++){
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }
}