上一篇是分享的是《Java异常简介与Java异常处理》，这篇分享的是《Java数组的定义、Java访问数组元素、Java数组元素的遍历、Java数组的静态初始化、Java数组引用数据类型、Java可变长参数、Java数组扩容、Java数组的特点、Java对象数组、Java二维数组》。

Java数组的定义

定义数组的语法:

数据类型 [] 数组名 = new 数据类型[数组长度];

也可以:

数据类型 数组名[] = new 数据类型[数组长度];

如, 定义一个可以存储5个int类型数据的数组:

int [] data = new int[5];

说明:

● data是一个数组名, 其实就是一个变量名, 数组是Java的一种引用数据类型, data数组名中存储的是数组的引用(起始地址)。

● int是指数组中存储元素的数据类型, int[]是一种数组类型, 即data变量的数据类型是 int[]。

● new运算符在堆区分配一块连续的存储空间, 这块连续的存储空间可以容纳5个int类型的数据, 把这块存储空间的引用保存到data数组名中。

再如, 定义一个数组,存储10个double类型的数据：

double [] data2 = new double[10];

Java访问数组元素

长度为5个数组, 最大下标是: 4

为什么通过索引值可以访问到数组的元素？

Java数组元素的遍历

package com.wkcto.chapter03.demo01;
import java.util.Arrays;
/**
 * 数组的定义,元素的访问与遍历
 *
 */
public class Test01 {
	public static void main(String[] args) {
		//1) 定义一个数组,存储5个int类型数据
		int [] data = new int[5];
		//定义数组,存储10个double类型数据
		double [] data2 = new double[10];
		//定义数组, 存储8个String字符串
		String[] data3  = new String[8];		
		//2) 给数组元素赋值, 通过索引值访问每个元素
		data[0] = 123;
		data[1] = 123;
		data[2] = 123;
		data[3] = 123;
		data[4] = 123;
		//3) 注意, 数组下标(索引值)不能越界
//		data[5] = 123;  	//java.lang.ArrayIndexOutOfBoundsException: 5  数组索引值越界异常		
		//4) 打印data数组每个元素的值
		/*System.out.println( data[0] );
		System.out.println( data[1] );
		System.out.println( data[2] );
		System.out.println( data[3] );
		System.out.println( data[4] );*/
		//数组有一个length属性,表示数组的长度
		for( int i = 0 ; i < data.length ;  i++){
			System.out.println( data[i] );
		}		
		//5)遍历数组元素时, 还可以使用增强的for循环,也称foreach循环
		for (int xx : data) {
			//依次把数组中的每个元素赋值给局部变量xx
			System.out.print( xx + "\t");
		}
		System.out.println();		
		//6)在输出数组的每个元素时,还可以调用Arrays工具类的toString()方法, 可以把数组的元素转换为字符串
		System.out.println( Arrays.toString(data));		
	}
}

Java数组的静态初始化

package com.wkcto.chapter03.demo01;
import java.util.Arrays;
/**
 * 数组的静态初始化 
 *
 */
public class Test02 {
	public static void main(String[] args) {
		//定义数组
		int [] data = new int[8];
		//给数组元素赋值
		data[2]	 = 666;
		//遍历数组的元素
		for(int i = 0 ;  i<data.length; i++){
			System.out.print( data[i] + "\t");
		}
		System.out.println( );
		/*
		 * 1) 创建了数组后, 系统会给数组进行默认的初始化
		 * 	整数数组,把所有元素默认初始化为0
		 * 	小数数组,把所有元素默认初始化为0.0
		 * 	字符数组,把所有元素默认初始化为码值为0的字符, '\u0000'
		 * 	布尔数组,把所有元素默认初始化为false
		 * 	引用数组,把所有元素默认初始化为null
		 */		
		//2)在创建数组的同时,可以给数组的元素赋出值, 这叫数组的静态初始化
		//在数组静态初始化时, 不需要指定数组的长度, 数组的长度由初始化元素的个数决定
		int [] mydata = new int[]{3,6,9,8};
		System.out.println( mydata.length );  		//4
		//数组的静态初始化,可以简化为:
		int [] mydata2 = {1,4,7};
		for (int xx : mydata2) {
			System.out.print( xx + "\t");
		}
		System.out.println( );		
		//3)数组名之间的相互赋值
		data = mydata; 		//把mydata的值赋值给data, mydata存储的是一个数组的引用, 现在mydata和data引用了同一个数组
		System.out.println( Arrays.toString(data )); 		//[3, 6, 9, 8]
		data[0] = 88;
		System.out.println( Arrays.toString(mydata));   	//[88, 6, 9, 8]		
		//4) 给数组重新赋值
		data = new int[] {6,6,6}; 		//data指向 了新的数组
		System.out.println( Arrays.toString(data ));
//		data = {8,8,8}; 		//简化的静态初始化,仅用于数组的静态初始化,不能用于数组的赋值	
	}
}

