从零开始学java（二十五）--数组与 java.util.Arrays工具类

数组的定义

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。数组的三个基本特点：

1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2. 其元素必须是相同类型，不允许出现混合类型。
3. 数组类型可以是任何数据类 型，包括基本类型和引用类型。

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

数组的声明

数组的声明方法一般有两种：

type[]   arr_name; //（推荐使用这种方式）
type    arr_name[];

注意事项

1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。
2. 声明一个数组的时候并没有数组真正被创建。
3. 构造一个数组，必须指定长度。

package Chapter_7;

public class TestArray {

	public static void main(String[] args) {
		 int[] array01;//仅仅只是声明，没有实例化，不分配存储空间
		 array01 = new int[20];//成功实例化，JVM分配空间
		 String array02;
		 User[] array03;
		 array03 = new User[5];//array03数组里的元素是对象
		 
		 //初始化
		 array01[0] = 15;
		 array01[1] = 58;
		 
		 for(int tag =2; tag<10;tag++) {
			 array01[tag]=2*tag;
		 }

		 for(int tag =0 ;tag<10;tag++) {
			 System.out.println(array01[tag]);
		 }

		 array03[0] = new User(1,"与猫子");
		 array03[1] = new User(2,"轩猫子");
		 for (int tag = 0; tag < 2; tag++) {
			System.out.println(array03[tag].getName()); 
		} 
	}
}
class User{
	private int id;
	private String name;
	
	public User(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public int getID() {
		return this.id;
	}
	public void setID(int id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return this.name;
	}
} 

引用类型数组的内存分配：

基本数据类型数组的内存分配：

数组的初始化

静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] a = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；

动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

int[] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int a2[] = new int[2]; // 默认值：0,0
boolean[] b = new boolean[2]; // 默认值：false,false
String[] s = new String[2]; // 默认值：null, null

数组的遍历

数组元素下标的合法区间：[0, length-1]。我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。

public class Test {
    public static void main(String[] args) {
        int[] a = new int[4];
        //初始化数组元素的值
        for(int i=0;i<a.length;i++){
            a[i] = 100*i;
        }
        //读取元素的值
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
}

for-each循环

增强for循环for-each是JDK1.5新增加的功能，专门用于读取数组或集合中所有的元素，即对数组进行遍历。

//foreach格式：
//for (array_type var : arrayName){      }
public class Test {
    public static void main(String[] args) {
        String[] ss = { "aa", "bbb", "ccc", "ddd" };
        for (String temp : ss) {
            System.out.println(temp);
        }
    }
}

数组的拷贝

System类里也包含了一个static void arraycopy(object src，int srcpos，object dest， int destpos，int length)方法，该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，destpos指定目标数组的第几个元素开始被赋值,length参数指定将src数组的多少个元素赋给dest数组的元素。

public class Test {
    public static void main(String args[]) {
        String[] s = {"阿里","尚学堂","京东","搜狐","网易"}; 
        String[] sBak = new String[6];
        System.arraycopy(s,0,sBak,0,s.length);
        for (int i = 0; i < sBak.length; i++) {
            System.out.print(sBak[i]+ "\t");
        }
    
	//测试从数组中深处某个元素，本质上还是数组的本质
	String[] s1={"aa","bb","cc","dd","ee"};
	//String[] s2 = new String[5];
	//我们测试删除cc
	//System.arraycopy(s1,3,s2,3-1,s1.length-3);
	
	//将源数组和目标数组都设为同一个数组就可以做到覆盖的效果	
	System.arraycopy(s1,3,s1,3-1,s1.length-3);
	s1[s1.length]=null;
	
	for(int tag = 0 ;tag <s1.length ;tag++){
	System.out.println(tag+"--"+s1[tag);
	}


	//数组的扩容（本质上是先定义一个更大的数组，然后把小数组的元素都复制到大数组里面去）
	//因为java没有指针，所以不能向C语言那样向操作系统提交申请然后扩容
	String[] s_small = {"aa","bb","cc"};
	String[] s_big = new String[s_small.length+10];
	System.arraycopy(s_small,0,s_big,0,s_small.length);
	
	for (String temp ; s_big){
	System.out.println{temp};
	}
	
}
}

java.util.Arrays工具类

DK提供的java.util.Arrays类，包含了常用的数组操作，方便我们日常开发。Arrays类包含了：排序、查找、填充、打印内容等常见的操作。

package Chapter_7;

import java.util.Arrays;

/**
 * 测试java。util。Arrays工具类
 * @author 与猫子
 *
 */
public class TestArray02 {

	public static void main(String[] args) {
		int[] a= {10,20,30,15,23,8,54};
		
		System.out.println(a);
		
		System.out.println(Arrays.toString(a));
		//测试排序
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
		
		
		//二分法查找，使用二分法之前要对数组进行排序
		//Arrays.binarySearch()可查找数据是否在数组中
		System.out.println(Arrays.binarySearch(a,30));
		//如果没有会返回-1
		
		
		//测试数组填充
		//Arrays,fill()能够将指定位置的元素替换为目标元素
		Arrays.fill(a,1,4,50);
		System.out.println(Arrays.toString(a));//将1到4-1的索引的值替换为50
		//这里是1到4-1的索引的原因是，其默认的逻辑是如此，当然我们可以仿照默认库来重写
	}
}