上一篇是分享的是《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;/**
数组的定义, 元素的拜访与遍历
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 办法的参数能够用来在开始运行程序时, 接管一些初始化的数据
如何给 main 办法传递参数?
*/public class Test04 {public static void main(String[] args) {System.out.println( args.length);for (String string : args) {System.out.println( string);}}}
package com.wkcto.chapter03.demo01;/**
main 办法的参数: String[] args
1)是一个存储字符串的数组
2)main 办法的参数能够用来在开始运行程序时, 接管一些初始化的数据
如何给 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 二维数组》的分享。
也欢送大家交换探讨，该文章若有不正确的中央，心愿大家多多包涵。
你们的反对就是我最大的能源，如果对大家有帮忙给个赞哦~~~