JAVA进阶版：数组

数组

• 1.数组是一种引用类型。
• 2.数组是一种简单的数据结构，线性的结构。
• 3.数组是一个容器，可以用来存储其他元素，数组是可以存储任意数据类型的元素。
• 4.数组分为：一维数组，二维数组，三维数组，多维数组。
• 5.数组中存储的元素类型是统一的
• 6.数组长度不可改变，数组一旦创建长度是不可变的，固定的

(1) 各类型数组(包括引用类型)

package javase.jingjie.ShuZu;
public class ShuZu01 {
	public static void main(String[] args) {
		//声明一个一维数组，用来存储int类型
		int [] a1= {100,200,150,300};//这种方法称作“静态初始化一维数组”
		//boolean类型的数组
		boolean[] b1= {true,false,true};
		
		//byte 数组
		byte [] b2= {1,2,3};
		
		//String数组
		String [] strs= {"AB","CD","RF"};
		
		//char数组
		char [] c1= {'a','c','d'};
		
		//Object数组
		Object o1=new Object();
		Object o2=new Object();
		Object o3=new Object();
		Object [] objs= {o1,o2,o3};
	}
}

---

(2) 静态初始化数组：int [] a1= {10,12,13};

package javase.jingjie.ShuZu;
/**
 * 初始化一维数组有两种方式：
 * --静态初始化
 * --动态初始化
 * 
 * 静态初始化：
 * 结果：第一个元素是：10
最后一个元素是：13
最后一个元素是：13
数组中元素的个数是：3
10
12
13
-----------
10
100
13

 * **/
public class ShuZu02 {

	public static void main(String[] args) {
		//静态初始化一个int类型的一维数组
		int [] a1= {10,12,13};
		
		//取得第一个元素
		System.out.println("第一个元素是："+a1[0]);
		System.out.println("最后一个元素是："+a1[2]);
		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]);
		}
	}
}

---

(3) 动态初始化数组：int [] a1=new int[4];

package javase.jingjie.ShuZu;
/**
 * 动态初始化一维数组
 *   1.动态初始化一维数组，会在堆内存中分配这个数组，并且每一个元素都采用默认值。
 *   byte,short,int,long  0
 *   float,double  0.0
 *   boolean  false
 *   char\u0000
 *   引用     null
 *   
 *   结果：0
0
0
0
21
22
23
24
null
null
null
 * */
public class ShuZu03 {	
	public static void main(String[] args) {
		//动态声明一个int类型的数组，最多可以存储4个元素
		int [] a1=new int[4];
		//遍历
		for(int i=0;i<a1.length;i++) {
			System.out.println(a1[i]);
		}	
		//赋值
		a1[0]=21;
		a1[1]=22;
		a1[2]=23;
		a1[3]=24;
		//遍历
		for(int i=0;i<a1.length;i++) {
			System.out.println(a1[i]);
		}
		
		//引用类型数组
		Object [] objs=new Object[3];
		
		for(int i=0;i<objs.length;i++) {
			Object o=objs[i];
			//o.toString();//注意空指针异常，因为引用类型的数组默认值是null
			System.out.println(o);//null null null
		}
	}
}

---

(4)
什么时候使用动态初始化，什么时候使用静态初始化？

• 1.无论是动态初始化还是静态初始化，最终的内存分布都是一样的
• 2.如果创建数组的时候，知道数组中应该存储什么数据，这个时候当然采用静态初始化方式；
• 3.如果创建数组的时候，无法预测到数组中存储什么数据，只是先开辟空间，即使用动态初始化方式。

package javase.jingjie.ShuZu;
public class ShuZu04 {
	public static void main(String[] args) {
		int [] a1= {1,2,3};
		//c++
		int a2[]= {3,4,5};	
		int a3[]=new int[4];
	}
}

---

(5) instanceof(是否属于该类型):深入数组

package javase.jingjie.ShuZu;
/**
 * 深入一维数组
 * 结果：javase.jingjie.ShuZu.Dog@a09ee92
        Dog eat
       javase.jingjie.ShuZu.Dog@30f39991
        Dog eat
       javase.jingjie.ShuZu.Cat@452b3a41
       Cat move
       javase.jingjie.ShuZu.Cat@4a574795
        Cat move
 * */
public class ShuZu05 {
	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);//调用a.toString()方法
			//强制类型转换（向下转型）
			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");
	}
}

---

(6) 方法调用的时候，也可以这样传递一个数组

package javase.jingjie.ShuZu;
/**
 * 方法调用的时候，也可以这样传递一个数组。
 * */
public class ShuZu06main {
	public static void main(String[] args) {
		// 第一种方式
		int [] a= {12,3,4,5,6};
		m1(a);
		//第二种方式
		m1(new int[] {34,24,56,78,6,7});
	}
	public static void m1(int[] a) {
		for(int i=0;i<a.length;i++) {
			System.out.println(a[i]);
		}
	}
}

---

(7) main方法中的参数列表String[] args

package javase.jingjie.ShuZu;
/**
 * 关于main方法中的参数列表String[] args
 * 1.String[] args是专门用来接收命令行参数的
 * 2.例如:java ShuZu07 abc def aaa
 * ---JVM在调用ShuZu07类的main方法之前，先"abc def aaa"这个字符串以“空格”的方式分割，然后存储在String数组中
 * ---先“bac def aaa”这个字符串以“空格”的方式分割，然后存储在String数组中
 * */
public class ShuZu07 {
	//main方法中的String[]数组的设计主要是用来接收命令行参数的
	public static void main(String[] args) {
		System.out.println("String类型的数组中元素的个数："+args.length);
		//遍历
		/*
		 * for(int i=0;i<args.length;i++)
		 *  { System.out.println(args[i]); 
		 *  }
		 */
		//需求：运行该软件的时候，必须提供软件用户名和密码
		//格式：java ShuZu07 username password
		//如果用户没有提供足够的参数，则系统退出
		if(args.length!=2) {
			System.out.println("要想使用该系统,必须这样输入：java ShuZu username password");
			return;
		}
		//参数提供正确，如果用户名是admin,密码是123，则登录成功。
		String username =args[0];
		String password =args[1];
		//java中比较字符串是否相等，必须用equals方法
		//String类型是SUN公司提供，已经equals方法
		if("admin".equals(username)&&"123".equals(password)) {
			System.out.println("登录成功，欢迎["+username+"]回来！");			
		}else {
			System.out.println("登录失败，用户名["+username+"]不存在或者密码错误！");
		}
	}
}
//本质是String数组存放
/*JVM{
	String[] args= {"abc","def","aaa"};
	ShuZu07.main(args);
}
*/

---

(8) 数组的拷贝

package javase.jingjie.ShuZu;
/**
 * 关于数组的拷贝
 * **/
public class ShuZu08 {
	public static void main(String[] args) {
		int [] src= {2,3,4,5,6,7,8};
		int [] dest= {10,11,12,13,14,15,16};
		//src中的4，5，6拷贝到dest数组中，从13开始
		System.arraycopy(src,2,dest,3,3);//源数组，源数据的开始下标，目标数组，目标数组的开始下标，拷贝长度
		
		//遍历
		for(int i=0;i<dest.length;i++) {
			System.out.println(dest[i]);
		}
	}
}