目录
数组的定义
数组是相同类型数据的有序集合,其中,每一个数据称为一个元素,每个元素可以通过一个索引(下标)来访问它们,数组的四个基本特点:
1.长度是确定的。数组一旦创建,它的大小是不允许被改变的。
2.其元素的类型必须是相同类型,不允许出现混合类型。
3.数组类型可以是任意数据类型,包括基本数据类型和引用类型。
4.数组变量属于引用类型,数组也是对象,数组中的元素相当于对象中的属性。
创建数组和初始化
数组的声明方式
type[ ] arr_name; //方式一
type arr_name[ ]; //方式二
注意事项:
1.声明时候并没有实例化对象,只有在实例化数组对象时,JVM才分配空间,这时才与长度有关。
2.声明一个数组时候并没有数组真正被创建。
3.构造一个数组,必须指定长度。
【创建一个基本类型的一维数组】
public class Test{
public static void main(String args[]){
int[] s; //声明数组;
s=new int[10]; //给数组分配空间
for(int i=0;i<10;i++){
s[i]=2*i+1; //给数组元素赋值;数组是对象,数组中的元素就是对象的属性
System.out.println(s[i]);
}
}
}
【创建引用类型的一维数组】
class Man{
private int age;
private int id;
public Man(int id,int age){
super();
this.age=age;
this.id=id;
}
}
public class AppMan{
public static void main(String[] args){
Man[] mans; //声明引用数据类型
mans = new Man[10]; //给引用类型数组分配空间
Man m1=new Man(1,11); //使用构造方法创建一个 id为1,age为11的m1对象
Man m2=new Man(2,22);
mans[0]=m1; //给引用类型数组元素赋值
mans[1]=m2;
}
}
数组的初始化
数组的初始化总共有三种:静态初始化、动态初始化、默认初始化。
1.静态初始化
除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值。
int[ ] a={1,2,3}; //静态初始化基本数据类型数组
Man[ ] mans={new Man(1,1),new Man(2,2)}; //静态初始化引用类型数组
2.动态初始化
数组定义与数组元素分配空间并赋值的操作分开进行。
int[ ] a1=new int[2]; //动态初始化数组,先分配空间
a1[0]=1; //给数组元素赋值;
a2[1]=2;
3.数组的默认初始化
数组是对象,它的元素相当于对象的属性;每个元素也按照属性的方式被默认初始化。
int a[ ] =new int[2]; //默认值是0
boolean[ ] b=new boolean[2]; //默认值是false,false
String[ ] s=new String[2]; //默认值是null,null
数组常见操作
数组的遍历
数组元素的下标的合法区间为[0,length-1]。我们可以通过下标来遍历数组中的元素,遍历时可以读取元素或者修改元素的值
for-each循环
for-each循环专门用于读取数组或容器内的所有元素。
public class Test{
public static void main(String[] args){
String[] ss={"aa","bb","cc","dd"};
for(String temp:ss){
System.out.println(temp);
}
}
}
执行结果为: aa
bb
cc
dd
注意事项:
1.for-each增强for循环在遍历数组过程中不能修改数组中某元素的值。
2.for-each仅适用与遍历,不涉及有关索引(下标)的操作。
数组的拷贝
System.arraycopy(object src,int srcops,object dest,int destpos,int length)
该方法可以将src数组里的元素值赋给dest数组的元素,其中srcpos指定从src数组的第几个元素开始赋值,length参数指定将src数组多少个元素赋给dest数组的元素。
java.util.Arrays类
Arrays类包含了:排序、查找、填充、打印内容等常见的数组操作。
打印操作 Arrays.toString()方法
import java.util.Arrays;
public class Test{
public static void main(String args[]){
int[] a={1,2};
System.out.println(a); //打印引用的值
System.out.println(Arrays.toString(a)); //打印数组元素的值
}
}
执行结果:
[I@15db9742
[1,2]
此处的Arrays.toString()方法是Arrays类的静态方法,不是见面讲的Object的toString()方法。
排序操作 Arrays.sort( )方法
二分法查找法 Arrays.binarySearch( )
填充 Arrays.fill( )方法
import java.util.Arrays;
public class Test05 {
public static void main(String[] args) {
int[ ] a = {1,2,323,23,543,12,59};
System.out.println(Arrays.toString(a));
Arrays.sort(a); //使用二分法查找必须要先对数组进行排序(从小到大排序)
System.out.println(Arrays.toString(a));
//返回排序后新的索引位置,若未找到返回负数。
System.out.println("该元素的索引:"+Arrays.binarySearch(a, 120));
int [] b = {10,20,30,40,50};
Arrays.fill(b,2,4,100); //将2到4索引(第三个元素和第四个元素)的元素替换为100
System.out.println(Arrays.toString(b));
}
}
多维数组
多维数组可以看成以数组为元素的数组。
二维数组的声明
import java.util.Arrays;
//测试多维数组的初始化
public class Test06 {
public static void main(String[] args) {
// Java中多维数组的声明和初始化应按从低维到高维的顺序进行
int[ ][ ] a = new int[3][ ];
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3];
// int a1[ ][ ]=new int[ ][4];//非法
}
}
二维数组的静态初始化
import java.util.Arrays;
//测试多维数组的初始化
public class Test06 {
public static void main(String[] args) {
// Java中多维数组的声明和初始化应按从低维到高维的顺序进行
int[ ][ ] a = new int[3][ ];
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3];
// int a1[ ][ ]=new int[ ][4];//非法
a[0][0] = 100;
a[0][1] = 200;
int[ ][ ] b = {
{ 1, 2, 3 },
{ 3, 4 },
{ 3, 5, 6, 7 }
};
System.out.println(b[2][3]);
}
}
二维数组的动态初始化
import java.util.Arrays;
//测试多维数组的初始化
public class Test06 {
public static void main(String[] args) {
// Java中多维数组的声明和初始化应按从低维到高维的顺序进行
int[ ][ ] a = new int[3][ ];
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3];
// int a1[ ][ ]=new int[ ][4];//非法
a[0][0] = 100;
a[0][1] = 200;
int[ ][ ] b = {
{ 1, 2, 3 },
{ 3, 4 },
{ 3, 5, 6, 7 }
};
System.out.println(b[2][3]);
int[ ][ ] c = new int[3][ ];
// c[0] = {1,2,5}; //错误,没有声明类型就初始化
c[0] = new int[ ] { 1, 2 };
c[1] = new int[ ] { 2, 2 };
c[2] = new int[ ] { 2, 2, 3, 4 };
System.out.println(c[2][3]);
System.out.println(Arrays.toString(c[0]));
System.out.println(Arrays.toString(c[1]));
System.out.println(Arrays.toString(c[2]));
}
}
Comparable接口
Comparable接口只有一个方法:
public int compareTo(object obj) //obj为要比较的对象
方法中,当前对象和obj这个对象进行比较,如果大于返回1,等于返回0,小于返回-1
import java.util.Arrays;
//测试Comparable接口
public class Test09 {
public static void main(String[] args) {
Man2[ ] msMans = {
new Man2(3, "a"),
new Man2(60, "b"),
new Man2(2, "c") };
System.out.println(Arrays.toString(msMans));
Arrays.sort(msMans);
//调用sort方法对数组元素是对象的数组排序,它所在的类型(Man)必须实现Comparable接口,上面对int类型元素排序不需要实现Comparable接口
System.out.println(Arrays.toString(msMans));
}
}
class Man2 implements Comparable {
int age;
int id;
String name;
public Man2(int age, String name) {
super();
this.age = age;
this.name = name;
}
public String toString() {
return this.name;
}
public int compareTo(Object o) {
Man2 man2 = (Man2) o;
if (this.age < man2.age) {
return -1;
}
if (this.age > man2.age) {
return 1;
}
return 0;
}
}