数组作为引用类型的运行机制

内存中的数组

1. 数组引用变量只是一个引用，相当于一个指针，指向内存中的数组的对象。
2. 数组的对象被存储在堆（heap）中，数组引用变量如果是一个局部变量，则它保存在栈（stack）内存中。
3. 访问数组元素采用p[index]
4. 如果想回收数组的内存，把数组引用变量赋值为null，则切断了数组引用变量与实际数组对象的关系。数组的对象就变成了垃圾。

只要类型相互兼容，就可以让一个数组变量指向另一个实际的数组。
注意：
这种操作并不是在改变数组的长度。数组的长度是不可改变的（大声说三遍）。数组应该看成是两个部分：数组引用变量和数组的对象。数组的长度指的是数组的对象的长度。让一个数组变量指向另一个实际的数组，是将数组引用变量这个指针指向了另一个数组，但是之前的数组的对象的长度并不会改变，只是变成了垃圾等待被回收。

基本类型数组的初始化

定义数组引用变量，在栈内存中有一个空引用
动态初始化数组后，开辟了内存空间，数组元素被赋默认值
动态遍历数组之后，数组元素的值直接储存在内存中。

引用类型数组的初始化

引用类型数组的数组元素是引用，塔指向另一块内存，这块内存存储了有效值。

如图所示

1. 首先当定义一个Person[] students;时，是在栈内存中开辟一块区域。
2. 当给数组动态赋值时，students=new Person[2];在内存里面开辟两块区域，并系统默认赋值为null。
3. Person zhang=new Person();
   zhang.age=12;
   .....
   在栈内存中开辟一块区域给新生成的对象 zhang
   lee同理
4. students[0]=zhang;把张赋值给了students[0];
   这时，students[0]和zhang能够访问到的东西完全相同。

没有多维数组

一维数组的定义是 type[] arrName,其中type是数组元素的类型，如果想要一个数组元素类型是int型数组的数组，那么就可以表示成int[][] arrName.扩展到全部java就是type[][] arrName.

动态初始化

静态初始化

一维数组的静态初始化

intArr1=new int[]{2,3,4};
intArr2={1,2,3};
String[][] str1=new String[]{new String[3],new String[]{"hello"}};
String[][] str2={new String[3],new String[]{"hello"}};

Java8增强的工具类：Arrays

public class  ArraysTest 
{
    public static void main(String[] args) 
    {
        int[] a=new int[]{3,4,5,6};
        int[] a2=new int[]{3,4,5,6};
        System.out.println("如果a和b是否相等"+Arrays.equals(a,a2));
        int[] b=Arrays.copyOf(a,6);
        System.out.println("b的数组是"+Arrays.toString(b));
        Arrays.fill(b,2,4,1);
        Systemm.out.println("b的数组是"+Arrays.toString(b));
        //System.out.println("Hello World!");
    }
}

p101之后再次阅读

数组的应用举例

数组的用途：如果程序中有多个类型相同的变量，而且它们具有逻辑的整体性，则可以把它们定义成一个数组。

浮点数转人民币读法(课后习题版)

（小白初学java，代码不当之处请大家多多指出。我自己都觉得编的太差）

import java.util.Arrays;
public class  Num2Rmb
{
    private String[] hanArr={"零","壹","二","三","四","五","六","七","八","九","十"};
    private String[] unitArr={"千","百","十","元"};
    private String[] unitXiaoArr={"角","分"};
    /**
    *把一个浮点数分解成整数部分和小数部分字符串
    *@param num 需要被分解的浮点数
    *@return 分解出来的整数部分和小数部分，第一个数组元素是整数部分，第二个数组元素是小数部分
     */
    private String[] divide(double num)
    {
         long zheng=(long)num;
         //小数部分变成一个两位数
         long xiao=Math.round((num-zheng)*100);
         //用两种方法把整数转换为字符
         return new String[]{zheng+"",String.valueOf(xiao)};
     }
     /**
     *把分割好的字符串数组转化为汉字字符串
     *@param numStr 需要转换的字符串数组
     *@return 转换成的汉字字符串
     */
     private String toHanStr(String[] numArr)
    {
         String result="";
         //整数与小数的长度
         int zhengLen=numArr[0].length();
         int xiaoLen=numArr[1].length();
         for(int i=0;i<zhengLen;i++)
        {
             //把char型数字转换成int型数字，因为ASCII码差48，
             //因此char型数字减去48就得到int型数字
             int numZheng=numArr[0].charAt(i)-48;
             //如果数字不是0，则需要添加单位
             if(numZheng != 0)
            {
                 result+=hanArr[numZheng]+unitArr[i];
                 
            }//如果最后一个数字是0，则加上“元”,直接跳出循环
            else if((numArr[0].charAt(zhengLen-1)-48)==0)
            {
                result+=unitArr[3];
                break;
            }
            //如果前一位不得0则打印汉字0
            else if((numArr[0].charAt(i-1)-48)!=0)
            {
                result+=hanArr[numZheng];
            }
            
         }
         //小数部分变成汉字
         for(int i=0;i<xiaoLen;i++)
        {
             int numXiao=numArr[1].charAt(i)-48;
             //只要不是0，就变成汉字加上单位
             if(numXiao!=0)
            {
                 result+=hanArr[numXiao]+unitXiaoArr[i];
             }else//如果是0.就只变成汉字
            {
                 result+=hanArr[numXiao];

             }

         }
         return result;
     }

    public static void main(String[] args) 
    {
        
        Num2Rmb nr=new Num2Rmb();
        System.out.println(Arrays.toString(nr.divide(23671125.123)));
        System.out.println(nr.toHanStr(nr.divide(1006.333)));

        
    }
}