Java基础语法之数组详细介绍【精】
Java基础语法
数组操作的2个异常
数组的索引超过范围异常 (索引越界)
程序中访问了不存在的索引, 每个数组的索引范围从0开始,最大的索引=数组的长度-1
public static void main(String[] args) {
//定义存储int类型的数组
int[] arr = {
1,2,3,4,5};
//数组中存储5个元素,长度是5个
System.out.println(arr.length);
//索引0-4
//访问不存在的索引
System.out.println(arr[5]);
}
数组的空指针异常
当数组的引用类型变量arr不保存数组的地址了,再操作数组,就出现空指针异常
public static void main(String[] args) {
int[] arr = {
1,2,3,4,5};
System.out.println(arr);
arr = null; //数组 = 空 , 不再保存数组在内存中的地址了
//不能操作数组的任何内容
System.out.println(arr.length);
}
数组的内存问题
两个数组在内存中的表现
每个数组,都会在内存中,开辟空间存储数据, 内存之间是相互独立的,没有关联
一个数组就会占用一个内存空间
public static void main(String[] args) {
//定义2个数组
int[] arr1 = new int[]{
1,2,3,4,5};
int[] arr2 = new int[]{
6,7,8,9,0};
//输出数组,看到不同的地址
System.out.println(arr1);
System.out.println(arr2);
System.out.println(arr1[0]);
System.out.println(arr2[0]);
}
多个变量指向同一个内存空间
public static void main(String[] args) {
//定义数组,存储一些元素
int[] arr1 = {
1,2,3,4};
System.out.println(arr1);
//将数组arr1的内存地址,赋值到另一个变量
int[] arr2 = arr1;
System.out.println(arr2);
System.out.println(arr1[0]);
arr2[0] = 100;
System.out.println(arr1[0]);
}
数组的常见操作
数组的遍历 (迭代)
所谓数组的遍历,就是将数组中的每一个元素分别取出的过程.
数组的遍历,是数组其他操作的一个最基础的案例
循环遍历取出数组的元素,循环的次数由长度决定
public static void main(String[] args) {
int[] arr = {
2,4,6,8,10};
//循环遍历数组,取出数组中的每个元素,依次取出
//数组的长度是5个,索引0-4 for(知道次数) while(不知道次数)
for(int i = 0 ; i < arr.length ; i++) {
//利用循环中的变量i, 作为索引使用,取出数组的元素
System.out.println(arr[i]);
}
}
数组最值获取
取出数组中的最大值,或者是最小值
实现核心思想 : 遍历中进行比较
/*
* 获取数组的最大值
* 实现步骤 :
* 1.定义变量,保存数组0索引上的元素
* 2.遍历数组,取出数组的每个元素
* 3.数组的元素和变量,进行比较
* 如果数组的元素,大于变量
* 数组的元素,存储在变量中
* 4.数组全部遍历完成,变量保存的就是最大值
*/
public class ArrayDemo06 {
public static void main(String[] args) {
//创建数组
int[] arr = {
1,5,10,2,6,9,0,7};
//定义变量,保存数组0索引上的元素
int max = arr[0];
//遍历数组,取出数组的每个元素
for(int i = 1 ; i < arr.length ; i++) {
//数组的元素,和变量max比较
if(arr[i] > max) {
//赋值变量
max = arr[i];
}
}
//数组全部遍历完成,变量保存的就是最大值
System.out.println("最大值是::"+max);
}
}
数组的倒序遍历
public static void main(String[] args) {
int[] arr = {
1,3,5,7,9};
//从数组的最大索引开始遍历
for(int i = arr.length-1 ; i >= 0 ; i--) {
System.out.println(arr[i]);
}
}
数组拼接为字符串
任意数组 : int[] arr = {1,2,3,4,5,6,7}, 遍历数组,取出元素,元素拼接为一个字符串
输出的格式 [1,2,3,4,5,6,7]
/*
* 输出的格式 [1,2,3,4,5,6,7]
* 数组遍历,拼接成上面的格式
* 解决最后一个逗号问题 :
* 判断循环变量 i , 如果i的值,到达了数组的最大索引
* 字符串拼接] ,而不是逗号
*
*/
public class ArrayDemo08 {
public static void main(String[] args) {
//创建数组
int[] arr = {
1,2,3,4,5,6,7};
//遍历,取出元素,字符串的拼接
String s = "[";
for(int i = 0 ; i < arr.length ;i++) {
//判断i是不是最大索引,如果是拼接]
if(i == arr.length - 1) {
s = s + arr[i]+"]";
}else {
s = s + arr[i]+",";
}
}
System.out.println(s);
}
}
数组元素的查找
已知数组 : 在数组中查找一个元素是否存在
元素存在于数组中 : 返回元素所在的索引
元素不存在数组中 : 返回负数
实现功能的核心思想 :
/*
* 数组元素基本查找
* 已知数组 : 在数组中查找一个元素是否存在
元素存在于数组中 : 返回元素所在的索引
元素不存在数组中 : 返回负数
实现功能的核心思想 : 遍历,进行比较
实现思想 :
1. 定义数组
2. 定义要查找的元素
3. 定义变量,保存查找后的结果 (数组的索引,或者是负数)
4: 遍历数组,取出每个元素,和要查找的元素对比
一旦找到,就不会在进行比较了
*/
public class ArrayDemo09 {
public static void main(String[] args) {
//1. 定义数组
int[] arr = {
1,5,6,7,2,3,8};
//2. 定义要查找的元素
int key = 1;
//3. 定义变量,保存查找后的结果 (数组的索引,或者是负数)
int index = -1;
//4: 遍历数组,取出每个元素,和要查找的元素对比
for(int i = 0 ; i < arr.length ; i++) {
//查找的元素 和 数组的元素相等,找到了
if(key == arr[i]) {
//数组的索引,赋值到变量index
index = i;
//不需要再计算了吧,结束循环
break;
}
}
if(index >= 0) {
System.out.println("元素找到了,在"+index+"这个索引");
}else{
System.out.println("抱歉,元素未找到");
}
}
}
数组翻转
所谓数组翻转,就是数组中元素的位置发生了转变 不等于倒序遍历
原始数组 : {1,2,3,4,5}
翻转数据 : {5,4,3,2,1}
/*
* 数组的翻转
*
* 数组最远端的元素换位
*
* 实现思想 :
* 1. 定义2个变量
* 一个变量,保存数组的最小索引
* 一个变量,保存数组的最大索引
*
* 2: 当最小索引,超过最大的索引,程序结束
*
* 3: 利用循环实现
*
* 4: 第三方变量的位置交换
*/
public class ArrayDemo11 {
public static void main(String[] args) {
int[] arr = {
1,2,3,4,5,0};
//一个变量,保存数组的最小索引
//一个变量,保存数组的最大索引
int min = 0;
int max = arr.length - 1;
for(; min <= max ;) {
//第三方变量交换位置
int temp = arr[max]; //临时变量,保存数组的最大索引
//最小索引的元素,赋值到最大索引
arr[max] = arr[min];
//临时变量的值,赋值到小索引上
arr[min] = temp;
//位置交换完毕,修改索引
min++;
max--;
}
//数组遍历
for(int i = 0 ; i < arr.length ; i++) {
System.out.println(arr[i]);
}
}
}
以上程序小的优化
public static void main(String[] args) {
int[] arr = {
1,2,3,4,5,0};
//一个变量,保存数组的最小索引
//一个变量,保存数组的最大索引
/* int min = 0;
int max = arr.length - 1;*/
for(int min = 0 , max = arr.length - 1; min <= max ;min++ ,max--) {
//第三方变量交换位置
int temp = arr[max]; //临时变量,保存数组的最大索引
//最小索引的元素,赋值到最大索引
arr[max] = arr[min];
//临时变量的值,赋值到小索引上
arr[min] = temp;
}
//数组遍历
for(int i = 0 ; i < arr.length ; i++) {
System.out.println(arr[i]);
}
}
二维数组
-
一维数组 : 一个数组,存储的是需要的数据 int[] arr = {123}
-
二维数组 : 一个数组,存储的元素,是另一个数组. 理解为数组中的数组
-
定义方式 :
数据类型[][] array = new 数据类型[3][2]; 格式解析 : 定义了一个二维数组 [3] : 二维数组的长度, 这个二维数组里面存储了3个一维数组 [2] : 每个一维数组的长度是2 -
二维数组中,存储的是一维数组的内存地址
public static void main(String[] args) { /* * 二维数组的长度是3,存储3个一维数组 * 每个一维数组,可以存储2个元素 */ int[][] array = new int[3][2]; System.out.println(array);// [[I@15db9742 //思考? System.out.println(array[0]); // [I@6d06d69c } -
定义方式:
数据类型[][] array = new 数据类型[][]{ } 创建数组直接赋值元素public static void main(String[] args) { int[][] array = new int[][] { { 1,2},{ 3,4,5,6},{ 7,8,9} }; System.out.println(array); //思考, 输出5 System.out.println(array[1][2]); //数组的越界异常 System.out.println(array[2][2]); } -
定义方式:
数据类型[][] array = { };public static void main(String[] args) { int[][] array = { { 1,2,3},{ 4,5},{ 6,7,8,9,0} }; System.out.println(array); }
-
遍历
二维数组的遍历 : 和一维数组遍历几乎是一样的
利用嵌套循环,双for, 外循环,遍历二维数组,内循环,遍历一维数组
public static void main(String[] args) {
int[][] array = {
{
1,2,3},{
4,5},{
6,7,8,9,0} };
//外循环,遍历二维数组,取出里面的3个一维数组
for(int i = 0 ; i < array.length; i++) {
//System.out.println(array[i]);
//内循环,遍历每个一维数组
for(int j = 0; j <array[i].length;j++ ) {
System.out.print(array[i][j]);
}
System.out.println();
}
}