Java 基础 —— 数组

创建数组大致包括如下步骤：

• 声明一个数组类型的引用变量，简称为数组变量；
• 用new语句构造数组的实例。new语句为数组分配内存，并且为数组中的每个元素赋予默认值；
• 初始化，即为数组的每个元素设置合适的初始值。

一. 数组变量的声明；

声明数组：
1) 一个存放同一类型数据的集合
   a. 即可以是基本类型，也可以是对象类型；
   b. 数组中的每个数据为元素；
2) 数组是一个对象，成员是数组长度和数组中的元素;
3) 声明了一个数组变量并不是创建了一个对象;
4) 声明数组的方式：

   int[] IArray 或者 int IArray[]         基本数据类型数组，数组中存放的是基本数据类型。
   Teacher[] tArray 或者 Teacher tArray[] 类类型数组，数组中存放的是Teacher类创建的若干个的对象。 

注意：1) 声明数组变量的时侯，不能指定数组的长度，以下声明方式是非法的。

         int x[1];
         int[2] x; 

二. 初始化

初始化：自变量创建后首次赋值的过程； 

1. 创建数组对象；
2. 初始化数组对象；
3. 多维数组；
4. 数组的边界：
5. 数组的拷贝：
6. 可变参数
7. 格式化输出

1. 创建数组对象；

   数组对象和其他Java对象一样，也用new语句创建；

   int[] iArray = new int[2];

   new int[2]语句执行以下步骤：

   a. 在堆区中为数组分配内存空间，
   b. 为数组中的每个元素赋予其数据类型的默认值。
      byte/short/int/long   0
      float         0.0f
      double                0.0d
      String                null
      char                  '\u0000'
      boolean               false
   c. 返回数组对象的引用

   在用new语句创建数组对象时，需要指定数组长度。数组长度表示数组中包含的元素数目。数组长度可以用具体的数值表示，也可以用变量表示。如：

   int[] x = new int[10];
   或
   int size = 10;
   int[] x = new int[size];

   数组的长度可以为0，此时数组中一个元素也没有。例如：

   int[] x = new int[0];

   对于Java类的程序入口方法main(String args[]),如果运行时这个类没有输入参数，那么main()方法的参数args并不是null, 而是一个长度为0的数组。例如：

   public class Sample {
       public static void main(String[] args) {
            System.out.println(args.length);           //打印0
       }
   }

   数组对象创建后，它的长度是固定的。数组对象的长度是无法改变的，但是数组变量可以改变所引用的数组对象。

   int[] x = new int[3];
   int[] y = x;
   x = new int[4];

2. 初始化数组对象；

   数组中的每个元素都有一个索引，或者称为下标。数组中的第一个元素的索引为0，第二个元素的索引为1, 依次类推。
   通过索引可以访问数组中的元素或者给数组中元素内容赋值。

   1) 声明、创建、初始化分开： 

      int[] iArray;     //声明

      iArray = new int[2];  //创建

      iArray[0] = 0;    //初始化
      iArray[1] = 1; 

   2) 声明、创建的同时并初始化数组；

      int[] iArray = {0, 1};
  int[] iArray = new int[]{0, 1};
      Student sArray[] = new Student[] { new Student(“George”, “Male”, 20), new Student()};
      Student[] stArray = { new Student(), new Student()} ;

      注意：下面这些都是非法的数组初始化方式：
               int[] x = new int[5]{5,4,3,2,1};           //编译出错，创建数组对象的同时并初始化的时候就不能指定数组长度了；

               int[] x;
               x = {5,4,3,2,1};                           //{5,4,3,2,1}必须在声明数组变量的语句中使用，不能单独使用 

3. 多维数组：

多维数组本质上是数组的数组，数组的元素内容还是数组；

4. 数组的边界：

1) 一个数组的下标从0开始，数组通过数组的对象引用变量的下标访问数组。

如果超出边界，在运行时会抛出ArrayIndexOutOfBoundsException

2) 通过调用数组的length方法可以获得一个数组的元素个数（数组长度）。

所有Java数组都有一个length属性，表示数组的长度. 该属性只能读取，但是不能修改。

   注：a. 数组变量必须在指向一个数组对象之后，才能访问其元素。

          public class Sample {
               private int[] x;

               public static void main(String[] args) {
                      Sample s = new Sample();
                      System.out.println(s.x);            //打印null
                      System.out.println(s.x[0]);         //运行时抛出NullPointerException
                      System.out.println(s.x.length);      //运行时抛出NullPointerException
               }
          }

       b. 当数组的元素为引用类型时，数组中存放的是对象的引用，而不是对象本身； 

冒泡排序：

            public void sort(int[] n) {
                for(int i=0;i<n.length-1;i++) {
                    for(int j=0;j<n.length-i-1;j++) {
                        if(n[j]>n[j+1]) {
                            int temp = n[j];
                            n[j] = n[j+1];
                            n[j+1] = temp;
                        }
                    }
                    print(n);
                }
            }

**java.util.Arrays辅助类的使用。
sort(int[] n)以及binarySearch(int[] n,int key)方法的使用。**

  注意：
  a. 这二个方法均为static方法，可直接通过类名使用；
  b. binarySearch方法必须保证数组中的元素已经按照升序排列，这样才能得到正确的结果；  

5. 数组的拷贝：

数组的长度一旦确定之后便不能调整，可以通过复制数组的内容变通实现改变数组长度。
在System类中提供一个辅助的 arraycopy方法提供复制数组内容的功能：

   public static void arraycopy(Object src,
                         int srcPos,
                         Object dest,
                         int destPos,
                         int length)

参数1,需要被复制的目标数组
参数2,从这个数组的那个一个位置开始复制
参数3,需要把数据复制到的另外的那一个新的数组对象
参数4,复制到新数组里面哪个位置(从这个位置开始算)
参数5,复制的目标数组的长度 

6.可变参数 JDK1.5或以上

之前的写法
public void test(int[] a){ }

可变参数写法
public void test2(int... a){ }

可变参数前面可以加其他参数
public static void test3(String msg,int... a){ }

可变参数后面不能加任何参数 这样是编译不通过的
public static void test4(int... a,String msg){ }  

7.格式化输出 JDK1.5或以上

System.out.printf是JDK1.5之后加入的新的方法，可以格式化输出内容

“%”表示进行格式化输出，”%”之后的内容为格式的定义。

    double d = 345.678;  
    String s = "你好！";  
    int i = 1234;  
    // "f"表示格式化输出浮点数
    System.out.printf("%f", d);             // 345.678000
    // "9.2"中的9表示输出的长度，2表示小数点后的位数。
    System.out.printf("%9.2f", d);          //    345.68
    // "+"表示输出的数带正负号。
    System.out.printf("%+9.2f", d);         //   +345.68    
    // "-"表示输出的数左对齐（默认为右对齐）。  
    System.out.printf("%-9.4f", d);         // 345.6780
    // "+-"表示输出的数带正负号且左对齐。
    System.out.printf("%+-9.3f", d);        // +345.678 
    System.out.println();
    // "d"表示输出十进制整数。
    System.out.printf("%d", i);
    // "o"表示输出八进制整数。 
    System.out.printf("%o", i);         // 2322
    // "x"表示输出十六进制整数                
    System.out.printf("%x", i);         // 4d2
    // "#x"表示输出带有十六进制标志的整数。  
    System.out.printf("%#x", i);        // 0x4d2
    // "s"表示输出字符串。
    System.out.printf("%s", s);