当前位置：
  1. 首页
  2. 市民
  3. 正文

数组的定义

  • 数组是相同类型数据的集合 比如全是int 或者全是 string

  • 数组描述是相同类型的数据，他们按照一定的先后次序排序

    （先后次序排序，取决于你输入的时候怎么排序）

  • 其中，每一个数据称作一个数组元素，每个数据元素可以通过一个下吧来访问。

    数组元素是从0开始的，假如数组有10个数字，他最高的下标是9

    俗称 从零开始的数组访问

数组声明和 创建

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

dataType[] arrayRefVar;   //首选的方法 
或
    dataType[] arrayRefVar[];//效果相同，但不是首选语法

一个是在类型后面加中括号一个是在变量名后面加中括号

package array;

public class ArrayDay01 { 
    //变量的类型 变量的名字 = 变量的值
    //数组类型

    public static void main(String[] args) { 
        int[] nums; //定义 //首选的方法
        int nums2 [];  //这2种都是可以的 //效果相同，但不是首选方法
        //加一个中括号，就可以代表这是int类型的数组了
        //为什么会有2种，是因为int nums2[]是c++类型的，早期是为了让c++的人快速掌握Java。 所以平时就用int[] nums;类型的就可以了

        nums = new int[10];//这里面可以存放10个int类型的数字
    }

看一下上面的代码，可以知道int[] nums 和int nums[] 的区别在哪里

如果没有数组的话，我们要定义一个数值，就要int x

int x1 int x2 这样，很麻烦，要写很多代码

比如图中的框框是一个内存，我们定义了一个int x=1 ，那么这个空间就是等于1了， 而那个空间的名称就叫做x

这个空间就是int类型，里面就是数字1 ，但是只能放一个。

要是想要定义10个，就要复制10个，非常麻烦

数组的意思

int[] nums = new int[10]

//int[] nums 数组的意思

//new int[10] **是新建一个int类型的组，新建了一个空间，空间里面开了10个数值 ** new 是 新 的意思

然后这个空间的名称叫做nums

这个空间里面被开辟了10个空间 ，空间数量多少 取决于new int[10] 的中括号里面的数值为多少，则空间数量为多少

里面所有的类型都是int类型的

里面的空间，分别对应1-10

然后每个空间都有一个编号也就是所谓的下标

下标是从0开始的

0-9是位置编号，1-10是里面的值

我们要取值的话，就是 nums 下的第0号元素。

相当于原来是一个数，现在是一组数，

但是这一组的同一个名字，所以他里面的类型必须都相同

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

dataType[] arrayRefVar = new dataType[]
    //dataType[] arrayRefVar 我们的数组 
    //dataType[] 为类型
    //arrayRefVar 为名称
    //new dataType[] 就是新建一个类型为dataType的组

就跟int[] nums = new int[];

这样 int[] nums 是变量 和 名称

new int[] 是创建一个类型为int 类型的组

示列

package array;

public class ArrayDay01 { 
    //变量的类型 变量的名字 = 变量的值
    //数组类型
    public static void main(String[] args) { 
        int[] nums; //声明一个数组
        nums = new int[10];//创建一个数组，里面可以存放10个int类型的数字
        //给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;
        System.out.println(nums[0]);
    }
}

运行一下， 得出1

我们吧0改成9 运行一下，得出10

如果我们吧

nums[9] = 10;

给删掉话，再次运行就会得出一个默认值0

当然也可以

int[] nums = new int[]   
//数据类型+上一个中括号代表他是数组
    //名称
    //在new一个int类型的数组，（中括号里面）再给他分配一个初始的大小
    //数组必须给他一个初始值，不然特没有特定的值，万一无线创下去就乱套了
    //数组的长度是确定的，一旦创建，它的大小就是不可以更改的

这样，我们吧声明和长度写在一起了

获取数组的长度 语法

arrays.length

​ arrays为数组的名称

length 是获取长度

求数组的全部值的和

package array;
public class ArrayDay01 { 
    //变量的类型 变量的名字 = 变量的值
    //数组类型
    public static void main(String[] args) { 
        int[] nums; //声明一个数组
        nums = new int[10];//创建一个数组，里面可以存放10个int类型的数字
        //给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;
        //计算所有元素的和
        int sum = 0;
        //获取数组长度： arrays.length
        for (int i = 0;i<nums.length ; i++){ 
            sum = sum +nums[i];
        }
          System.out.println("总和为："+sum);
    }
}

如图

内存分析

  • Java内存分析

理解

