java中数组的定义及使用方法详解

1 数组的概念和其他语言一样，Java也提供数组支持，数组是属于引用类型，即数组是一个对象。

强调数组的类型是引用类型。

数组的基本概念及作用数组是相同数据类型元素的集合数组本身是引用数据类型，即对象。

但是数组可以存储基本数据类型，也可以存储引用数据类型。

数组的举例int [] a = new int []{1,2,3,4,5};String [] s = new String []{"小熊","小小熊","小小小熊"}; Employee [] e=new Employee[10];（Employee是自定义类）2 数组的声明数组的声明的两种方式：数据类型 [] 数组名字例如：int [] a;数据类型数组的名字 [] 例如： int a [];注意：在Java语言中两种声明方法没有任何区别，但是建议大家用第一种，避免混淆a的数据类型。

数组在声明后还只是一个空指针，不能使用，要想使用必须创建。

数组创建的三种方式：•//声明数组的同时，根据指定的长度分配内存，但数组中元素值都为默认的初始化值char[] chAry = new char[10];•//声明数组并分配内存，同时将其初始化•int[] ary1 = new int[]{1, 2, 3, 4, 5};•//与前一种方式相同，仅仅只是语法相对简略•int[] ary2 = {1, 2, 3, 4, 5};从另一个角度，数组创建可以分为动态和静态两种动态创建数组（没有为元素赋值，可以结合for循环进行赋值）char[] chAry = new char[10];静态创建数组，在创建的时候，即为每个元素赋初值int[] ary1 = new int[]{1, 2, 3, 4, 5};数组的长度数组的长度：length属性int [] b1 = new int []{1,2,3,4,5,6,7};System.out.println(b1.length);注意：数组的长度是属性，String的长度是length（）；创建数组的时候必须指定数组的长度，而且一经定义则不允许改变。

java数组定义方法Java数组是一种用于存储多个相同类型元素的数据结构。

定义方法是在程序中声明一个数组变量，并为其分配内存空间。

在Java中，数组的定义方法可以通过以下几种方式来实现。

1. 通过指定数组长度进行定义可以使用以下语法来定义一个数组：```dataType[] arrayName = new dataType[arrayLength];```其中，dataType是数组中元素的数据类型，arrayName是数组的名称，arrayLength是数组的长度，即数组可以存储的元素个数。

例如，定义一个整型数组变量arr，长度为5的数组可以写成：```int[] arr = new int[5];```这样就在内存中分配了一个可以存储5个整数的数组。

2. 通过指定初始值进行定义除了指定数组长度外，还可以直接指定初始值来定义数组。

可以使用以下语法来定义一个数组：```dataType[] arrayName = {value1, value2, ...};```其中，value1、value2等是数组中的元素值。

例如，定义一个字符串数组变量names，包含三个初始值可以写成：```String[] names = {"Tom", "Jerry", "Alice"};```这样就定义了一个包含三个字符串元素的数组。

3. 通过指定数组长度和初始值进行定义还可以同时指定数组的长度和初始值，可以使用以下语法来定义一个数组：```dataType[] arrayName = new dataType[]{value1, value2, ...};```例如，定义一个浮点型数组变量scores，长度为4，初始值为{98.5, 78.2, 86.7, 92.3}可以写成：```float[] scores = new float[]{98.5, 78.2, 86.7, 92.3};```这样就定义了一个长度为4的浮点型数组，并指定了初始值。