Java数组引用数据类型

package com.wkcto.chapter03.demo01;
import java.util.Arrays;
/**
 * 数组作为方法的返回值类型,参数类型
 *
 */
public class Test03 {
	public static void main(String[] args) {
		int [] mydata = getData();
		System.out.println( Arrays.toString(mydata));		
		//在方法体中修改了形参数组的元素, 实际上也是修改实参数组的元素值
		swap(mydata, 0, 5);
		System.out.println( Arrays.toString(mydata));		
		//在方法体中对形参数组重新赋值,形参数组指向新的数组,不再指向实参数组
		newData(mydata);
		System.out.println( Arrays.toString(mydata));	
	}	
	//定义方法,实现对数组的重新赋值
	private static void newData(int[] data) {
		data = new int[]{6,6,6};
	}
	//定义方法,实现数组指定两个元素的交换, 交换data[i]和data[j]这两个元素
	public static void swap(int [] data, int i , int j) {
		int t = data[i];
		data[i] = data[j];
		data[j] = t;
	}
	//定义方法,返回一个长度为10的int类型数组, 对数组进行随机的初始化
	public static int[] getData() {
		int [] data = new int[10];
		//给数组的每个 元素赋值
		for(int i = 0; i<data.length; i++){
			int xxx = (int) (Math.random()*100);
			data[i] = xxx;
		}
		return data;
	}	
}

main方法的参数

package com.wkcto.chapter03.demo01;
/**
 * main方法的参数:		String[] args 
 * 	1)是一个存储字符串的数组
 * 	2)main方法的参数可以用来在开始运行程序时, 接收一些初始化的数据
 * 	3) 如何给main方法传递参数?
 * 		run菜单--> run configurations菜单项, 在arguments选项卡的Program Arguements文本框中输入main方法的参数
 *
 */
public class Test04 {
	public static void main(String[] args) {
		System.out.println( args.length );
		for (String string : args) {
			System.out.println( string );
		}
	}
}

Java可变长参数

package com.wkcto.chapter03.demo01;
/**
 * 可变长参数
 * 	1) 可变长参数用来接收任意个数据
 * 	2) 定义可变长参数
 * 		方法名( 参数类型   参数名,  参数类型  ... 可变长参数名)
 * 		说明:
 * 			1) 可变长参数最多只能有一个
 * 			2) 方法参数列表如果有多个参数, 可变长参数只能放在参数列表的最后
 * 			3) 在方法体中, 可以把可变长参数当作数组使用
 * 			4) 在调用方法时,可以传递任意个数, 也可以传递一个数组
 * 
 *
 */
public class Test05 {
	public static void main(String[] args) {
		//在调用方法时,可以传递任意个数, 也可以传递一个数组
		sum();
		sum(1);
		sum(1,2,3,4,5);
		int [] data = {6,6,6,6};
		sum(data);
	}	
	//定义方法, 打印任意个整数的和
	public static void sum(int ... num  ) {
		int result =  0;
		// 可以把可变长参数当作数组使用
		for( int i = 0 ;  i<num.length; i++){
			result += num[i];
		}
		System.out.println("sum==" + result);
	}
}

Java数组扩容

package com.wkcto.chapter03.demo01;
import java.util.Arrays;
/**
 * 数组扩容
 *
 */
