Java中的数组arrays

作者: Arvin Chen 分类: Java 来源: Break易站(www.breakyizhan.com)

Java中的数组arrays

数组是一组通用名称引用的类型变量。Java中的数组的工作方式与在C / C ++中的工作方式不同。以下是关于Java数组的一些重要观点。

  • 在Java中,所有数组都是动态分配的(下面讨论)
  • 由于数组是Java中的对象,我们可以使用成员长度来查找它们的长度。这与使用sizeof查找长度的C / C ++不同。
  • 在数据类型之后,Java数组变量也可以用[]与其他变量一起声明。
  • 数组中的变量是有序的,每个变量都有一个从0开始的索引。
  • Java数组也可以用作静态字段,局部变量或方法参数。
  • 数组的大小必须由int值指定,不能长或短。
  • 数组类型的直接超类是Object。
  • 每种数组类型都实现Cloneable和java.io.Serializable接口。

根据数组的定义,数组可以包含基本数据类型以及类的对象。在基元数据类型的情况下,实际值存储在连续的存储位置。对于类的对象,实际对象存储在堆段中。

Java中的数组arrays

创建,初始化和访问数组

一维数组:

一维数组声明的一般形式是

type var-name[];
OR
type[] var-name;

数组声明包含两个组件:类型和名称。类型声明数组的元素类型。元素类型决定了构成数组的每个元素的数据类型。类似于int类型的数组,我们也可以创建其他基本数据类型的数组,如char,float,double..etc或用户定义的数据类型(类的对象)。因此,数组的元素类型决定了数组将保存的数据。
例:

//都是有效的声明
int intArray []; 
或int [] intArray; 

byte byteArray [];
shot shortsArray [];
boolean booleanArray [];
long longArray [];
float floatArray [];
double doubleArray [];
char charArray [];

//对象的引用数组
//类MyClass(一个类创建的
//用户)
MyClass myClassArray []; 

Object [] ao,// Object的数组
Collection[] ca; // Collection的数组
                     //未知类型

尽管上面的第一个声明确定了intArray是一个数组变量的事实,但实际上并不存在任何数组。它只是告诉编译器,这个(intArray)变量将包含整数类型的数组。要将intArray与实际的物理整数数组链接起来,您必须使用new分配一个并将其分配给intArray。

在Java中实例化一个数组

当我们声明一个数组时,只会创建一个数组的引用。为了实际创建或给出数组的内存,可以像下面这样创建一个数组:新的一般形式适用于一维数组,如下所示:

var-name = new type [size];

这里,type指定要分配的数据的类型,size指定数组中元素的数量,var-name是链接到数组的数组变量的名称。也就是说,要使用new分配数组,您必须指定要分配的元素的类型和数量。

例:

int intArray []; //声明数组
intArray = new int [20]; //将内存分配给数组

要么

int [] intArray = new int [20]; //将两个语句合并为一个

注意 :

  1. 由new分配的数组中的元素将自动初始化为0(对于数字类型),false(对于布尔值)或null(对于引用类型)
  2. 获取数组是一个两步过程。首先,你必须声明一个所需数组类型的变量。其次,您必须使用new分配将容纳数组的内存,并将其分配给数组变量。因此,在Java中,所有数组都是动态分配的。

数组new

在已知数组大小和数组变量的情况下,可以使用数组new。

 int [] intArray = new int [] {1,2,3,4,5,6,7,8,9,10}; 
 //声明数组文字
  • 该数组的长度决定了创建的数组的长度。
  • 无需在最新版本的Java中编写新的int []部分

使用for循环访问Java数组元素

数组中的每个元素都通过其索引进行访问。索引从0开始并以(总数组大小)-1结束。可以使用Java for Loop访问数组的所有元素。

// accessing the elements of the specified array
for (int i = 0; i < arr.length; i++)
  System.out.println("Element at index " + i + 
                                " : "+ arr[i]);

执行:

// Java program to illustrate creating an array
// of integers,  puts some values in the array,
// and prints each value to standard output.
 