System.out.println(e.getMessage());
}
}
}
//输入方法二(这里发生了方法的重载)
public static voidscoreInput(float[] arr){
Scanner sc=new Scanner(System.in);
int i=0;
while(i<arr.length){
import java.util.*;
class Average1{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
float avg=0;
float sum=0;
int count=0;
int n=0;
//result.delete(result.length()-1,result.length());
//System.out.print(result.substring(0,result.length()-1));
//result.setCharAt(result.length()-1,' ');
float sum=0;
int count=0;
int n=0;
StringBuilder result=new StringBuilder();//这非同步的字符串缓冲类
System.out.println("班级人数:");
try{
n=sc.nextInt();
}catch(InputMismatchException e0){
}catch(InputMismatchException e1){

Java中数组的定义与使⽤⽬录⼀、数组的基本⽤法1.什么是数组2.创建数组3.数组的使⽤⼆、数据作为⽅法参数1.基本⽤法2.理解引⽤类型3.认识null4.JVM内存区域划分5.数组作为⽅法的返回值6.关于数组的地址四、数组练习1.数组转字符串2.数组拷贝五、⼆维数组1.⼆维数组的语法2.⼆维数组的结构3.⽤for-each遍历⼆维数组总结⼀、数组的基本⽤法1.什么是数组数组本质上就是让我们能 “批量” 创建相同类型的变量。

如果我们需要创建多个同⼀个类型的变量，则不可能⼿动⼀个接⼀个地创建，如：int n=10; int m =20;int y = 30;等等，因此数组能帮我们批量创建同⼀个类型的数据。

注意事项: 在 Java 中, 数组中包含的变量必须是相同类型。

2.创建数组基本语法：// 动态初始化数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };// 静态初始化数据类型[] 数组名称 = { 初始化数据 };//不初始化数据类型[] 数组名称 = new 数据类型[需要创建的数组长度];代码⽰例：int[] arr = new int[]{1, 2, 3};int[] arr = {1, 2, 3};int[] arr = new int[3];注意事项: 静态初始化的时候, 数组元素个数和初始化数据的格式是⼀致的。

虽然我们也可以使⽤：int arr[] = {1, 2, 3}; ，但是还是更推荐写成 int[] arr 的形式，int和 [] 是⼀个整体。

3.数组的使⽤int[] arr = {1, 2, 3};// 获取数组长度System.out.println("length: " + arr.length); // 执⾏结果: 3// 访问数组中的元素System.out.println(arr[1]); // 执⾏结果: 2System.out.println(arr[0]); // 执⾏结果: 1arr[2] = 100;System.out.println(arr[2]); // 执⾏结果: 1001.使⽤ arr.length 能够获取到数组的长度，. 这个操作为成员访问操作符. 后⾯在⾯向对象中会经常⽤到。

java实验报告--数组Java实验报告 - 数组引言：Java是一种广泛应用于软件开发的编程语言，其强大的数组功能使得它成为处理大量数据的理想选择。

本实验报告将探讨Java中数组的基本概念、使用方法以及一些常见的应用场景。

一、数组的定义与初始化在Java中，数组是一种用于存储多个相同类型元素的数据结构。

数组可以存储基本数据类型（如整数、浮点数等）或者对象。

声明一个数组需要指定元素的类型和数组的名称，然后使用关键字"new"来创建数组对象。

二、数组的访问与操作通过索引（index）可以访问数组中的元素，索引从0开始计数。

例如，对于一个长度为10的整数数组，可以使用arr[0]来访问第一个元素，arr[1]来访问第二个元素，以此类推。

数组的长度可以通过arr.length来获取。

三、数组的遍历与排序遍历数组是指逐个访问数组中的元素。

常用的遍历方法有使用for循环和foreach循环。

对于需要对数组进行排序的情况，可以使用Java提供的排序算法（如快速排序、冒泡排序等）或者使用Arrays类中的sort方法。

四、多维数组除了一维数组，Java还支持多维数组。

多维数组可以看作是数组的数组，可以用于存储表格、矩阵等结构化数据。

在声明多维数组时，需要指定每一维的长度。

五、数组的应用场景1. 数据存储与处理：数组可以用于存储和处理大量数据，如学生成绩、员工工资等。

通过数组，可以方便地进行数据的查找、排序和统计等操作。

2. 图像处理：图像可以用二维数组表示，每个元素代表一个像素点的颜色值。

通过对数组的操作，可以实现图像的旋转、缩放等功能。

3. 算法实现：许多算法的实现都需要使用数组，如查找算法、排序算法等。

数组的高效访问和操作使得算法的实现更加简洁和高效。

六、实验案例：数组的查找与统计为了更好地理解数组的应用，我们设计了一个实验案例：数组的查找与统计。

假设有一个整数数组，我们需要找到其中的最大值、最小值、平均值以及某个特定元素的出现次数。

int score[ ];
该声明表示数组的名字为score，每个元素为整数。 要表示学生的体重（浮点数），可以声明元素的 数据类型为float的数组weight，其声明如下：
float[ ] weight;
“雪亮工程"是以区（县）、乡（镇） 、村（ 社区） 三级综 治中心 为指挥 平台、 以综治 信息化 为支撑 、以网 格化管 理为基 础、以 公共安 全视频 监控联 网应用 为重点 的“群 众性治 安防控 工程” 。
for (j=0; j<3; j++) {
d[i][j]=i+j; c[i][j]=d[i][j]; } e=d;
“雪亮工程"是以区（县）、乡（镇） 、村（ 社区） 三级综 治中心 为指挥 平台、 以综治 信息化 为支撑 、以网 格化管 理为基 础、以 公共安 全视频 监控联 网应用 为重点 的“群 众性治 安防控 工程” 。
“雪亮工程"是以区（县）、乡（镇） 、村（ 社区） 三级综 治中心 为指挥 平台、 以综治 信息化 为支撑 、以网 格化管 理为基 础、以 公共安 全视频 监控联 网应用 为重点 的“群 众性治 安防控 工程” 。
系统为该数组a的12个元素分配存储空间， 形式如表所示：
a[0][ 0] a[1 ][0] a[2][ 0]
声明的同时进行初始化
类型标识符 数组名[ ][ ]= new 类型标识符[行数][列数] 或
类型标识符[ ][ ] 数组名=new 类型标识符[行数][列数] int a[][]=new int[3][4];
数组中各元素通过两个下标来区分，每个下标的最小值为0， 最 大 值 分 别 比 行 数 或 列 数 少 1 。 a 的 12 个 元 素 分 别 为 a[0][0], a[0][1], a[0][2], a[0][3], a[1][0], a[1][1]，…，a[2][3]。

java中数组的定义方法摘要：1.数组的定义方法2.数组的初始化方法3.二维数组的定义和初始化4.数组的遍历方法5.数组的应用实例正文：在Java中，数组是一种非常重要且实用的数据结构。

它允许我们存储多个相同类型的数据。

下面我们将介绍数组的定义方法、初始化方法、二维数组的定义和初始化、数组的遍历方法以及数组的应用实例。

1.数组的定义方法在Java中，可以使用以下语法定义数组：```java数据类型数组名[]```例如，定义一个整型数组：```javaint[] arr;```2.数组的初始化方法数组的初始化有三种方法：（1）使用默认值初始化：```javaint[] arr = new int[5]; // arr={0, 0, 0, 0, 0}```（2）使用特定值初始化：```javaint[] arr = {1, 2, 3, 4, 5}; // arr={1, 2, 3, 4, 5}```（3）使用循环初始化：```javaint[] arr = new int[5];for (int i = 0; i < arr.length; i++) {arr[i] = i + 1;}// arr={1, 2, 3, 4, 5}```3.二维数组的定义和初始化二维数组是具有多行多列的数组，可以使用以下语法定义：```java数据类型数组名[][]```例如，定义一个二维整型数组：```javaint[][] arr;```二维数组的初始化方法与一维数组类似，也可以使用默认值、特定值或循环初始化。

4.数组的遍历方法数组的遍历有两种方法：（1）使用for循环遍历：```javafor (int i = 0; i < arr.length; i++) {for (int j = 0; j < arr[i].length; j++) {System.out.print(arr[i][j] + " ");}System.out.println();}```（2）使用增强型for循环遍历：```javafor (int[] arrElement : arr) {for (int element : arrElement) {System.out.print(element + " ");}System.out.println();}```5.数组的应用实例数组在很多场景下都有广泛的应用，例如：（1）存储和管理数据：如学生成绩、商品库存等。

Java中数组的定义⽅式数组定义⽅式⼀
动态⽅式（指定数组的长度）
格式：
数组存储的数据类型[]数组名字 = new 数组存储的数据类型[长度];
[] : 表⽰数组。

数组名字：为定义的数组起个变量名，满⾜标识符规范，可以使⽤名字操作数组。

new：关键字，创建数组使⽤的关键字。

数组存储的数据类型：看创建的数组⽤来存储什么数据类型。

[长度]：数组的长度，表⽰数组容器中可以存储多少个元素。

例⼦：
定义可以存储3个整数的数组容器，代码如下：
int[] arr = new int[3];
数组定义⽅式⼆
静态⽅式（指定数组的元素）
格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
定义存储1，2，3，4，5整数的数组容器。

int[] arr = new int[]{1,2,3,4,5};
或者省略格式：（不能先声明后赋值，只能声明的同时赋值）
数据类型[] 数组名 = {元素1,元素2,元素3...};
定义存储1，2，3，4，5整数的数组容器。

int[] arr = {1,2,3,4,5};
注意:
1.如果使⽤静态⽅式创建数组,那么系统会根据元素的个数⾃动计算数组的长度
2.静态⽅式创建数组右边的中括号⾥⾯不能写长度
3.静态⽅式的省略格式创建数组不能先声明后赋值,只能声明的同时直接赋值。

java 参数数组Java是一种面向对象的编程语言，它具有强大的参数传递机制。

其中，参数数组是Java中非常重要的一个概念。

本文将从以下几个方面介绍Java参数数组。

一、什么是参数数组在Java中，参数数组是指一个数组，它包含了方法的参数。

当我们需要传递多个参数时，可以将它们封装到一个数组中，然后将该数组作为方法的参数传递。

这样做的好处是可以简化代码，提高代码的可读性和可维护性。

二、如何定义参数数组定义参数数组的语法格式如下：public static void methodName(String[] args) {// 方法体}其中，methodName是方法的名称，String[] args是参数数组。

在方法体中，我们可以通过args数组来访问方法的参数。

三、如何使用参数数组使用参数数组的方法非常简单。

我们只需要在调用方法时，将需要传递的参数封装到一个数组中，然后将该数组作为方法的参数传递即可。

例如：public static void main(String[] args) {String[] params = {"param1", "param2", "param3"};methodName(params);}在上面的代码中，我们定义了一个名为params的数组，它包含了三个字符串类型的参数。

然后，我们将该数组作为参数传递给了methodName方法。

四、参数数组的注意事项在使用参数数组时，需要注意以下几点：1. 参数数组的长度可以为0，也可以为任意正整数。

2. 参数数组的元素类型可以是任意类型，包括基本数据类型和引用数据类型。

3. 参数数组的元素可以为null。

4. 参数数组的元素可以是可变参数，即使用...语法定义的参数。

五、总结Java参数数组是一种非常实用的编程技巧，它可以简化代码，提高代码的可读性和可维护性。

在使用参数数组时，需要注意参数数组的长度、元素类型、元素值等方面的问题。

静态初始化可用于不规则二维数组的初始化
//第一种方式： int a[][]={{1,2,3},{4,5,6}}; //第二种方式； int[][] ints = new int[4][2]; ints[i][j] =__; //分别赋值 //第三种方式：第二维的长度可以动态申请 int[][] arr3 = new int[5][];//五行的长度
登录后才能查看或发表评论立即登录或者逛逛博客园首页
Java中 一 维 数组 和 二 维 数 组 的 定 义 方 式
1、一维数组的三种定义方式
int[] arr1=new int[10]; int[] arr2={1,2,3,6}; int[] arr3=new int[]{1,2,3,4,5,6,7,22};
2、二维数组的定义方式
格式1: 动态初始化 数据类型 数组名 [ ][ ] = new 数据类型[m][n] 数据类型 [ ][ ] 数组名 = new 数据类型[m][n] 数据类型 [ ] 数组名 [ ] = new 数据类型[m][n]
举例：int [ ][ ] arr=new int [5][3]; 也可以理解为“5行3例”
格式2: 静态初始化 数据类型 [ ][ ] 数组名 = {{元素1,元素2....},{元素1,元素2....},{元素1,元素2....}.....};
举例：int [ ][ ] arr={{22,15,32,20,18},{12,21,25,19,33},{14,58,34,24,66},};

java 基本类型数组Java是一种面向对象的编程语言，它的数据类型分为基本类型和引用类型。

其中，基本类型包括boolean、byte、short、int、long、float和double类型。

基本类型数组是一种存储基本类型数据的容器。

本文将详细介绍Java基本类型数组的相关知识和用法。

一、创建基本类型数组创建基本类型数组的语法格式为：数据类型[] 数组名 = new 数据类型[数组长度]。

比如，创建一个整数数组，其长度为5，代码如下：int[] nums = new int[5];这段代码就创建了一个名为nums的整数数组，它可以存储5个整数。

二、访问基本类型数组的元素数组的每个元素都有一个下标，用于唯一标识该元素。

Java中的数组下标从0开始，因此访问数组元素时，要使用下标来指定元素的位置。

例如，访问nums数组中第3个元素的代码如下所示：这段代码将数组nums中第3个元素（下标为2）的值赋给了num3。

需要注意的是，如果访问一个不存在的数组元素，将抛出ArrayIndexOutOfBoundsException异常。

三、初始化基本类型数组Java数组在创建时，所有元素都会被自动初始化为相应类型的默认值。

整数类型数组的默认值为0，例如下面代码创建并初始化一个整数数组：int[] nums = new int[]{1, 2, 3, 4, 5};这段代码创建了一个名为nums的整数数组，它包含5个元素，每个元素的值分别为1、2、3、4和5。

四、遍历基本类型数组遍历数组是一种常见的操作，用于获取数组中的每个元素。

Java提供了两种遍历数组的方式：for循环和foreach循环。

下面是使用for循环遍历整数数组nums的代码：for(int i = 0; i < nums.length; i++){System.out.println(num);}这段代码逐个遍历数组nums中的元素，并将每个元素的值输出到控制台。

JAVA中数组的使⽤数组（array），是多个相同类型数据按照⼀定顺序排列的集合，并使⽤⼀个名字命名，通过编号的⽅式对这些数据进⾏统⼀管理。

做个铺垫：什么是数据结构？即数据与数据之间的逻辑关系，包含：集合、⼀对⼀、⼀对多、多对多等。

数据的存储结构：线性表（⼀对⼀的关系）：顺序表（数组）、链表、栈、队列树形结构（⼀对多的关系）：⼆叉树图形结构（多对多的关系）常应⽤的算法：排序算法搜索算法1、常见概念：数组概念：多个相同类型数据按⼀定顺序排列的集合，并使⽤⼀个名字命名，通过编号的⽅式对这些数据进⾏统⼀管理。

数组属于引⽤数据类型，数组中的元素可以是任何数据类型，包括引⽤数据类型。

创建数组对象会在内存中开辟⼀整块连续的空间，⽽数组名中引⽤的是这块连续空间的⾸地址。

数组相关的概念：1、数组名2、数组元素3、⾓标、下标、索引4、数组的长度：元素的个数数组的特点：顺序排列、长度⼀但确定不可修改数组的分类：1、按照维数：⼀维数组、⼆维数组。

2、按照数组元素的类型：基本数据类型元素的数组、引⽤数据类型元素的数组2、⼀维数组的使⽤1. ⼀维数组的声明和初始化：⼀旦初始化完成，长度就确认了。

int[] arr = new int[]{1,2,3,4,5};静态初始化String[] arr2= new String[5];动态初始化int[] arr3={1,2,3,4,5,5};静态初始化-类型推断2. 如何调⽤数组的指定位置的元素通过⾓标的⽅式调⽤，从0开始，到（数组的长度-1）结束。

arr[1]arr[2]3.如何获取数组的长度length属性int k = arr.length;4.如何遍历数组可通过for循环，依次通过数组的⾓标遍历。

5.数组元素的默认初始化值数组元素是整型，默认0数组元素是浮点型，默认0.0char，默认0或‘\u0000’,⽽⾮‘0’boolean,默认false数据元素是引⽤数据类型时，null6.数组的内存解析栈：stack，存放局部变量。

Java数组的基础知识Java数组是一种用于存储固定大小相同类型元素的数据结构。

数组在Java 中是一种引用类型，可以用来存储多个对象。

一、创建数组在Java中，可以使用以下语法来创建数组：dataType[] arrayName = new dataType[size];其中，dataType是数组元素的类型，arrayName是数组的名称，size是数组的大小。

例如，创建一个包含5个整数的数组：int[] myArray = new int[5];二、访问数组元素可以通过索引来访问数组中的元素。

在Java中，数组的索引从0开始。

例如，访问上述数组的第一个元素：int firstElement = myArray[0];三、修改数组元素同样，可以通过索引来修改数组中的元素。

例如，将上述数组的第一个元素修改为10：myArray[0] = 10;四、遍历数组可以使用for循环来遍历数组中的所有元素。

例如，遍历上述数组并打印每个元素：for (int i = 0; i < myArray.length; i++) {System.out.println(myArray[i]);}五、数组长度可以使用length属性来获取数组的长度。

例如，获取上述数组的长度：int length = myArray.length;六、多维数组Java还支持多维数组，即数组的数组。

例如，二维整数数组可以这样创建：int[][] my2DArray = new int[5][3];这创建了一个5行3列的二维整数数组。

同样地，可以通过索引来访问和修改其中的元素。

代码及内存分析 —— I
代码及内存分析 —— II
代码及内存分析 —— III
取得数组长度
要特别注意的是，在Java中取得数组的长度（也就是数组元素的长度）可以利用 “数组名称.length”完成，如下面的格式： 数组名称.length 返回一个int型数据
public class ArrayDemo03 { public static void main(String[] args) { int score[] = new int[3]; // 声明并实例化数组 System.out.println("数组长度为" + score.length); 求出数组长度 } }
数组
int [] x; x = new int[100]; x=null; 的内存状态变化情况
声明数组的同时分配内存空间
声明数组的同时分配内存： 数据类型 数组名[] = new 数据类型[个数] int score[] = new int[10] ;
声明一个元素个数为10的整型数组score，同时开辟一块内存空间供其 使用 在Java中，由于整数数据类型所占用的空间为4个bytes，而整型数组 score可保存的元素有10个，所以上例中占用的内存共有4 * 10 = 40个 字节
一维数组
一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的。 要使用Java的数组，必须经过两个步骤：（1）声明数组、（2）分配内 存给该数组。这两个步骤的语法如下： 声明形式一：
声明一维数组：数据类型 数组名[] = null ; 分配内存给数组：数组名 = new 数据类型[长度] ;
数组与方法 —— 数组定义及使用

java数组基本概念JaVa中的数组是一种数据结构，用于存储相同类型的元素。

数组是一种线性数据结构，可以容纳一组有序的元素。

每个元素都可以通过其索引(位置)进行访问。

在JaVa中，数组是一种对象，因此它们存储在堆内存中。

以下是Java数组的一些基本概念：1.声明数组：在JaVa中，必须先声明数组才能使用它。

声明数组时，需要指定数组的类型和名称。

例如：int[] arr;2.分配内存：声明数组后，必须为其分配内存空间。

这可以通过使用ne,关键字来完成。

例如：arr = new i∏t[5]:这将创建一个可以存储5个整数的数组。

3.初始化数组：可以在声明数组时直接初始化它。

例如：int□ arr= {1, 2, 3, 4, 5)：这将创建一个包含5 个整数的数组，并将它们初始化为1到5的值。

4.访问数组元素：可以通过使用数组的索引来访问它的元素。

数组的索引从O开始，因此第一个元素的索引为0,第二个元素的索引为1,依此类推。

mH：int firstEle≡ent = arr[0]:这将获取数组的第一个元素。

5.修改数组元素：可以通过使用数组的索引来修改它的元素。

例如：arr⑵=42;这将把数组的第三个元素修改为42o6.数组长度:可以使用Iength属性来获取数组的长度(即数组中元素的数量)。

例如：int length = arr∙ length;这将获取数组arr的长度。

7.多维数组：Java还支持多维数组，即数组的数组。

例如，二维数组可以看作是一个表格，其中每个单元格都可以存储一个值。

8.遍历数组：可以使用for循环或for-each循环来遍历数组中的所有元素。

例如，以下代码将打印出数组中的所有元素：java复制代利for (int i = 0; i < arr. length; i++) {System, out. println(arr[i]);}或者java复制代科for (int element : arr) {System, out. printin(element);)这些是Java数组的一些基本概念。

java字符数组⽤法总结,java字符串数组的定义与使⽤java字符数组，java数组的定义与使⽤⼆维数组String[] str = new String[5]; //创建⼀个长度为5的String(字符串)型的⼀维数组String[] str = new String[]{"","","","",""};String[] str = {"","","","",""};String数组初始化区别⾸先应该明⽩java数组⾥⾯存的是对象的引⽤，所以必须初始化才能⽤； String[] str = {"1","2","3"}与String[] str = newString[]{"1","2","3"}在内存⾥有什么区别？ 编译执⾏结果没有任何区别。

更不可能像有些⼈想当然说的在栈上分配空间，Java的对象都是在堆上分配空间的。

这⾥的区别仅仅是代码书写上的：　String[] str = {"1","2","3"}; 这种形式叫数组初始化式（ArrayInitializer），只能⽤在声明同时赋值的情况下。

⽽ String[] str = new String[]{"1","2","3"}是⼀般形式的赋值，=号的右边叫数组字⾯量（ArrayLiteral），数组字⾯量可以⽤在任何需要⼀个数组的地⽅（类型兼容的情况下）。

如： String[] str = {"1","2","3"}; // 正确的 String[] str = new String[]{"1","2","3"} // 也是正确的⽽ String[] str; str = {"1","2","3"}; // 编译错误因为数组初始化式只能⽤于声明同时赋值的情况下。

在Java 中，数组（array）是一种用来存储多个相同类型数据的对象。

数组在Java 中的应用非常广泛，以下是一些常见的用法：1. 声明和创建数组：声明数组的方法是使用`arrayOf` 或者直接使用方括号`[]`。

例如，创建一个整数数组：```javaint[] intArray = new int[5]; // 创建一个包含5 个整数的数组```2. 初始化数组：在创建数组时，可以使用大括号`{}` 初始化数组元素。

例如：```javaint[] intArray = {1, 2, 3, 4, 5}; // 创建一个包含5 个整数的数组```或者使用循环初始化数组：```javaint[] intArray = new int[5];for (int i = 0; i < intArray.length; i++) {intArray[i] = i + 1;}```3. 访问数组元素：使用数组下标来访问数组元素。

数组下标从0 开始。

例如：```javaint intValue = intArray[2]; // intValue 等于3```4. 修改数组元素：通过索引来修改数组元素。

例如：```javaintArray[2] = 42; // 将intArray 数组中下标为2 的元素修改为42```5. 获取数组长度：使用`length` 属性来获取数组的长度。

例如：```javaint length = intArray.length; // length 等于5```6. 遍历数组：使用for 循环或者增强型for 循环（for-each 循环）遍历数组。

例如：```javafor (int i = 0; i < intArray.length; i++) {System.out.println(intArray[i]);}```7. 数组操作：Java 提供了许多数组操作方法，例如`concat()`（合并数组）、`equals()`（比较两个数组是否相等）、`fill()`（填充数组）等。