数组的定义、数组声明和创建、获取数组的长度 语法 及反向数组
数组的定义
-
数组是相同类型数据的集合 比如全是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内存分析
理解
-
声明一个nums，这个时候在堆里面还是没有东西的。 但是在栈（zhan）里面会压过一个东西，叫做nums.
我们现在只是声明了一个数组，这个数组是空的，他只有一个名字，这个名字并没有什么实际作用
2.第二部创建数组
nums = new int [10]
new一个int ，产生了 new这个事件
看上面的图片，new关键词都会放在堆里面
于是乎，在做完这个第二部的时候栈里面的nums
在堆里面做了一件事情
他开辟了一个空间，这个空间就是int类型
里面被分成了10个小块，因为初始的大小为10
-
声明的时候，这个数组并不存在，只有我们通过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
推荐阅读
-
数组的定义、数组声明和创建、获取数组的长度 语法 及反向数组
-
灵魂拷问：Java如何获取数组和字符串的长度？length还是length()？
-
java数组声明和使用（java中数组的定义与使用）
-
C#中获取二维数组的行数和列数以及多维数组各个维度的长度
-
闭包的原理与经典应用场景，访问器属性，类与对象的创建与成员引用，数组与对象的解构过程与经典案例，JS引入到浏览器中的的方法及获取DOM元素的两个API
-
闭包的原理与经典应用场景，访问器属性，类与对象的创建与成员引用，数组与对象的解构过程与经典案例，JS引入到浏览器中的的方法及获取DOM元素的两个API
-
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂
-
php数组的foreach和for遍历循环，以及系统函数，自定义函数的使用，数组遍历的模板语法以及定界符单引号双引号的使用
-
JS获取数组最大值、最小值及长度的方法_javascript技巧
-
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