class GFG
{
    public static void main (String[] args)
    {
      // declares an Array of integers.
      int[] arr;
 
      // allocating memory for 5 integers.
      arr = new int[5];
 
      // initialize the first elements of the array
      arr[0] = 10;
 
      // initialize the second elements of the array
      arr[1] = 20;
 
      //so on...
      arr[2] = 30;
      arr[3] = 40;
      arr[4] = 50;
 
      // accessing the elements of the specified array
      for (int i = 0; i < arr.length; i++)
         System.out.println("Element at index " + i +
                                      " : "+ arr[i]);
    }
}

输出:

Element at index 0 : 10
Element at index 1 : 20
Element at index 2 : 30
Element at index 3 : 40
Element at index 4 : 50

你也可以使用foreach循环访问java数组
Java中的数组arrays

对象阵列

按照以下方式创建对象数组,就像原始类型数据项的数组一样。

 Student[] arr = new Student[7]; //student is a user-defined class

studentArray包含七个存储空间,每个存储空间的大小可以存储七个Student对象的地址。学生对象必须使用Student类的构造函数实例化,并且它们的引用应该分配给以下方式。

Student arr = new Student[5];
// Java program to illustrate creating an array of
// objects
 
class Student
{
    public int roll_no;
    public String name;
    Student(int roll_no, String name)
    {
        this.roll_no = roll_no;
        this.name = name;
    }
}
 
// Elements of array are objects of a class Student.
public class GFG
{
    public static void main (String[] args)
    {
        // declares an Array of integers.
        Student[] arr;
 
        // allocating memory for 5 objects of type Student.
        arr = new Student[5];
 
        // initialize the first elements of the array
        arr[0] = new Student(1,"aman");
 
        // initialize the second elements of the array
        arr[1] = new Student(2,"vaibhav");
 
        // so on...
        arr[2] = new Student(3,"shikar");
        arr[3] = new Student(4,"dharmesh");
        arr[4] = new Student(5,"mohit");
 
        // accessing the elements of the specified array
        for (int i = 0; i < arr.length; i++)
            System.out.println("Element at " + i + " : " +
                        arr[i].roll_no +" "+ arr[i].name);
    }
}

输出:

Element at 0 : 1 aman
Element at 1 : 2 vaibhav
Element at 2 : 3 shikar
Element at 3 : 4 dharmesh
Element at 4 : 5 mohit

如果我们尝试访问数组大小之外的元素会发生什么?

编译器会抛出ArrayIndexOutOfBoundsException异常,以表明该数组已被非法索引访问。索引是否定的或者大于或等于数组的大小。

class GFG
{
    public static void main (String[] args)
    {
        int[] arr = new int[2];
        arr[0] = 10;
        arr[1] = 20;
 
        for (int i = 0; i <= arr.length; i++)
            System.out.println(arr[i]);
    }
}

运行时错误

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
	at GFG.main(File.java:12)

输出:

10
20

多维数组

多维数组是数组的数组,数组中的每个元素都包含其他数组的引用。这些也被称为Jagged Arrays。通过为每个维度附加一组方括号([])来创建多维数组。例子:

int [] [] intArray = new int [10] [20]; // 2D数组或矩阵
int [] [] [] intArray = new int [10] [20] [10]; // 3D数组
class multiDimensional
{
    public static void main(String args[])
    {
        // declaring and initializing 2D array
        int arr[][] = { {2,7,9},{3,6,1},{7,4,2} };
 
        // printing 2D array
        for (int i=0; i< 3 ; i++)
        {
            for (int j=0; j < 3 ; j++)
                System.out.print(arr[i][j] + " ");
 
            System.out.println();
        }
    }
}

输出:

2 7 9 
3 6 1 
7 4 2 

Java中的数组arrays

将数组传递给方法

像变量一样,我们也可以将数组传递给方法。例如,下面的程序将数组传递给方法sum以计算数组值的总和。

// Java program to demonstrate
// passing of array to method
 
class Test
{
    // Driver method
    public static void main(String args[])
    {
        int arr[] = {3, 1, 2, 5, 4};
 
        // passing array to method m1
        sum(arr);
 
    }
 
