Java基础篇——数组

        数组也是一种数据结构，是一种引用类型的数组类型，它是用来存放同一类数据类型的集合，通过下标可以访问数组中每一个元素。

1、数组的声明：(必须要指明其类型）

        int[] ary;
	int ary[];  //不推荐的写法,(继承了C++ 的声明方式)

这只是声明了整型数组变量ary（即：一个引用变量），而没有把ary初始化为一个真正的数组。

2、初始化

    1>、动态初始化：必须指明数组长度

        int[] arry = new int[10];//自动初始化全为0
	    int[] arry = new int[]{1,2,3,4,5};

     2>、静态初始化：只能在声明数组时候使用

            int[] arry = {1,2,3,4,5};
	   //arry = {1,2,3,4,5}; //编译错误
	   arry = new int[]{1,2,3,4,5};

     3>、数组成员自动初始化为“零”值      ‘零’值：0，0.0，u\0000,false,null

3、数组的其他 ：

   1>、ary.length可以度量数组的长度

   2>、数组的大小一旦确定，就不可以改变

   3>、数组的长度可以允许是0 

     int[] ary = new int[0];

实例1：

         等本金还款

借款本金：18万

利息：5.6% （年利息）

还款期数（月）：60个月（5年）

每月归还本金：180000/60=3000

第1个月还利息：180000*(5.6%/12)=840

第2个月还利息：（180000-3000*1）*(5.6%/12)=826

……

第1月   3000 840  3840

第2月   3000 826  3826

……

提示：利用数组来存放每个月的利息值

代码示例：

/**
 * 等本金还款
 * @author xcbeyond
 *
 */
public class Demo {
	public static void main(String[] args) {
		int benjin = 180000;
		double ret = 5.6/100;
		int months = 60;
		double[] lixi = new double[months];
		double monthPay = (double)benjin/months;
		//利息计算
		for(int i = 0;i<months;i++){
			lixi[i] = (benjin-monthPay*i)*(ret/12);
		}
		double sumBenJin = 0;
		double sumLixi = 0;
		double sumPay = 0;
		
		System.out.println("月份\t 本金\t\t利息\t\t本息和");
		for(int i = 0;i<months;i++){
			System.out.print("第"+(i+1)+"月\t");
			System.out.print(monthPay+"\t");
			System.out.print(lixi[i]+"\t");
			System.out.println(lixi[i]+monthPay);
			sumBenJin+=monthPay;
			sumLixi+=lixi[i];
			sumPay+=lixi[i]+monthPay;
		}
		System.out.println("合计\t"+sumBenJin+"\t"+sumLixi+"\t"+sumPay);
		
	}
}

4、数组的扩展问题

   1〉Java 数组的大小是固定的

  2〉利用数组复制的方法可以变通的实现数组扩展

      数组赋值：修改了数组的引用变量，而没有进行新的内存空间的分配，他们共同使用了一个相同的数组空间，如：

	int[] ary = new int[]{1,2,4,5};
        int[] ary2 = ary;//数组赋值

     数组的复制：重新申请一个新的内存空间来存放新的数组，只是将原数组元素值分别赋给新开辟的内存空间中。如：

        int[] ary3 = new int[ary.length];//重新开辟一个内存空间来存储ary3数组
	for(int i = 0;i<ary.length;i++) {
			ary3[i] = ary[i];
	}

    数组的动态扩展：变向的增加了数组的长度

                int[] ary5 = new int[ary.length+1];
		System.arraycopy(ary,0,ary5,0,ary.length);
		ary = ary5;

   3〉System.arraycopy()可以复制数组

     //用方法arraycopy复制数组，效率更高  如：

        int[] ary4 = new int[ary.length];
        System.arraycopy(ary,0,ary4,0,ary.length);

    4〉Arrays.copyOf()可以简便复制数组,如：

	int[] ary5 = new int[ary.length+1];
	System.arraycopy(ary,0,ary5,0,ary.length);
	ary = ary5;

实例2：

   身份证第18位验证计算法 

1>、将前面的身份证号码17位数分别乘以不同的系数

从第一位到第十七位的系数分别为：

7—9—10—5—8—4—2—1—6—3—7—9—10—5—8—4--2

2>、将这17位数字和系数相乘的结果相加

3>、用加出来和除以11，看余数是多少？

4>、余数只可能有0—1—3……10这11个数字

其分别对应的最后一位身份证的号码为

1—0—x—9—8—7—6—5—4—3—2

5>、通过上面得知,如果余数是2，就会在身份证的第18位数字上

例如：3405241980010101x

/**
 * 身份证最后一位数的验证
 * @author xcbeyond
 * 
 */
public class IdCardDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String id = "3405241980010101x";
		if(verify(id)){
			System.out.println("你的身份证"+id+"是合法的");
		}
		else{
			System.out.println("你的身份证"+id+"是非法的！");
		}
		
	}
	//验证是否合法
	public static boolean verify(String id){
		if(id.length()!=18)
			return false;
		//17位各系数值 
		int[] w = {7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};
		int sum = 0;
		for(int i = 0;i<w.length;i++){
			sum += (id.charAt(i)-'0')*w[i];
		}
		int c = sum%11;//余数
		char[] ch = {'1','0','x','9','8','7','6','5','4','3','2'};
		char code = ch[c];
		char last = id.charAt(17);
		last = last == 'x'?'X':last;//验证不管x或X即可
		return last==code;
	}

}

4、数组排序

Java中，数组是一种引用型数据类型，要想对数值型数组进行排序，可以直接使用现有Arrays类中sort方法。不过也可以自己编写相应的排序算法，如《排序算法（冒泡排序、选择排序、插入排序）》 。Arrays类中的sort方法是采用了优化的快速排序算法，它的返回类型为void。（Arrays类在JDK1.6后才出现，JDK版本低于1.6的无法实现）

import java.util.Arrays;
/**
 * 使用Arrays.sort()排序数组元素
 * @author xcbeyond
 *
 */
public class ArraysSort {
	public static void main(String[] args) {
		int ary[] ={13,15,37,89,60,39,12,109,56,72} ;
		Arrays.sort(ary);//排序方法
		String s = Arrays.toString(ary);//将数组元素转化为特殊的字符串样式
		System.out.println(s);
	}
}

输出结果：

        [12, 13, 15, 37, 39, 56, 60, 72, 89, 109]