数组一

一维数组

一维数组的声明

 一维数组的声明方式：

type var[]; 或type[] var;
   例如：
   int a1[]; int[] a2;
   double b[];
   Person[] p1; String s1[];
   java语言中声明数组时不能指定其长度（数组中元素的个数），例如：
   int a[5] ;                     //非法（C中可以）
 
 
  除了基础的数据类型以外，java中所以的类型都是引用类型。
  java中数组是存放在堆中的。

数组对象的创建

  java 中使用关键字new创建数组对象，格式为：
    数组名=new 数组元素的类型 [数组元素的个数]
   
    如
    int []s;
    s=new int[5];

数组初始化

动态初始化

数组定义与为数组分配空间和赋值的操作分开进行，如

    public class Test{
       public static void main(String[] args){
          int a[];                           //声明了一个数组名字，栈空间里分配了一个空间（该空间里的引用是指向堆里为数组分配的空间的。）
          a=new int[3];                      在堆里为数组分配空间了
          a[0]=1;a[1]=2;a[2]=3
          Date days[];
          days=new Date[3];
          days[0]=new Date(1,4,2004);
          days[1]=new Date(2,4,2004);
          days[2]=new Date(3,4,2004);
          
       }
     }
    class Date{
        int year,month,day;
        Date(int y,int m,int d){
           year=y;month=m;day=d;
        }
     }

 

 

静态初始化

在定义数组的同时就为数组元素分配空间并赋值，例如：

     public class Test{
       public static void main(String[] args){
          int a[]={1,2,3};
          Date days[]={
                new Date(1,4,2004);
                new Date(2,4,2004);
                new Date(3,4,2004);
          };
         
       }
     }
     
     
     class Date{
        int year,month,day;
        Date(int y,int m,int d){
           year=y;month=m;day=d;
        }
     }

数组元素的默认初始化

数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化，如：

    public class Test{
       public static void main(String[] args){
          int a[]=new int[3];                      
          Date days[]=new Date[3];
          
          System.out.println(a[3]);
          System.out.println(days[2]);
          
       }
     }
    class Date{
        int year,month,day;
        Date(int y,int m,int d){
           year=y;month=m;day=d;
        }
     }
     
     输出结果：0
             null

数组元素的引用

 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素，数组元素的引用方式为arrayName[index]
      a.length   //不是a.length()!
      查看本地主机ip信息的命令行参数
      ipconfig
      ipconfig -all

String[] args 的情况

public class TestArgs1{
	public static void main(String[] args){
		for(int i=0;i<args.length;i++){
			System.out.println(args[i]);
			}
		}
	}
	
	
	javac TestArray1.java
	java TestArray1 asd 123 yre ouus
输出:asd
     123
     yre
     ouus

 

 

public class TestArgs2{
	public static void main(String[] args){
		if(args.length<3){
			System.out.println("出错啦！");
			System.exit(-1);
			}
			double d1=Double.parseDouble(args[0]);  //将字符串转换成double类型
			double d2=Double.parseDouble(args[2]);
			double d=0;
			if(args[1].equals("+")) d=d1+d2;
			else if(args[1].equals("-"))d=d1-d2;
			else if(args[1].equals("x"))d=d1*d2;      //注意此处的  x  和   *
			else if(args[1].equals("/"))d=d1/d2;
			else{
				System.out.println("Error operator!");
				System.exit(-1);
				}
				System.out.println(d);
		}
	}

二维数组

二维数组的声明

二维数组可以看成以数组为元素的数组。例如：
        int a[][]={{1,2},{3,4,5,6},{7,8,9}};
        java中多维数组的声明和初始化应按从高维到低维的顺序进行，例如：
         int a[][]=new int [3][];
         a[0]=new int [2];
         a[1]=new int [4];
         a[2]=new int [3];
         int t1[][]=new int [][4];   //非法

二维数组初始化

静态初始化： 

        int A[][]={{1,2},{2,3},{3,4,5}};

        int B[3][2]={{1,2},{2,3},{3,4,5}};        //非法

动态初始化：

int a[][]=new int[3][5];
        int b[][]=new int[3][];
        b[0]=new int[2];
        b[1]=new int[3];
        b[2]=new int[5];

 

public class Test{
	public static void main(String[] args){
		int a[][]={{1,2},{3,4,5,6},{7,8,9}};
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a[i].length;j++){
				System.out.print("a["+i+"]["+j+"]="+a[i][j]+"  ");
				}
				System.out.println();
			}
		}
}

数组的拷贝

使用java.lang.System类的静态 public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
         
          如果源数据数目超过目标数组边界会抛出异常IndexOutOfBoundsException

 

public class TestArrayCopy{
	public static void main(String[] args){
		
		String[] s={"Mcrosoft","IBM","Sun","Oracle","Apple"};
		String[] sBak=new String[6];
		System.arraycopy(s,0,sBak,0,s.length);
		
		for(int i=0;i<sBak.length;i++){
			System.out.println(sBak[i]+" ");
			}
			
			System.out.println();
			
			int[][] intArray={{1,2},{1,2,3},{3,4}};
			int[][] intArrayBak=new int[3][];
			System.arraycopy(intArray,0,intArrayBak,0,intArray.length);
			intArrayBak[2][1]=100;
			
			for(int i=0;i<intArray.length;i++){
				for(int j=0;j<intArray[i].length;j++){
					System.out.print(intArray[i][j]+"  ");
					}
					System.out.println();
				}
		
		}

}