java数组

数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量
数组中的元素可以是任何数据类型，包括基本类型和引用类型
记住数组首先分配空间再赋值！
动态初始化：就是先分配空间再赋初值；
静态初始化：定义数组同时就为数组元素分配空间并赋值。

1一维数组的声明
一维数组的声明：type var[]或type[] var
      注意：数组声明是不能指定其长度，如 int a[5];//非法

Java中使用关键字new 创建数组对象：int[] s;
                                  s = new int[10];
2一维数组的创建
创建基本数据类型一维数组(new后面的中括号一定要有值)：
      public class Test{
              public static void main(String args[]){
                    int[] s;
                   s = new int[10];//创建一个INT类型的数组，并为它分配10个空间
                    for ( int i=0; i<10; i++ ) {
                         s[i] =2*i+1;
                 System.out.println(s[i]);
                    }
             }
       }

创建元素为引用数据类型的数组：
    class MyDate{
            private int day;
            private int month;
            private int year;
            public MyDate(int d, int m, int y){
            day = d;    month = m;    year = y;
            }
            public void display(){
            System.out.println(day + "-" + month + "-" + year);
            }
     }

    public class Test{
            public static void main(String args[]){
                  MyDate[] m;
                  m = new MyDate[10];创建一个MyDate类型的数组，并为它分配10个空间   
                  for ( int i=0; i<10; i++ ) {
                             m[i] =new MyDate(i+1, i+1, 1990+i);//它是mydate类型的数组，它的每个元素应当是一个mydate对象!必须给这个对象new一个空间才能用。
                     m[i].display();
                  }
             }
        }

3一维数组的初始化
 动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。
    int  a[];
    a  = new int[3];
    a[0] = 3;
    a[1] = 9;
    a[2] = 8;

    MyDate dates[];
    dates = new MyDate[3];
    dates[0] = new MyDate(22, 7, 1964);
    dates[1] = new MyDate(1, 1, 2000);
    dates[2] = new MyDate(22, 12, 1964);

 静态初始化：在定义数组的同时就为数组元素分配空间并赋值。
    int a[] = { 3, 9, 8};

    MyDate dates[] = {
            new MyDate(22, 7, 1964),
            new MyDate(1, 1, 2000),
               new MyDate(22, 12, 1964)
    };

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

定义并用运算符new为之分配空间后后，才可以引用数组中的每个元素；


多维数组(Java中多维数组不必须是规则矩阵形式)：
    多维数组的声明
    定义二维数组：
        int[ ][ ]   intArray;
        double dbArray [ ][ ];
    定义三维数组：
        int[ ][ ][ ]   intArray；
        String strArray [ ][ ][ ]；
    当使用new 来创建多维数组时，不必指定每一维的大小，但要指定最左边的维的大小。
           int[ ][ ]  array = new int[2][ ];//
          int t1[][] = new int[][4]; //非法
        int tt[][] = new int[4][5];
          int t1[][][] = new int[2][][4]; //非法
    静态初始化：
        int[][] a = {{1,2},{10,2},{20,1}};
        int intArray1[3][2] = {{1,2},{2,3},{4,5}};  //非法,因为这是定义与初始化同时进行，定义时不能指明数字，在这里同样不能！
    动态初始化：
        int a[][] = new int[4][5];//二维数组有四个一维数组，里面每个都是5个；也可以理解左边[]是行，右边[]是列。
        int b[][] = new int[3][]
            b[0] = new int[4];
            b[1] = new int[3];
           b[2] = new int[5];
            b[0][0]=1;
            b[0][1]=2;
           ……
二维数组例子。
public class CreateErWei
{
   public static void main(String args[])
  {
     int[][] a= {{1,2},{3,4,4,6},{5,6,7}};//创建一个不规则二维数组，左[]表示一维，有[]表示一维里面的二维
      //遍历

      for(int i = 0; i<a.length; i++)//表示遍历一维数组
        {
            for(int j = 0; j<a[i].length; j++)//遍历一维数组当中的二维数组内的每一个元素，注意这个a[i].length，而且注意不能写成j<=a[i].length
             {
                 System.out.print(a[i][j]+" ");//输出二维数组当中的数据
             }
               System.out.println();//换行
        }
  }

}


/*
输出结果为：
1 2
3 4 4 6
5 6 7
*/       

   

上课笔记：
记住数组首先分配空间再赋值！
动态初始化：就是先分配空间再赋初值；
静态初始化：定义数组同时就为数组元素分配空间并赋值。
引用类型默认是空值！

public class Test
{
  public static void main(String args[])
   {
     int a = new int[5];
     Date[] days = new Date[3];
     System.out.println(a[3]);//输出结果为0
     System.out.println(days[2]);//输出结果为null
   }

  class Date
   {
     int year, int month, int day;
     Date(int y, int m, int d)
      {
        Date(int y; int m; int d)
         {
          year = y; month = m; day = d;
          }
       }
   }
}


new数组后才可以引用数组里面的元素，其引用方式为：arrayName[index]，如a[3]
每个数组都有一个属性length知名它的长度，如：a.length的值为数组a的长度（元素个数）。

声明的时候绝对不能往中括号放值，如int[4] a;绝对不行，要么静态创建，要么动态创建！这样绝对不行。

直接new MyDate(22,7,1998);叫做创建无名对象。
数组的元素相当与类的成员变量，new的时候直接初始化了。

length属性相当于变量，属性相当于变量。
String类中里面有一个length方法，它可以返回字符串长度；数组里没有length方法，它有length属性，它可以返回数组的长度。
new后面的中括号一定要有值。

static静态，可以通过类名直接调用，如果在本类的话，直接录入方法名即可调用；
一个类会先加载静态的东西，再加载成员变量。
用static修饰的东西不属于某个类。

Java中多维数组的声明和初始化应按从高维到低维的顺序进行，int t1[][] = new int [][4];   //非法

MyDate dates[];//MyDate叫引用类型，也叫类类型。
dates = new MyDate[3];
dates[0] = new MyDate(22, 7, 1964);
dates[1] = new MyDate(1, 1, 2000);
dates[2] = new MyDate(22, 12, 1964);

java.lang.System类的arraycopy()方法提供了数组元素复制功能：

     //源数组
     int source[] = { 1, 2, 3, 4, 5, 6 };
     // 目的数组
     int dest[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
     // 复制源数组中从下标0开始的source.length个元素到目的数组，从下标0的位置开始存储。
     System.arraycopy(source, 0, dest, 0, source.length);

lang包不用引包可以直接用！

封装类也叫包装类！
所谓装箱，就是把值类型用它们相对应的引用类型包起来，使它们可以具有对象的特质，如我们
          可以把int型包装成Integer类的对象，或者把double包装成Double，等等。
所谓拆箱，就是跟装箱的方向相反，将Integer及Double这样的引用类型的对象重新简化为值类型的数据。


public class Arraycopy
{

    public static void main(String[] args)
    {

           int[] aa = {1,2,3,4,5,6};
           int[] bb = {7,8,9,10,11,12};

         // System.out.println(aa);不能这样输出!!!

            for(int i:aa)
            {
               System.out.print(i+" ");
            }

             System.out.println();

            for(int i:bb)
            {
               System.out.print(i+" ");
            }

           System.out.println();

          System.arraycopy(aa,0,bb,0,aa.length);

          for(int i:bb)
            {
               System.out.print(i+" ");
            }
         }
}

/*
输出结果为：
1 2 3 4 5 6

7 8 9 10 11 12

1 2 3 4 5 6

*/