java中的一维数组

最新推荐文章于 2023-10-25 16:54:19 发布

原创最新推荐文章于 2023-10-25 16:54:19 发布 · 357 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #数组

java学习手记专栏收录该内容

27 篇文章

订阅专栏

Java中的一维数组

1.数组的含义
2.创建一维数组
3.深入一维数组
4.一维数组的拷贝

1.数组的含义

package array1;
/*
	数组：
		1.数组是一种引用类型
		2.数组是一种简单的数据结构，线性的结构
		3.数组是一个容器，可以用来存储其他元素
		4.数组是可以存储任意数据类型的元素
		5.数组可以分为：一维数组，二维数组，三维数组，多维数组
		6.数组中存储的元素类型是统一的
		7.数组长度不可改变，数组一旦创建，长度是固定不变的
		8.数组优点：查找效率高；缺点：随意增删元素效率低
 */
public class Test01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//声明一个一维数组，用来存储int类型
		int[] a1 = {100,200,150,300};//这种方式称作“静态初始化一维数组”
		
		//boolean类型的数组
		boolean[] b1 = {true,false,true};
		
		//String类型的数组
		String[] strs = {"AB","CD","EF"};
		
		//byte类型的数组
		byte[] b2 = {'A','B','C'};
		byte[] b3 = {1,2,3};
		
		//char类型的数组
		char[] c1 = {'A','B','C'};
		char[] c2 = {1,2,3};
		
		//Object类型的数组
		Object o1 = new Object();
		Object o2 = new Object();
		Object o3 = new Object();
		Object[] objs = {o1,o2,o3};
		System.out.println(a1[0]+"\n");
		System.out.println(a1[1]);
	}

}

2.创建一维数组

package array1;
/*
	数组中存储元素的类型是统一的，每一个元素在内存中所占的空间大小是相同的，
	知道数组的首元素的内存地址，再知道要查找的元素的下标就可以快速计算出偏移量，
	通过首元素内存地址加上偏移量快速计算出要查找元素的内存地址，通过内存地址快速定位该元素，
	所以数组查找元素的效率较高。
	
	随机的对数组进行增删元素，当增加元素的时候，为了保证数组中元素在空间存储上是有序的，
	所以被添加元素位置后面的所有元素都要向后移动；删除元素同理。所以数组的增删效率较低。
	
	初始化一维数组有两种方式：
		1.静态初始化
		2.动态初始化
			（1）动态初始化一维数组，会先在堆内存中分配这个数组，并且数组中每一个元素都采用默认值
			byte,short,int,long 0
			float double 0.0
			boolean false
			char \u0000
			引用  null
 */
public class Test02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//静态初始化一个int类型的一维数组
		int[] a1 = {10,12,14,16};
		
		//取得第一个元素
		System.out.println("第一个元素："+a1[0]);
		System.out.println("最后一个元素："+a1[a1.length-1]);
		
		//取得个数
		System.out.println("数组中元素的个数："+a1.length);
		
		//遍历一维数组
		for(int i=0;i<a1.length;i++) {
			System.out.println(a1[i]);
		}
		
		//将第二个元素修改成100
		a1[1] = 100;
		System.out.println("----------");
		for(int i=0;i<a1.length;i++) {
			System.out.println(a1[i]);
		}
		
		
		//动态初始化一维数组
		System.out.println("----------");
		
		//动态声明一个int类型数组，最多存储4个元素
		int[] a2 = new int[4];
		
		//遍历一维数组
		for(int i=0;i<a2.length;i++) {
			System.out.println(a2[i]);
		}
		
		//赋值
		a2[0] = 21;
		a2[1] = 22;
		a2[2] = 23;
		a2[3] = 24;
		
		//遍历一维数组
		System.out.println("----------");
		for(int i=0;i<a2.length;i++) {
			System.out.println(a2[i]);
		}
		
		//引用类型的数组
		Object[] objs = new Object[3];
		for(int index=0;index<objs.length;index++) {
			Object o = objs[index];
			//o.toString();//注意空指针异常，因为引用类型的数组默认值是null
			System.out.println(o);//底层写好了
		}
	}

}

package array1;
/*
	什么时候使用动态初始化，什么时候使用静态初始化
		1.无论是动态初始化还是静态初始化，最终的内存分布都是一样的
		2.如果在创建数组的时候，知道数组中应该存储什么数据，这个时候当然采用静态初始化方式
		如果在创建数组的时候，无法预测到数组中存储什么数据，只是先开辟空间，则使用动态初始化方式
		
 */
public class Test03 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a1 = {1,2,3};//数据类型 变量名
		int a2[] = {1,2,3};//C/C++惯用
		//两种方式都可以成功创建数组
	}

}

3.深入一维数组

package array1;
/*
	深入一维数组
 */
public class Test04 {
	public static void main(String[] args) {
		//创建一个数组，既可以存储Dog，也能存储Cat
		Animal[] as = new Animal[4];
		
		//赋值
		Dog d1 = new Dog();
		Dog d2 = new Dog();
		Cat c1 = new Cat();
		Cat c2 = new Cat();
		
		as[0] = d1;
		as[1] = d2;
		as[2] = c1;
		as[3] = c2;
		
		//需求：遍历数组，取出每个对象，如果是Dog则执行eat方法，如果是Cat则执行move方法
		for(int i=0;i<as.length;i++) {
			Animal a = as[i];
			System.out.println(a);
			//强制类型转换（向下转型）
			if(a instanceof Cat) {
				Cat c = (Cat)a;
				c.move();
			}else if(a instanceof Dog) {
				Dog d = (Dog)a;
				d.eat();
			}
		}
	}
}

class Animal{
	
}

class Dog extends Animal{
	public void eat() {
		System.out.println("dog eat");
	}
}

class Cat extends Animal{
	public void move(){
		System.out.println("Cat move");
	}
}

4.一维数组的拷贝

package array1;
/*
	关于数组的拷贝
	
 */
public class Test06 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		int[] a1 = {1,2,3,4};
		int[] a2 = new int[6];
		
		//作业：手动完成数组拷贝
//		for(int i=0;i<a1.length;i++) {
//			a2[i]=a1[i];
//		}
//		for(int i=0;i<a2.length;i++) {
//			System.out.println(a2[i]);
//		}
		
		//System.arraycopy(源数组, 源数组下标, 目标数组, 目标数组下标, 拷贝长度);
		//System.arraycopy(src, srcPos, dest, destPos, length);
		System.arraycopy(a1, 0, a2, 1, 4);
		
		for(int i=0;i<a2.length;i++) {
		System.out.println(a2[i]);
		}
		
		//作业2：模仿arraycopy方法完成数组拷贝
		int srcPos = 0;
		int destPos = 1;
		int length = 4;
		for(int i=srcPos,j=destPos;i<length;i++,j++) {
			a2[j]=a1[i];
		}
		System.out.println("----------");
		for(int i=0;i<a2.length;i++) {
		System.out.println(a2[i]);
		}
	}

}