目录
一、数组定义和访问
1.容器概述
容器:是将多个数据存储到一起,每个数据称为该容器的元素。
生活中的容器:水杯,衣柜,教室。
2.数组概念
数组概念: 数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致。
3.数组的定义
(1)方式一
格式: 数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
数组定义格式详解:
数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
[] : 表示数组。
数组名字:为定义的数组起个变量名,满足标识符规范,可以使用名字操作数组。
new:关键字,创建数组使用的关键字。
数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
[长度]:数组的长度,表示数组容器中可以存储多少个元素。
注意:数组有定长特性,长度一旦指定,不可更改。
/*
数组概念: 就是一个容器,可以同时存放多个数据值.
数组的特点:
1.数组是一种引用数据类型.
2.数组中的多个数据,类型必须要统一.
3.数组的长度在程序运行期间是不可改变的.
数组初始化: 是在内存中创建一个数组,并且向其中赋予一些默认的值.
两种常见的初始化方式:
1.动态初始化(指定长度)
2.静态初始化(指定内容)
动态初始化数组格式:
数据类型[] 数组名称 = new 数据类型[数组的长度];
解析含义:
左侧定义的是数据类型,也就是说数组中保存的数据,全都是统一的类型.
左侧的中括号: 代表我是一个数组;
左侧的数组名称: 给数组取一个名字.
右侧的 new : 代表创建数组的动作
右侧数据类型: 必须和左侧的数据类型保持一致.
右侧中括号的长度: 也就是数组当中,到底可以保存多少个数据,是一个int数字.
*/
public class Test {
public static void main(String[] args) {
//创建一个数组,里面可以存放300个int数据
int[] arryA = new int[300];
//创建一个数组,能存放10个double类型的数据
double[] arryB = new double[10];
//创建一个数组,能存放5个字符串
String[] arryC = new String[5];
}
}
(2)方式二
格式: 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
/*
动态初始化(指定长度): 在创建数组的时候,直接指定数组的数据元素个数
静态初始化(指定内容): 在创建数组的时候,不直接指定数据的个数多少,而是直接将具体的数据内容指定.
静态初始化基本格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,........};
注意事项:
虽然静态初始化没有直接告诉长度,但是根据大括号中的元素具体内容,也可以推断出来长度
*/
public class Test {
public static void main(String[] args) {
//直接创建一个数组,里面全部装的都是int数据, 分别是 5, 15, 20
int[] arrayA = new int[]{5,15,20};
//创建一个数组,用来给他转一个字符串: "Hello", "World", "Java";
String[] arrayB = new String[]{"Hello","World","Java"};
}
}
(3) 方式三
格式: 数据类型[] 数组名 = {元素1,元素2,元素3...};
/*
使用静态初始化数组的时候,格式可以省略一下
标准格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,......}
省略格式:
数据类型[] 数组名称 = {元素1,元素2,......}
注意事项:
1.静态初始化没有指定长度,但是会自动推算得到长度.
2.静态初始化的标准格式, 也可以拆分成两个步骤
3.动态初始化也可以拆分成两个步骤
4.静态初始化的省略格式,不能拆分成为两个步骤
使用建议:
如果不确定数组中的具体内容的时候,用动态初始化,否则,已经确定了具体内容,用静态的初始化.
*/
public class Test {
public static void main(String[] args) {
//省略格式的静态初始
int[] arrayA = {1,5,8};
//静态初始化的标准格式, 也可以拆分成两个步骤
int[] arrayB;
arrayB = new int[]{657,23,19};
//动态初始化,也可以拆分成两个步骤
int[] arrayC;
arrayC = new int[5];
//静态初始化的省略格式,不能拆分成为两个步骤
/* int[] arrayD;
arrayD = {1,2,6};*/
}
}
4.数组的访问
(1)索引
每一个存储到数组的元素,都会自动的拥有一个编号,从0开始,这个自动编号称为数组索引
(index),可以通过数组的索引访问到数组中的元素。
(2)格式
数组名[索引]
(3)数组的长度属性
每个数组都具有长度,而且是固定的,Java中赋予了数组的一个属性,可以获取到数组的长度,语句为: 数组名.length ,属性length的执行结果是数组的长度,int类型结果。由次可以推断出,数组的最大索引值为 数组名.length-1 。
/*
直接打印数组名称,得到的是数组对相应的内存地址哈希值.
访问数组元素的格式: 数组名称[索引值]
索引值: 就是一个int数字, 代表数组中的元素的编号
[注意] : 索引值从0开始,一直到"数组的长度-1"为止
*/
public class Test {
public static void main(String[] args) {
//静态的省略方式初始化数组
int[] array= {10,20,30};
System.out.println(array);//[I@50cbc42f
//直接打印数组中的元素
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);
}
}
(4) 索引访问数组中的元素
a.数组名[索引]=数值,为数组中的元素赋值
b.变量=数组名[索引],获取出数组中的元素
/*
使用动态初始化数组的时候,其中的元素会自动拥有一个默认值,规格如下:
如果是整数类型, 那么默认值就是 0
如果是浮点类型,那么默认是 0.0
如果是字符类型, 那么默认的是'\u0000',
如果是boolean类型, 默认值是false
如果是引用数据类型, 默认值就是 null;
注意事项:
静态初始化其实也是默认值的过程,只不过系统自动马上将默认值替换成为大括号中的具体数值.
*/
public class Test {
public static void main(String[] args) {
//静态的省略方式初始化数组
int[] array= new int[3];
System.out.println(array);//[I@50cbc42f
//直接打印数组中的元素
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println("===============");
//将数据119赋值交给数组 array中的1号元素.
array[1] = 119;
System.out.println(array[0]);//0
System.out.println(array[1]);//119
System.out.println(array[2]);//0
char[] a = new char[10];
System.out.println(a[1]);
}
}
二、数组原理内存图
1.内存概述
内存是计算机中的重要原件,临时存储区域,作用是运行程序。我们编写的程序是存放在硬盘中的,在硬盘中的程序是不会运行的,必须放进内存中才能运行,运行完毕后会清空内存。Java虚拟机要运行程序,必须要对内存进行空间的分配和管理。
2.Java虚拟机的内存划分
为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。
JVM的内存划分:
区域名称 | 作用 |
寄存器 | 给CPU使用,和我们开发无关。 |
本地方法栈 | IM在使用操作系统功能的时候使用,和我们开发无关。 |
方法区 | 存储可以运行的class文件。 |
堆内存 | 存储对象或者数组,new来创建的,都存储在堆内存。 |
方法栈 | 方法运行时使用的内存,比如main方法运行,进入方法栈中执行。 |
3.数组在内存中的存储
(1)一个数组内存图
public class Test {
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
System.out.println("============");
//通过索引值,改变内容
array[1] = 10;
array[2] = 20;
System.out.println(array); //内存地址
System.out.println(array[0]);//0
System.out.println(array[1]);//10
System.out.println(array[2]);//20
}
}
输出arr[0],就会输出arr保存的内存地址中数组中0索引上的元素 。
(2)两个数组内存图
public class Test {
public static void main(String[] args) {
int[] arrayA = new int[3];// 动态初始化
System.out.println(arrayA); //内存地址
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//0
System.out.println(arrayA[2]);//0
System.out.println("====");
//通过索引值,改变内容
arrayA[1] = 10;
arrayA[2] = 20;
System.out.println(arrayA); //内存地址
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//10
System.out.println(arrayA[2]);//20
System.out.println("=========");
int[] arrayB = new int[3];// 动态初始化
System.out.println(arrayB); //内存地址
System.out.println(arrayB[0]);//0
System.out.println(arrayB[1]);//0
System.out.println(arrayB[2]);//0
System.out.println("====");
//通过索引值,改变内容
arrayB[1] = 100;
arrayB[2] = 200;
System.out.println(arrayB); //内存地址
System.out.println(arrayB[0]);//0
System.out.println(arrayB[1]);//100
System.out.println(arrayB[2]);//200
}
}
(3) 两个变量指向一个数组
public class Test {
public static void main(String[] args) {
int[] arrayA = new int[3];// 动态初始化
System.out.println(arrayA); //内存地址
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//0
System.out.println(arrayA[2]);//0
System.out.println("====");
//通过索引值,改变内容
arrayA[1] = 10;
arrayA[2] = 20;
System.out.println(arrayA); //内存地址
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//10
System.out.println(arrayA[2]);//20
System.out.println("=========");
//将arrayA的值直接赋值给arrayB数组
int[] arrayB = arrayA;// 动态初始化
System.out.println(arrayB); //内存地址
System.out.println(arrayB[0]);//0
System.out.println(arrayB[1]);//0
System.out.println(arrayB[2]);//0
System.out.println("====");
//通过索引值,改变内容
arrayB[1] = 100;
arrayB[2] = 200;
System.out.println(arrayB); //内存地址
System.out.println(arrayB[0]);//0
System.out.println(arrayB[1]);//100
System.out.println(arrayB[2]);//200
}
}
三、数组的常见操作
1.数组越界异常
/*
索引下标越界异常, 索引是从0开始, 一直到数组的长度是 -1结束
原因: 索引编号写错了
解决方式: 修改成为正确的索引编号.
*/
public class Test {
public static void main(String[] args) {
int[] array = {15,25,35};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);//.ArrayIndexOutOfBoundsException:
}
}
创建数组,赋值3个元素,数组的索引就是0,1,2,没有3索引,因此我们不能访问数组中不存在的索引,程序运行后,将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中,数组的越界异常是不能出现的,一旦出现了,就必须要修改我们编写的代码。
2.数组空指针异常
/*
所有的引用数据类型变量,都可以赋值给null值,代表其中什么都没有.
数据必须进行new初始化才能使用其中的元素.
如果只赋值一个null,没有进行new创建.
那么将会发生空指针异常:NullPointerException
原因: : 忘记new
解决: 补上 new
*/
public class Test {
public static void main(String[] args) {
int[] array = null;
//array = new int[3];
System.out.println(array[0]);//java.lang.NullPointerException
}
}
arr = null 这行代码,意味着变量arr将不会在保存数组的内存地址,也就不允许再操作数组了,因此运行的时候会抛出 NullPointerException 空指针异常。在开发中,数组的越界异常是不能出现的,一旦出现了,就必须要修 改我们编写的代码。
空指针异常在内存图中的表现
3.数组遍历
数组遍历: 就是将数组中的每个元素分别获取出来,就是遍历。遍历也是数组操作中的基石。
public class Test {
public static void main(String[] args) {
int[] arrayA = new int[3];
arrayA[0] = 100;
arrayA[1] = 200;
System.out.println(arrayA[0]);
System.out.println(arrayA[1]);
System.out.println(arrayA[2]);
int[] arrayB = {10,21,32,234,546,678,123,123,67,78,12,23,45,66};
System.out.println("数组长度"+ arrayB.length);
System.out.println("==============");
int[] arrayC = new int[3];
System.out.println(arrayC.length);//3;
int[] arrayD = new int[5];
System.out.println(arrayD.length);//5;
}
}
以上代码是可以将数组中每个元素全部遍历出来,但是如果数组元素非常多,这种写法肯定不行,因此我们需要改 造成循环的写法。数组的索引是 0 到 lenght-1 ,可以作为循环的条件出现。
public class Test {
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]);
}
}
}
4.数组获取最大值元素
a.最大值获取:从数组的所有元素中找出最大值。
b.实现思路:
定义变量,保存数组0索引上的元素。
遍历数组,获取出数组中的每个元素。
将遍历到的元素和保存数组0索引上值的变量进行比较。
如果数组元素的值大于了变量的值,变量记录住新的值。
数组循环遍历结束,变量保存的就是数组中的最大值。
public class Test {
public static void main(String[] args) {
int[] arr = { 5, 15, 2000, 1000, 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);
}
}
5.数组反转
a.数组的反转: 数组中的元素颠倒顺序,例如原始数组为1,2,3,4,5,反转后的数组为5,4,3,2,1。
b.实现思路:
数组最远端的元素互换位置。
实现反转,就需要将数组最远端元素位置交换。
定义两个变量,保存数组的最小索引和最大索引。
两个索引上的元素交换位置。
最小索引++,最大索引--,再次交换位置。
最小索引超过了最大索引,数组反转操作结束。
public class Test {
public static void main(String[] args) {
int[] array = {10,20,30,40,50};
//遍历输出内容
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("===================");
/*
初始话语句: int min =0 ,max = array.length-1
条件判断: min < max
步进表达式: min++ , max--
在循环体里:用第三方变量进行倒手
*/
for(int min =0 ,max = array.length-1; min < max;min++ , max--){
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
public class Test {
public static void main(String[] args) {
// 初始化一个整数数组
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
//遍历数组,将数组中的元素依次交换
for (int i = 0; i < arr.length / 2; i++) {
// 临时变量用于存储当前元素,以便交换
int temp = arr[i];
// 将当前元素与对应位置的尾部元素交换
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
// 遍历并打印反转后的数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
6.修改数组元素
a.修改数组元素:对于数组的元素进行修改。
public class Test {
public static void main(String[] args) {
//定义数组,存储薪资数组
int[] salaryarr =new int[10];
salaryarr[0]=10000;
//遍历数组,获取数组中的元素
for (int i = 0; i < salaryarr.length; i++) {
System.out.println(salaryarr[i]);
}
System.out.println("=======================");
double[] darr =new double[10];
for (int i = 0; i < darr.length; i++) {
System.out.println(darr[i]);
}
System.out.println("=======================");
String[] sarr =new String[10];
sarr[0]="张三";
for (int i = 0; i < sarr.length; i++) {
System.out.println(sarr[i]);
}
}
}
7.数组排序(冒泡排序)
a.数组排序(冒泡):它通过不断比较相邻的元素,并交换位置来实现排序。
public class Test {
public static void main(String[] args) {
// 初始化一个整数数组
int[] arr = {1, 5, 3, 9, 2, 8, 7, 4, 6};
//遍历数组,将数组中的元素依次交换
for( int i = 0; i < arr.length - 1; i++){
// 内层循环逐渐减少比较的范围
for(int j = 0; j < arr.length - 1 - i; j++){
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
// 遍历并打印排序后的数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
四、数组作为方法参数和返回值
1.数组作为方法参数
数组作为方法参数传递,传递的参数是数组内存的地址。
public class Test {
public static void main(String[] args) {
int[] array = {10,20,30,60,70,40};
System.out.println(array);//内存地址
printArray(array);//传递的参数也是内存地址
System.out.println("aaaaaa");
printArray(array);
System.out.println("bbbbbb");
}
public static void printArray(int[] array){
System.out.println("内存地址是:");
System.out.println(array);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
2.数组作为方法返回值
数组作为方法的返回值,返回的是数组的内存地址。
public class Test {
public static void main(String[] args) {
int[] result = calculate(10,20,30);
//返回数据内存地址值:
System.out.println("调用完方法返回的内存地址值:");
System.out.println(result);
System.out.println("总和:"+ result[0]);
System.out.println("平均值:" + result[1]);
}
public static int[] calculate(int a,int b,int c){
int sum = a + b + c;
int avg = sum/3;
//需要动态初始化一个数组的方式
/* int[] array = new int[2];
array[0] = sum;
array[1] = avg;*/
int[] array = {sum,avg};
System.out.println("方法的内存地址值:");
System.out.println(array);
return array;
}
}
3.方法的参数类型区别
a.下列程序代码,输出结果。
public class Test {
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;
}
}
b.下列程序代码,输出结果。
public class Test {
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;
}
}
c. 总结:方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值。