  1. 声明一个nums，这个时候在堆里面还是没有东西的。 但是在栈（zhan）里面会压过一个东西，叫做nums.

    我们现在只是声明了一个数组，这个数组是空的，他只有一个名字，这个名字并没有什么实际作用

    2.第二部创建数组

    nums = new int [10]

    new一个int ，产生了 new这个事件

    看上面的图片，new关键词都会放在堆里面

    于是乎，在做完这个第二部的时候栈里面的nums

    在堆里面做了一件事情

    他开辟了一个空间，这个空间就是int类型

    里面被分成了10个小块，因为初始的大小为10

  2. 声明的时候，这个数组并不存在，只有我们通过new关键词去创建的时候，这个数组才存在，当我们给里面赋值的时候，这里面才有值，没有赋值的话，里面就是默认值

加入我们只有10个元素，那我要是获取第11个元素会怎么样呢？

  //给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;
       
          System.out.println(nums[10]);

就会看到一个错误

java.lang.ArrayIndexOutOfBoundsException

array 数组的意思

IndexOutOfBounds 数组下标越界了

就是说，我们数组只有10个，你却取第11个，

第11个，可能在外面，也有可能不存在，所以是拿不到的

所以就会异常

不过一般来说，我们都是把声明和创建写在一块

int[] nums =new int[10];

数组的三种初始化

  • 静态初始化

  • 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;

  • 数组的默认初始化

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

静态初始化

 int[] a = { 1,2,3,4,5,6,7,8};
        System.out.println(a[0]);

我个人理解是

静态初始化

int[] 这是数组的一个类型

a = 名称

我们之前呢？ 是new int[] new了一个int让它初始化

我们也可以直接给他初始化，一个{}括号就代表这是一个数组

所有花括号括起来的都是一个数组

然后我们在往数组里面放元素了。放多少个，它的空间就是多大 ，一旦定义之后就不可以改变了

a就是固定那么多

创建的时候顺便赋值

我们输出一下 a[0] 发现等于1

动态初始化

int[] b = new int[10];
b[0] = 10;
b[1] = 10;
b[2] = 10;
b[3] = 10;
b[4] = 10;
System.out.println(b[0]);
System.out.println(b[1]);
System.out.println(b[2]);
System.out.println(b[3]);
System.out.println(b[4]);

int[] b = new int[10];

int[] b = new int[10]；

前面的叫声明，后面的叫初始化，给他创建空间

但是空间创建完之后，里面现在的所有值都是零

我们要给他去手动赋值

动态初始化：默认初始化

数组在没有被赋值的时候默认是0，String类型是null 空的意思

 int[] b = new int[10];
        b[0] = 10;
  System.out.println(b[0]);
        System.out.println(b[1]);

我们运行b[0]和b[1]

发现

一个为10 一个为0

没有被初始化的空间，默认值是0

数组的四个基本特点

  • 长度是确定的。数组一旦被创建，它的大小计算不可以改变的。如果说需要改变大小，那么只能重新创建

  • 其中元素的类型必须是相同的类型，不允许出现混合类型

    比如里面定义的是int类型，那么就不能出现String类型

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

  • 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

    数组本身就是对象，Java中对象是在堆中的，因此数组无论保持原始类型还是其他对象类型，数组对象本身是在堆中的

    只要使用new关键词，new出来的，以及数组，都是在堆中的

不管是原始类型还是其他对象类型的，所有东西都是保存在堆中的

数组边界

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

    就比如说，我们的数组长度为10，

    但是真正的下标数值为[0,10-1]

    就是[0，9]

    public stativ void main(String[] args){ 
    int[] a = new int [2];
    System.out.println(a[2]);
}

上图中的代码，一旦运行就会出现

ArrayIndexOutOfBoundsException:数组下标越界异常！

出现这个错误的时候，就要回去看看，什么地方越界了

示范

package array;

public class ArrayDay02 { 
    public static void main(String[] args) { 
        //静态初始化 创建+赋值
        int[] a = { 1,2,3,4,5,6,7,8};
  
         for(int i = 0; i<a.length; i++){     //a.length 的意思是，可以获取a数组的长度
             System.out.println(a[i]);

         }

a.length 的意思是

a为我们数组的名称

length为 数组的长度

System.our.println(a[i])；

我们输出一下

就会发现全部都运行出来了

我们在i<a.length 的那个地方加个=

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

         }

再次运行就会发现

越界了

i<=8 的时候 i=8 ，但是数组里面没有int [8]的数组

所以显示越界了

数组边界小结

数组是相同数据类型的有序集合

数组也是对象。因为他是new出来的，数组元素相当于对象的成员变量

数组的长度是确定的，不可以变的，想改变的话，必须重新创建一个

如果越界就会报出 ArrayIndexOutOfBounds

数组使用

