java 数组 、 for each循环， 数组的两种拷贝方法 ，Arrays.copyOf()，Arrays.toString[]，匿名数组

数组是一种数据结构，数组不一定里面是数，也可以是char，String，boolean，int，double
数组通过一个整型下标可以访问数组中每一个值。例如a是一个整形数组，则a[i]就是数组中下标为i的整数。
在声明（区别于创建）数组时，需要指出数组类型（数据元素类型[ ]+数组变量名字）
int[ ] a; //只是声明了数组变量a，而没有创建数组a
应该使用new运算符创建数组：
int[] a=new int[100]; //创建了int型的数组a，并将数组元素都初始化为0
数组长度不要求是常量，可以为int[] a=new int[n];

package 第3章;

public class 第3章a
{
    public static void main(String[] args)
    {
        int[] b=new int[10];
        int i;
        for(i=0;i<10;++i)
        {
            b[i]=i;
        }
        for(i=9;i>=0;--i)
        {
            System.out.println(b[i]);
        }   
    }          
}

创建一个数字数组时，所有元素都初始化为0，boolean数组的元素会初始化为false，对象数组的元素则初始化为null，这表示这些元素还未存放任何对象。

 String[] name=new String[10];   //此时10个字符串全部为null

如果希望这个数组包含空串，可以为元素制定空串（空串“”与null串是不一样的值）

package 第3章;

public class 第3章a
{
    public static void main(String[] args)
    {
        String[] name=new String[10];   //此时10的元素全部为null
        String[] name2=new String[10];
        for(int i=0;i<10;++i)
        {
            name[i]=null;
            name2[i]="";
        }
        for(int i=0;i<10;++i)
        {
            System.out.println(name[i]);
            System.out.println(name2[i]);

        }

    }          
}

要想获得数组中的元素个数，可以使用array.length（数组名.length)而不是 数组名.length();
数组名.length 适用于任何类型的数组（String，boolean……）

package 第3章;
public class 第3章a
{
    public static void main(String[] args)
    {
        String[] name=new String[10];   //此时10的元素全部为null
        int c=name.length;
        //不是 int c=name.length（）;
        System.out.println(c);
    }          
}

一旦创建了数组，就不能在改变它的大小（尽管可以改变每一个数组元素），如果经常需要在运行过程中扩展数组的大小，就应该使用另一种数据结构–数组列表（array list）
for each 循环
Java有一种功能很强的循环结构，可以用来依次处理数组中的每个元素，而不必为下标值而分心。

for(变量 ：数组名）
{

}

//例如：
package 第3章;
import java.util.Arrays;
public class 第3章a
{
    public static void main(String[] args)
    {
        int[] a=new int[2];
        int i=1;
        a[0]=1;
        a[1]=3;
        for(int element:a)
        {
          //  System.out.println(element);
           System.out.println(element);
        }
        System.out.println(Arrays.toString(a));
    }          
}

for(int element:a)
{
System.out.println(element);
}
打印数组a的每一个元素，一个元素占一行
这个循环应读作：循环a中的每一个元素（for each element in a)
使用for each语句显得更加简洁，更不易出错
for each 循环语句的循环变量element将遍历数组中的每一个元素

package 第3章;
import java.util.Arrays;
public class 第3章a
{
    public static void main(String[] args)
    {
        int[] a=new int[2];

        int i=1;
        a[0]=1;
        a[1]=3;

        System.out.println(Arrays.toString(a));

    }          
}

有个更加简洁的方式打印数组中的所有值，即利用Arrays类的toString方法，
import java.util.Arrays ;
调用Arrays.toString(a)方法，返回一个包含数组元素的字符串，这些元素被放置在中括号内，元素之间以逗号分隔，例如：“[1,2,3,4,5]”
要想打印数组，可以调用
System.out.println(Arrays.toString(a));

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
       int[] a=new int[5];
       for(int i=0;i<5;++i)
       {
           a[i]=i;
       }
       System.out.println(Arrays.toString(a));
    }          
}

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
       int[] a=new int[5];
       for(int element:a)
       {
           System.out.println(element);
       }

    }          
}

数组初始化以及匿名数组
在java中，提供了一种创建数组对象同时赋予初始值的简化书写形式：
int [] hello={1,2,3,4,5};
请注意，在使用这种语句时，不需要调用new：
int [] hello=new int[5];
甚至还可以初始化一个匿名的数组：
new int [] {1,2,3,4,5,6,7}; //可以用来重新初始化一个已有的数组：
hello=new int[] {1,2,3,4,5,6,7};
以上为下列语句的简写：
int[] annoymous={1,2,3,4,5,6,7};
hello=annoymous ;

 package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
       int[] hello=new int[3];
       hello=new int[] {1,2,3};
       for(int element:hello)
       {
           System.out.println(element);
       }
       System.out.println(Arrays.toString(hello));
    }          
}

在java中，允许数组的长度为0，在编写一个结果维数组的方法时，如果碰巧结果为空，则这种语法形式就显得非常有用，此时可以创建一个长度为0的数组：

int[] well=new int[0];

在java中，允许将一个数组变量拷贝给另一个数组变量，这时，两个变量引用同一个数组。
如同两个指针指向同一个数组
int [] hello=new int [5];
int [] well=hello;

//例如：
package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
       int[] hello=new int[3];
       hello[0]=1;
       hello[1]=3;
       hello[2]=0;
       int [] well=hello;
       System.out.println(Arrays.toString(well));
       //两个数组变量指向同一个数组
       //如果希望将一个数组的所有制拷贝到另一个新的数组中，就要使用Arrays类的copyOf方法
       int[] what=Arrays.copyOf(well, well.length);
       int[] how=Arrays.copyOf(hello, 2*hello.length);
       System.out.println("what= "+Arrays.toString(what));
       System.out.println("how= "+Arrays.toString(how));
       char[] a=new char[3];
       boolean[] b=new boolean[3];
       String[] c=new String[3];
       char[] A=Arrays.copyOf(a, a.length);
       boolean[] B=Arrays.copyOf(b, b.length);
       String[] C=Arrays.copyOf(c, c.length);
       System.out.println("A= "+Arrays.toString(A));
       System.out.println("B= "+Arrays.toString(B));
       System.out.println("C= "+Arrays.toString(C));

       //Arrays.copyOf(数组名，拷贝而成的数组的长度）;
       //数值型（int，long，double）多余的元素赋值为0，布尔型boolean，多余元素赋值为false，如果长度小于原数组长度，则只拷贝最前面的数组元素。
       //JAVA中的数组语句：int[] hello=new int[5];   等同于int *hello=new int[5];
       //JAVA中的[]运算符被预定义为检查数组边界，而且java没有指针运算，既不能通过hello+1来得到数组的下一个元素。
    }          
}
run:
[1, 3, 0]
what= [1, 3, 0]
how= [1, 3, 0, 0, 0, 0]
A= [, , ]
B= [false, false, false]
C= [null, null, null]

char[] A;
A 为空时，A= [ , , ]；
boolean[] B;
B为空时，B= [false, false, false];
String[] C;
C为空时，C= [null, null, null]