public class Test06 {
	public static void main(String[] args) {
//		m1(); 		//完全手动扩容
//		m2(); 		//数组复制调用 了System.arraycopy(0方法
		m3();		//调用  Arrays.copyOf(0实现扩容
	}
	private static void m3() {
		// 定义长度为5的数组
		int[] data = { 1, 2, 3, 4, 5 };
		// 想要在数组中存储更多的数据,需要对数组扩容
		//Arrays工具类copyOf(源数组, 新数组的长度) 可以实现数组的扩容
		data = Arrays.copyOf(data, data.length*3/2);		
		System.out.println( Arrays.toString(data));
	}
	private static void m2() {
		//定义长度为5的数组
		int [] data = {1,2,3,4,5};		
		//想要在数组中存储更多的数据,需要对数组扩容		
		//(1) 定义一个更大的数组
		int [] newData = new int[data.length * 3 / 2] ;		//按1.5倍大小扩容
		//(2)把原来数组的内容复制到新数组中
		//把src数组从srcPos开始的length个元素复制到dest数组的destPos开始的位置
//		System.arraycopy(src, srcPos, dest, destPos, length);
		System.arraycopy(data, 0, newData, 0, data.length);
		//arraycopy()方法使用了native修饰,没有方法体, 该方法的方法体可能是由C/C++实现的
		//JNI,Java native Interface技术,可以在Java语言中调用其他语言编写的代码		
		//(3) 让原来的数组名指向新的数组
		data = newData;		
		//
		System.out.println( Arrays.toString(data));
	}
	private static void m1() {
		//1)定义长度为5的数组
		int [] data = {1,2,3,4,5};		
		//2)想要在数组中存储更多的数据,需要对数组扩容		
		//(1) 定义一个更大的数组
		int [] newData = new int[data.length * 3 / 2] ;		//按1.5倍大小扩容
		//(2)把原来数组的内容复制到新数组中
		for( int i = 0 ; i < data.length; i++){
			newData[i] = data[i];
		}
		//(3) 让原来的数组名指向新的数组
		data = newData;		
		//
		System.out.println( Arrays.toString(data));
	}
}

Java数组的特点

应用场景：适用于以查询访问为主, 很少进行插入/删除操作的情况。

package com.wkcto.chapter03.demo01;
import java.util.Arrays;
/**
 * 在数组中插入元素
 *
 */
public class Test07 {
	public static void main(String[] args) {
		int [] data = {1,2,3,4,5,6,7};		
		//在data数组,索引值为3的位置插入元素666
		data = insert( data, 3 , 666);
		System.out.println( Arrays.toString(data));  //[1,2,3,666,4,5,6,7]
	}
	//定义方法, 在数组的指定i位置添加一个元素key
	public static int[] insert( int [] myArray, int i, int key) {
		//1)定义更大的数组
		int[] newData = new int[myArray.length+1];		
		//2) 把[0,i)范围的元素复制到新的数组中
		for(int j = 0 ; j < i ; j++){
			newData[j] = myArray[j];
		}		
		//3) 把key元素存储到新数组的i位置
		newData[i] = key;		
		//4) 把原数组[i,lenth)范围的元素复制到新的数组的[i+1, length+1)
		for( int j = i ;  j<myArray.length; j++){
			newData[j+1] = myArray[j];
		}		
//		//5) 让原来的数组名指向新的数组
//		myArray = newData;
//		System.out.println( Arrays.toString(myArray));
		//5)返回新的数组
		return newData;
	}
}

//定义方法,删除数组指定位置的元素, 把myArray[i]元素删除
	public static int[] delete(int [] myArray, int i) {
		//1)定义更少的数组
		int [] newData = new int[myArray.length-1];
		//2) 把[0,i)范围 元素复制到新数组中
		System.arraycopy(myArray, 0, newData, 0, i);
		//3) 把[i+1, length)范围的元素复制到新数组[i,lenth-1)
		for( int j = i+1; j < myArray.length; j++){
			newData[j-1] = myArray[j];
		}
		//4) 返回新的数组
		return newData;
	}

Java对象数组

package com.wkcto.chapter03.demo01;
/**
 * 对象数组
 * 	数组元素是一个对象, 数组中存储的是引用类型数据
 * 	数组元素实际上存储的是对象的引用
 * 	遍历对象数组,访问对象的实例成员时, 注意避免出现空指针异常
 *
 */
public class Test08 {
	public static void main(String[] args) {
		//定义数组,存储5个Person对象
		Person[] personss = new Person[5];		
		//给数组的元素赋值, 实际上是把对象的引用保存到数组元素中
		Person lisi = new Person("lisi", 18);
		personss[0] = lisi;
		personss[2] = new Person("feifei", 28);		
		//遍历数组,输出每个元素
		for( int i = 0 ; i<personss.length; i++){
			System.out.println( personss[i] );
		}		
		//让数组中的所有人吃饭, 遍历数组中的Person对象, 调用eat()
		for (Person person : personss) {
			if ( person != null ) {				
				person.eat();
			}
		}		
	}
}
class Person{
	String name;
	int age;	
	//吃饭
	public void eat() {
		System.out.println(name + "正在吃饭....");
	}	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}	
}

