文章目录
▌Java基础语法
〓 数组
■ 数组的概念
○ 数组概念: 数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致。
○ 是一种容器,可以同时存放多个数据值。
○ 容器:是将多个数据存储到一起,每个数据称为该容器的元素。
■ 数组的特点
○ 数组是一种引用数据类型。
○ 数组当中的多个数据,类型必须统一。
○ 数组的长度在程序运行期间不可变。
■ 数组的初始化
○ 在内存中创建一个数组,并且向其中赋予一些默认值。
■ 两种常见的初始化方式
■ 动态初始化 —— 指定长度
○ 在创建数组的时候,直接指定数组当中的数据元素个数。
○ 动态初始化数组的格式:
数据类型[] 数组名称 = new 数据类型[数组长度];
◐ 解析含义:
○ 左侧数据类型:也就是数组当中保存的数据,全都是统一的类型。
○ 左侧的中括号:代表我是一个数组。
○ 左侧数组名称:给数组取一个名字。
○ 右侧的new:代表创建数组的动作。
○ 右侧数据类型:必须和左边的数据类型保持一致。
○ 右侧中括号的长度:也就是数组当中,到底可以保存多少个数据,是一个int数字。
◐ 举例:
public class arrayText1 {
public static void main(String[] args) {
//创建一个数组,里面可以存放300个int类型的数据
//格式:数据类型[] 数组名称 = new 数据类型[数组长度];
int[] arrayA = new int[300];
//创建一个数组,里面可以存放10个double类型的数据
double[] arrayB = new double[10];
//创建一个数组,里面可以存放5个字符串
String[] arrayC = new String[5];
}
}
■ 静态初始化 —— 指定内容
○ 在创建数组的时候,不直接指定数据的个数,而是直接将具体的数据内容进行指定。
○ 静态初始化数组的格式
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3...};
◐ 注意事项:
○ 虽然静态初始化没有直接告诉长度,但是根据大括号里面的元素具体内容,也可以自定推算出长度。
public class arrayText2 {
public static void main(String[] args) {
//直接创建一个数组,里面装的全是int数字,具体为:5/15/25
int[] arrayA = new int[]{5,15,25};
//创建一个数组,用来装字符串:"Hello","World","Java"
String[] arrayB = new String[]{"Hello","World","Java"};
}
}
◐ 格式省略的静态初始化
○ 使用静态初始化数组的时候,格式还可以省略一下。
○ 省略的静态初始化的格式。
数据类型[] 数组名称 = {元素1,元素2,...};
◐ 注意事项:
○ 01.静态初始化没有直接指定长度,但是仍然会自动推算得到长度。
○ 02.静态初始化标准格式可以拆分成为两个步骤。
○ 03.动态初始化也可以拆分成为两个步骤。
○ 04.静态初始化一旦使用省略格式,就不能拆分成为两个步骤了。
◐ 使用建议:
○ 如果不确定数组当中的具体内容,用动态初始化;已经确定了具体的内容,用静态初始化。
public class arrayText2 {
public static void main(String[] args) {
//省略格式的静态初始化
int[] arrayA = {10,20,30};
//静态初始化的标准格式,可以拆分成为两个步骤
int[] arrayB;
arrayB = new int[]{11,21,31};
//动态初始化也可以拆分成为两个步骤
int[] arrayC;
arrayC = new int[5];
}
}
■ 访问数组元素进行获取
◐ 索引
○ 索引(index):也叫下标,脚标,是数组元素距离数组起始位置的偏移量,第一个元素的偏移量为
0,所以元素的索引是从0开始的。
◐ 格式:
○ 索引值:就是一个int数字,代表数组当中元素的编号。
数组名[索引值]
◐ 注意:
○ 索引值从0开始,一直到“数组的长度-1”为止。
public class arrayText3 {
public static void main(String[] args) {
//静态初始化的省略格式
int[] array = {10,20,30};
System.out.println(array);//[I@75412c2f — (地址值)
//直接打印数组当中的元素
System.out.println(array[0]);//10
System.out.println(array[1]);//20
System.out.println(array[2]);//30
System.out.println("==================");
//也可以将数组当中的某一个单个元素,赋值交给变量
int num = array[1];
System.out.println(num);//20
}
}
■ 访问数组元素进行赋值
◐ 使用动态初始化数组的时候,其中的元素将会自动拥有一个默认值。规则如下:
○ 如果是整数类型,那么默认为0;
○ 如果是浮点类型,那么默认为0.0;
○ 如果是字符类型,那么默认为‘\u0000’;
○ 如果是布尔类型,那么默认为false;
○ 如果是引用类型,那么默认为null;
public class arrayText3 {
public static void main(String[] args) {
//动态初始化一个数组
int[] array = new int[3];
System.out.println(array);//内存地址值
System.out.println(array[0]);//0
System.out.println(array[1]);//0
System.out.println(array[2]);//0
//将数据123赋值交给数组array当中的1号元素
array[1] = 123;
System.out.println(array[0]);//0
System.out.println(array[1]);//123
System.out.println(array[2]);//0
}
}
◐ 注意事项
○ 静态初始化其实也有默认值的过程,只不过系统马上将默认值替换成为了大括号当中的具体数值。
■ 数组在内存中的储存(Java中的内存划分)
■ Java的内存需要划分成为5个部分
◐ 1.栈(Stack):存放的都是方法中的局部变量。方法的运行一定要在栈当中进行。
-------- 局部变量:方法的参数,或者是方法{}内部的变量。
-------- 作用域:一旦超出作用域,立刻从栈内存当中消失。
◐ 2.堆(Heap):凡是new出来的东西,都在堆当中。
-------- 堆内存里面的东西都有一个地址值:16进制。
-------- 堆内存里面的数据,都有默认值。规则:
-------- 如果是整数 ——— 默认为0
-------- 如果是浮点数 —— 默认为0.0
-------- 如果是字符 ——— 默认为’\u0000’
-------- 如果是布尔类型 — 默认为false
-------- 如果是引用类型 — 默认为null
◐ 3.方法区(Method Area):存储.class相关信息,包含方法的信息。
◐ 4.本地方法栈(Native Method Stack):与操作系统相关。
◐ 5.寄存器(pc Register):与CPU相关。
■ 一个数组的内存图
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr);//[I@5f150435
}
○ 以上方法执行,输出的结果是[I@5f150435,这个是什么呢?是数组在内存中的地址。new出来的内容,都是在堆内存中存储的,而方法中的变量arr保存的是数组的地址。
○ 输出arr[0],就会输出arr保存的内存地址中数组中0索引上的元素。
■ 两个数组的内存图
public static void main(String[] args) {
int[] arr = new int[3];
int[] arr2 = new int[2];
System.out.println(arr);
System.out.println(arr2);
}
■ 两个变量指向一个数组
public static void main(String[] args) {
// 定义数组,存储3个元素
int[] arr = new int[3];
//数组索引进行赋值
arr[0] = 5;
arr[1] = 6;
arr[2] = 7;
//输出3个索引上的元素值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//定义数组变量arr2,将arr的地址赋值给arr2
int[] arr2 = arr;
arr2[1] = 9;
System.out.println(arr[1]);
}
■ 数组的常见问题
■ 数组越界异常
○ 数组的索引编号从0开始,一直到“数组的长度-1”为止。
○ 如果访问数组元素的时候,索引编号并不存在,那么将会发生数组索引越界异常(ArrayIndexOutOfBoundsException)。
○ 原因:索引编号写错了。
○ 解决:修改成为存在的正确索引编号。
public class arrayText4 {
public static void main(String[] args) {
int[] array = {15,25,35};
System.out.println(array[0]);//0
System.out.println(array[1]);//0
System.out.println(array[2]);//0
//错误写法
//并不存在3号元素,所以发生异常
System.out.println(array[3]);//0
}
}
○ 创建数组,赋值3个元素,数组的索引就是0,1,2,没有3索引,因此我们不能访问数组中不存在的索引,程序运行后,将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中,数组的越界异常是不能出现的,一旦出现了,就必须要修改我们编写的代码。
■ 数组空指针异常
○ 所有的引用类型变量,都可以赋值为一个null值。代表其中什么都没有。
○ 数组必须进行new初始化才能使用其中的元素。
○ 如果只是赋值了一个null,没有进行new创建。
○ 那么将会发生:空指针异常(NullPointerException)。
○ 原因:忘了new。
○ 解决:补上new。
public class arrayText5 {
public static void main(String[] args) {
int[] array = null;
//array = new int[3];
System.out.println(array[0]);
}
}
○ arr = null 这行代码,意味着变量arr将不会在保存数组的内存地址,也就不允许再操作数组了,因此运行的时候会抛出 NullPointerException 空指针异常。在开发中,数组的越界异常是不能出现的,一旦出现了,就必须要修改我们编写的代码。
◐ 空指针异常在内存图中的表现
■ 获取数组的长度
◐ 格式:
数组名.length
○ 这将会得到一个int数字,代表数组的长度。
○ 数组一旦创建,程序运行期间,长度不可改变。
■ 获取数组的索引
◐ 格式:
数组名.length-1
○ 索引(index):也叫下标,脚标,是数组元素距离数组起始位置的偏移量,第一个元素的偏移量为0,所以元素的索引是从0开始的。
■ 数组遍历
○ 数组遍历: 就是将数组中的每个元素分别获取出来,就是遍历。遍历也是数组操作中的基石。
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
}
○ 以上代码是可以将数组中每个元素全部遍历出来,但是如果数组元素非常多,这种写法肯定是不行的,因此我们需要改造成循环的写法。数组的索引是 0 到 length-1 ,可以作为循环的条件出现。
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
■ 数组获取最大元素值
○ 最大值获取:从数组的所有元素中找到最大值。
◐ 实现思路:
○ 定义变量,保存数组 0 索引上的元素。
○ 遍历数组,或去除数组中的每个元素。
○ 将遍历到的元素和保存数组 0 索引上值得变量进行比较。
○ 如果数组元素的值大于了变量的值,变量记录住新的值。
○ 数组循环遍历结束,变量保存的就是数组中的最大值。
public static void main(String[] args) {
int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
//定义变量,保存数组中0索引的元素
int max = arr[0];
//遍历数组,取出每个元素
for (int i = 0; i < arr.length; i++) {
//遍历到的元素和变量max比较
//如果数组元素大于max
if (arr[i] > max) {
//max记录住大值
max = arr[i];
}
}
System.out.println("数组最大值是: " + max);
}
■ 数组反转
○ 数组的反转:数组中的元素颠倒顺序,例如原始数组为 {1,2,3,4,5},反转后的数组为{5,4,3,2,1}。
◐ 实现思路:
○ 实现反转,就需要将数组最远端的元素位置交换。
○ 定义两个变量,保存数组中的最小索引和最大索引。
○ 两个索引上的元素交换位置。
○ 最小索引 ++ ,最大索引 - - ,在此交换位置。
○ 最小索引超过了最大索引,数组的反转操作结束。
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
/*
循环中定义变量min=0最小索引
max=arr.length-1最大索引
min++,max--
*/
for (int min = 0, max = arr.length - 1; min <= max; min++, max--) {
//利用第三方变量完成数组中的元素交换
int temp = arr[min];
arr[min] = arr[max];
arr[max] = temp;
}
// 反转后,遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
■ 数组作为方法参数和返回值
■ 数组作为方法参数
○ 数组作为方法的参数,传递进去的是数组的地址值。
○ 当调用方法的时候,向方法的小括号进行传参,传递进去的其实是数组的地址值。
public static void main(String[] args) {
int[] arr = { 1, 3, 5, 7, 9 };
//调用方法,传递数组
printArray(arr);
}
/*
创建方法,方法接收数组类型的参数
进行数组的遍历
*/
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
■ 数组作为方法返回值
○ 任何数据类型都能作为方法的参数类型,或者返回值类型。
○ 数组作为方法的返回值,返回的是数组的地址值。
public static void main(String[] args) {
//调用方法,接收数组的返回值
//接收到的是数组的内存地址
int[] arr = getArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
/*
创建方法,返回值是数组类型
return返回数组的地址
*/
public static int[] getArray() {
int[] arr = { 1, 3, 5, 7, 9 };
//返回数组的地址,返回到调用者
return arr;
}
■ 方法的参数类型区别
◐ 代码分析
○ 分析下列程序代码,计算输出结果。
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(a);
System.out.println(b);
change(a, b);
System.out.println(a);
System.out.println(b);
}
public static void change(int a, int b) {
a = a + b;
b = b + a;
}
○ 分析下列程序代码,计算输出结果。
public static void main(String[] args) {
int[] arr = {1,3,5};
System.out.println(arr[0]);
change(arr);
System.out.println(arr[0]);
}
public static void change(int[] arr) {
arr[0] = 200;
}
◐ 总结
○ 方法的参数为基本类型时,传递的是数据值。
○ 方法的参数为引用类型是,传递的是地址值。