java 数组详解

from : http://blog.csdn.net/jionjionyoushen/article/details/6223006

 

1．关于数组的特点

 

1）在Java中，无论使用数组或集合，都有边界检查。如果越界操作就会得到一个RuntimeException异常。

 

2）数组只能保存特定类型。数组可以保存原生数据类型，集合则不能。集合不以具体的类型来处理对象，它们将所有对象都按Object类型处理，集合中存放的是对象的引用而不是对象本身。

 

3）集合类只能保存对象的引用。而数组既可以创建为直接保存原生数据类型，也可以保存对象的引用。在集合中可以使用包装类（Wrapper Class），如Integer、Double等来实现保存原生数据类型值。

例码：int a = 10;

         Integer integer = new Integer(a);

         int b = integer.intValue();

         System.out.println(a = b);

 

4）对象数组和原生数据类型数组在使用上几乎是相同的；唯一的区别是对象数组保存的是引用，原生数据类型数组保存原生数据类型的值。

 

2．关于数组定义

 

     1）一维数组的声明方式：  type var[];      或type[] var;

 

         声明数组时不能指定其长度（数组中元素的个数），

 

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

         例码：int num[];

            num=new int[3];

 

             或  int num[]=new int[3];

   

2）可以这样定义二维数组。

     例码：

            int [][] num;

            num=new int[3][];

            num[0]=new int[5];

            num[1]=new int[3];

            num[2]=new int[2];

          //定义了一个二维数组num,这个数组有三行，第一行5个元素，第二行3个元素，第三行2个元素。

 

3）关于数组初始化

 

*动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
      
 
  1. public class TestD  {   
  2.         
  3.    public static void main(String args[]) {        
  4.        int a[] ;        
  5.        a = new int[3] ;     
  6.        a[0] = 0 ;  
  7.        a[1] = 1 ;  
  8.        a[2] = 2 ;   
  9.        Date days[] ;  
  10.        days = new Date[3] ;   
  11.        days[0] = new Date(2008,4,5) ;       
  12.        days[1] = new Date(2008,2,31) ;   
  13.        days[2] = new Date(2008,4,4) ;  
  14.     }   
  15. }     
  16. class Date  {        
  17.  int year,month,day ;     
  18.     Date(int year ,int month ,int day) {  
  19.            this.year = year ;  
  20.            this.month = month ;  
  21.            this.day = day ;  
  22.        }  
  23.   }    

 

 

 

*静态初始化：在定义数字的同时就为数组元素分配空间并赋值；

 
 
  1. public class TestS {  
  2.        public static void main(String args[]) {     
  3.              int a[] = {0,1,2} ;  
  4.              Time times [] = {new Time(19,42,42),new Time(1,23,54),new Time(5,3,2)} ;  
  5.      }  
  6. }  
  7.         
  8. class Time｛  
  9.           int hour,min,sec ;  
  10.           Time(int hour ,int min ,int sec) {  
  11.               this.hour = hour ;  
  12.               this.min = min ;  
  13.               this.sec = sec ;  
  14.           }  
  15.      }      

 

 

 

 


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

 

 
 
  1. public class TestDefault {  
  2.          public static void main(String args[]）  
  3. {  
  4.             int a [] = new int [5];  
  5.             System.out.println("" + a[3]);  
  6.      }  
  7. }     

 

 

3.关于数组的相关操作

 

1）在Java中，所有的数组都有一个缺省的属性length，用于获取数组中元素的个数。

 

2）数组的复制：System.arraycopy()。

 

3）数组的排序：Arrays.sort()。

 

4）在已排序的数组中查找某个元素：Arrays.binarySearch()。

 

4.数组使用示例：

 

1） 循环初始化数组元素
             要求：初始化一个长度为100的int数组，数组中的元素依次为1-100。
             这是一个基本的使用，主要是熟悉数组的语法，在实际编写时，需要发现数组下标和数组元素值之间的规律即可。
             第一种思路：循环数组的下标0-99，则和下标对应的元素的值比数组下标多1。
             则实现代码如下：
                       int[] m = new int[100];
                       for(int i = 0;i < m.length;i++){
                                m[i] = i + 1;
                       }
             代码说明：声明并初始化一个长度是100的数组，使用循环循环数组的下标，下标的区间是[0,m.length-1]，其中m.length表示数组的长度。在实际赋值时，把数组的下标做成变量，则当i的值为0时，则m[i]就是m[0]，依次类推，按照题目的要求，则数值的规律是i+1，这样循环结束以后，数组m中的值就依次是1-100了。
             第二种思路：循环数组的值1-100，则下标比数组的值下1。
             则实现的代码如下：
                       int[] m = new int[100];
                       for(int i = 1;i <= 100;i++){
                                m[i – 1] = i;
                       }
             该代码中循环变量i的值从1循环到100，则数组的下标是i – 1，这样也可以实现题目要求的功能。
    2）输出数列
             要求：输出1 1 2 3 5 8 13……这样的数列，输出该数列的前20个数字。
             该题是一个基本的数字逻辑，在实际解决该问题时，首先要发现该数字的规律，然后按照该规律来设计数组即可。
             实现思路：数字的规律是除了数列里的前两个数字以外，其它的数字都满足该数字等于前两个数字的和，由于题目要求输出前20个数字，所以需要一个长度为20的数组，第一个和第二个数字直接赋值，后续的数字通过前两个数字元素得到。
             则实现的代码如下：
                       int[] num = new int[20];
                       num[0] = 1;
                       num[1] = 1;
                       //循环初始化
    for(int i = 2;i < num.length;i++){
                                num[i] = num[i – 1] + num[i – 2];
                       }
                       //循环输出
    for(int i = 0;i < num.length;i++){
                                System.out.print(num[i]);
                                System.out.print(‘ ‘);
                       }
                       System.out.println(); //换行

 

在该代码中，初始化一个长度为20的数组，首先将数组中的前两个元素赋值成1，然后循环对后续的元素的赋值，如果当前元素的下标是i，则它前一个元素的下标是i-1，再前面一个元素的下标是i-2，只需要将这2个元素的值相加，然后赋值给当前元素即可。后面使用一个循环，输出数组中所有的元素，元素和元素之间有一个间隔的空格，在输出所有的元素以后换行。

posted @ 2016-04-13 21:06  英特费斯  阅读(195)  评论(0)  编辑  收藏  举报