Java二维数组

package com.wkcto.chapter03.demo01;
import java.util.Arrays;
/**
 * 二维数组
 * 		数组的每个元素是一个一维数组, 即一维数组的数组
 * 		
 *
 */
public class Test09 {
	public static void main(String[] args) {
		int [] data1 = {1,2,3,4,5};
		int [] data2 = {6,7,8};
		int x = 10;
		int y = 20;
		int [] data3 = {x, y};
		/*
		 * data1/data2/data3是三个数组名, 其实就是一个变量名, 它的数据类型是 int[] 类型
		 * []表示data1/data2/data3是数组, []前面的int表示数组元素的类型
		 * 数据类型[]  数组名  = new 类型[长度] 
		 */		
		//定义一个数组, 数组中存储data1, data2, data3这三个变量
		int[] [] mydata = {data1, data2, data3};
		//mydata是一个数组名, mydata前面的一个[]表示数组, []前面的int[]表示mydata数组中的元素类型	
		System.out.println( mydata.length ); 		//3		
		//遍历mydata数组中存储的整数
		for( int i = 0 ;  i<mydata.length; i++){
			//mydata[0]是 data1, mydata[i]是一个一维数组名
//			System.out.println( mydata[i] );
			for( int j = 0 ;  j < mydata[i].length ; j++){
				System.out.print( mydata[i][j] + "\t" );
			}
			System.out.println();
		}		
		//foreach遍历
		for (int[] is : mydata) {
			for (int xx : is) {
				System.out.print( xx + "\t");
			}
			System.out.println();
		}		
		//Arrays.deepToString()可以把多维数组中的元素转换为字符串
		System.out.println( Arrays.deepToString(mydata));
	}
}

package com.wkcto.chapter03.demo01;
import java.util.Arrays;
/**
 * 二维数组的动态初始化及静态初始化
 *
 */
public class Test10 {
	public static void main(String[] args) {
		//1)二维数组的动态初始化
		//定义一个长度为5的二维数组
		int[][] mydata = new int[5][];		
		//2)给二维数组的元素赋值, 二维数组的每个元素是一个一维数组
		//二维数组元素中存储的内容是一维数组的引用
		mydata[0] = new int[5];
		mydata[1] = new int[]{1,3,5};
		int [] data = {2,5,8};
		mydata[2] = data;
		//mydata[3]和mydata[4]默认初始化为null		
		//3)遍历二维数组
		for(int i = 0 ;  i<mydata.length; i++){
			//判断mydata[i]这个一维数组是否为null
			for( int j = 0 ; mydata[i] != null && j < mydata[i].length; j++){
				System.out.print( mydata[i][j] + "\t");
			}
			System.out.println();
		}		
		//4)在定义二维数组同时,可以指定一维数组的长度,系统会给一维 数组默认初始化
		int[][] mydata2 =  new int[5][4]; 	//二维数组的长度是5, 它的元素是一个长度为4的一维数组
		//遍历
		for (int[] is : mydata2) {
			for (int xx : is) {
				System.out.print( xx + "\t");
			}
			System.out.println();
		}		
		//5)mydata2二维数组的每个元素存储的是一维数组的引用
		mydata2[0] = data;
		mydata2[1] = new int[]{4,5,6,7,8,9};
		System.out.println( Arrays.deepToString(mydata2));		
		//6)二维数组的静态初始化
		int[][]mydata3 = new int[][]{ data , new int[5] , new int[]{1,2,3,4} };
		System.out.println( Arrays.deepToString(mydata3));
		//可以简化为
		int[][] mydata4 = {data, new int[5], new int[]{1,2,3,4}};
		//还可以写为
		int[][] mydata5 = { {1,2,3,4} , {5,6,7} , {8,9}};
		System.out.println( Arrays.deepToString(mydata5));
	}
}

• 上面就是《Java异常简介与Java异常处理》，这篇分享的是《Java数组的定义、Java访问数组元素、Java数组元素的遍历、Java数组的静态初始化、Java数组引用数据类型、Java可变长参数、Java数组扩容、Java数组的特点、Java对象数组、Java二维数组》的分享。
• 也欢迎大家交流探讨，该文章若有不正确的地方，希望大家多多包涵。
• 你们的支持就是我最大的动力，如果对大家有帮忙给个赞哦~~~