    public static void sum(int[] arr)
    {
        // getting sum of array values
        int sum = 0;
 
        for (int i = 0; i < arr.length; i++)
            sum+=arr[i];
 
        System.out.println("sum of array values : " + sum);
    }
}

输出:

sum of array values : 15

从方法返回数组

像往常一样,一个方法也可以返回一个数组。例如,下面的程序从方法m1返回一个数组。

// Java program to demonstrate
// return of array from method
 
class Test
{
    // Driver method
    public static void main(String args[])
    {
        int arr[] = m1();
 
        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i]+" ");
 
    }
 
    public static int[] m1()
    {
        // returning  array
        return new int[]{1,2,3};
    }
}

输出:

1 2 3

用于数组的类对象

每个数组都有一个关联的Class对象,与具有相同组件类型的所有其他数组共享。

// Java program to demonstrate
// Class Objects for Arrays
 
class Test
{
    public static void main(String args[])
    {
        int intArray[] = new int[3];
        byte byteArray[] = new byte[3];
        short shortsArray[] = new short[3];
 
        // array of Strings
        String[] strArray = new String[3];
 
        System.out.println(intArray.getClass());
        System.out.println(intArray.getClass().getSuperclass());
        System.out.println(byteArray.getClass());
        System.out.println(shortsArray.getClass());
        System.out.println(strArray.getClass());
    }
}

输出:

class [I
class java.lang.Object
class [B
class [S
class [Ljava.lang.String;

说明:

  1. 字符串“[I”是类型为int的类对象“数组的运行时类型签名”。
  2. 任何数组类型的唯一直接超类是java.lang.Object。
  3. 字符串“[B”是类对象的运行时类型签名“组件类型为byte ”。
  4. 字符串“[S”是组件类型为short的类对象的数组的运行时类型签名。
  5. 字符串“[L”是组件类型为Class的类对象“数组的运行时类型签名”。类名称随后。

数组成员

现在,您知道数组是类的对象,并且数组的直接超类是类Object。数组类型的成员都是以下各项:

  • 公共最终字段长度,其中包含数组的组成部分数量。长度可能是正数或零。
  • 所有成员从Object类继承没有继承的对象的唯一方法是它的克隆方法。
  • 公共方法clone(),它覆盖Object类中的clone方法并不引发检查的异常。

克隆数组

  • 当克隆一个单维数组,例如Object []时,将使用包含原始数组元素副本而不是引用的新数组执行“深层副本”。
    // Java program to demonstrate
    // cloning of one-dimensional arrays
     
    class Test
    {
        public static void main(String args[])
        {
            int intArray[] = {1,2,3};
     
            int cloneArray[] = intArray.clone();
     
            // will print false as deep copy is created
            // for one-dimensional array
            System.out.println(intArray == cloneArray);
     
            for (int i = 0; i < cloneArray.length; i++) {
                System.out.print(cloneArray[i]+" ");
            }
        }
    }
    

    输出:

    false
    1 2 3
    

     

  • 多维数组的克隆(如Object [] [])是一个“浅拷贝”,也就是说它只创建一个新数组,每个元素数组对一个原始元素数组的引用,但是子数组是共享的。
    // Java program to demonstrate
    // cloning of multi-dimensional arrays
     
    class Test
    {
        public static void main(String args[])
        {
            int intArray[][] = {{1,2,3},{4,5}};
     
            int cloneArray[][] = intArray.clone();
     
            // will print false
            System.out.println(intArray == cloneArray);
     
            // will print true as shallow copy is created
            // i.e. sub-arrays are shared
            System.out.println(intArray[0] == cloneArray[0]);
            System.out.println(intArray[1] == cloneArray[1]);
     
        }
    }
    

    输出:

    false
    true
    true

Java中,数组的一些常见问题

  •   本文标题:Java中的数组arrays - Break易站
    转载请保留页面地址:https://www.breakyizhan.com/java/4032.html
      微信返利机器人
      免费:淘宝,京东,拼多多优惠券
      腾讯,爱奇艺,优酷的VIP视频免费解析,免费看
      即刻扫描二维码,添加微信机器人!

    发表笔记

    电子邮件地址不会被公开。 必填项已用*标注