  • For-Each 循环

  • 数组作方法入参

  • 数组作返回值

    package array;

public class ArrasyDay03 { 
    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 k = 0 ; k<arrays.length;k++){ 
                sum = sum + arrays [k] ;
            }
               System.out.println("sum :" +sum);        System.out.println("=====================");
        //查找最大元素
        int max = arrays[0];
       for (int i = 1; i < arrays.length; i++) { 
            if (arrays[i]>max){ 
                max = arrays[i];
            }
        }
       System.out.println("max ="+max);
        }
    }

分别是打印数组、求和还有最大元素的写法

For-Each 循环 刚刚我们用的都是普通的for循环

​

public static void main(String[] args) { 
        int[] arrays = { 1,2,3,4,5};
         
         //JDK1.5以上版本 省略了下标 // 用于打印输出
        for (int array : arrays) { 
            // arrays 代表一个数组
            System.out.println(array);
        }

我们输入arrays.for 就是自动变成 上面的方法理解就好

for(int array ： arrays) 
    // int array 是类型+名称
    //arrays 是数组的名称
    //： 是类似于==的意思

然后我们在输出一下，这样子的for循环是直接吧arrays里面的数值

一个一个打印出来，是比较简单的一种操作

但是还是建议使用这种类型的

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

数组作方法入参 数组作返回值

打印数组元素

 .public static void main(String[] args){ 
   printArray(reverse);  
 } 
     
public static void printArray(int[] arrays) { 
     //static 是为了后面方便调用， 就是类变量
     //printArray 是方法名称
     //int[] arrays 是int类型 arrays名称的数组
     
     
        for(int i = 0 ;i < arrays.length;i++){ 
              // arrays.langth arrays是数组名称
            //langth 是长度的意思， 合在一起就是arrays这个数组的长度有多长
            
            System.out.print(arrays[i]+" ");
            //print 是运行完之后不换行
        }

输出一下，就是

反转数组

package array;

public class ArrasyDay04 { 
    public static void main(String[] args) { 
        int[] arrays = { 1,2,3,4,5};
        int[] reverse = reverse(arrays);
        printArray(reverse);
    }
    //反转数组
    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;
    }
}

第一步

public static int[] reverse(int[] arrays){ 
     //public static 是修饰符 
    //int[] 为返回的数据类型 返回一个数组
    //reverse 是方法名称 reverse ： 反转
    //传递的是数组参数 int[] arrays arrays名称的数组类型
    //
}

第二部

 public static int[] reverse(int[] arrays){ 
        int[] result = new int[arrays.length];
 
        }

声明并创建一个数组，数值为arrays.length 意思是 arrays数组的长度

这样可以保证，是同一个结果

第三部 反转操作

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--){ 
        //j=result.length-1 是因为有个下标是0
        result[j] = arrays[i];	
        //result[j] 因为上面 int[arrays.length]; 也就是说他是5 
        //所以j=result.length-1 = 4 (这是下标) 
        //而arrats[i] 是从1开始 ，然后递增 到4
        //所以j=4 i=1
        //j 是下标符 i是数值
        //所以4=1 3=2 2=3 1=4 0=5
        //然后排序就是5,4,3,2,1
        
        
    }
    return result;
        }

result[j] 因为上面 int[arrays.length]; 也就是说他是5
所以j=result.length-1 = 4 (这是下标)
而arrats[i] 是从1开始 ，然后递增 到4
所以j=4 i=1
j 是下标符 i是数值
所以4=1 3=2 2=3 1=4 0=5
然后排序就是5,4,3,2,1

然后再return返回result的值

然后我们在输出一下

public class ArrasyDay04 { 
    public static void main(String[] args) { 
        int[] arrays = { 1,2,3,4,5};
            int[] reverse = reverse(arrays);
        printArray(reverse);

输入reverse(arrays);

就会返回一个结果，这个结果就是已经被反转过的数组

int[] reverse = reverse(arrays);

然后再输出printArray(revers);

运行一下

本文地址：https://blog.csdn.net/XYzuiyou/article/details/113967046

上一篇 万年历羊年查询表，万年历属相生肖查询表羊命
下一篇 HashMap和Hashtable的区别？？？

相关文章