Java程序设计基础（二）

---

java中怎样使用数组

数组是java编程语言的重要语法，使用数组可以解决很多问题，这篇文章给大家讲解怎样使用数组，对于刚接触编程的或者不会使用数组的同学们可以学习下。

为什么需要数组。当我们定义一个变量时可以使用一个变量名表示，但是如果出现很多的变量我们分别起变量名代替表示存储就比较麻烦了，为了解决这样的问题我们采用数组的形式表示存储，使用下标表示每个变量。

生活中使用数组案例。生活中使用数组可以使商品等分类清楚明了，便于我们管理，数组也一样，相同类型的一类数据。

什么是数组。学习怎样使用数字之前我们简单介绍下什么是数组，便于我们使用数组。增加我们对数组的认识，了解数组的使用方法。

数组概述：
1、数组可以看成是多个相同数据类型数据的组合，对这些数据的统一管理。
2、数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
3、数组中的元素可以是任何类型，包括基本类型和引用类型。


如何使用数组。我们学习了java中数组的定义和意思，但是怎么使用呢？我们在实验数组的时候使用关键字NEW进行实例化数组，才能使用，从第五步开始我们详细介绍。

使用前先声明数组。声明数组就是告诉计算机数据类型是什么。具体实现步骤如下

然后分配空间。分配空间就是告诉计算机分配几个连续的空间 。

最后给数组赋值。给数组赋值就是向分配的格子里放数据、

如何给数组赋值。上面我们介绍了给数组赋值，但是具体怎样赋值呢？一般有两种情况，也是最经常使用的情况，记住不要使数组的大小超过长度。

使用数组常见错误一。在大家编程时使用数组很容易出现错误，下面我们把常见的容易出错的地方给大家列举出来，大家学习下。

使用数组常见错误二。数组越界。

使用数组常见错误三。语法错误。

注意事项：
定义数组的范围不要超过索引。
数组名尽量命名要有意义。

一维数组

一维数组，可以理解为只能存放一行相同数据类型的数据。

一维数组的12个最佳方法

1、声明一个数组

Java代码

String[] aArray = new String[5];  
String[] bArray = {"a","b","c", "d", "e"};  
String[] cArray = new String[]{"a","b","c","d","e"};  

2、输出一个数组

Java代码

int[] intArray = { 1, 2, 3, 4, 5 };  
String intArrayString = Arrays.toString(intArray);  

// print directly will print reference value  
System.out.println(intArray);  
// [I@7150bd4d  

System.out.println(intArrayString);  
// [1, 2, 3, 4, 5]  

3、从一个数组创建数组列表

Java代码

String[] stringArray = { "a", "b", "c", "d", "e" };  
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));  
System.out.println(arrayList);  
// [a, b, c, d, e]  

4、检查一个数组是否包含某个值

Java代码

String[] stringArray = { "a", "b", "c", "d", "e" };  
boolean b = Arrays.asList(stringArray).contains("a");  
System.out.println(b);  
// true  

5、连接两个数组

Java代码

int[] intArray = { 1, 2, 3, 4, 5 };  
int[] intArray2 = { 6, 7, 8, 9, 10 };  
// Apache Commons Lang library  
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);  

6、声明一个内联数组（Array inline）

Java代码

method(new String[]{"a", "b", "c", "d", "e"});  

7、把提供的数组元素放入一个字符串

Java代码

// containing the provided list of elements  
// Apache common lang  
String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");  
System.out.println(j);  
// a, b, c  

8、将一个数组列表转换为数组

Java代码

String[] stringArray = { "a", "b", "c", "d", "e" };  
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));  
String[] stringArr = new String[arrayList.size()];  
arrayList.toArray(stringArr);  
for (String s : stringArr)  
    System.out.println(s);  

9、将一个数组转换为集（set）

Java代码

Set<String> set = new HashSet<String>(Arrays.asList(stringArray));  
System.out.println(set);  
//[d, e, b, c, a]  

10、逆向一个数组

Java代码

int[] intArray = { 1, 2, 3, 4, 5 };  
ArrayUtils.reverse(intArray);  
System.out.println(Arrays.toString(intArray));  
//[5, 4, 3, 2, 1]  

11、移除数组中的元素

Java代码

int[] intArray = { 1, 2, 3, 4, 5 };  
int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array  
System.out.println(Arrays.toString(removed));  

12、将整数转换为字节数组

Java代码

byte[] bytes = ByteBuffer.allocate(4).putInt(8).array();  

for (byte t : bytes) {  
   System.out.format("0x%x ", t);  
}  

一维数组的应用

下面举一个用ars输入10个数，并且用选择排序，从小到大排序的示例：

publicclass TestSortInt{
    publicstaticvoid main(String args[]){
        int[] a = newint[args.length];
        for(int i=0; i<args.length; i++){
            a[i] = Integer.parseInt(args[i]);
        }
        int k,temp;
        for(int i=0; i<a.length; i++){
            k = i;
            for(int j=i+1; j<a.length; j++){
                if(a[k]>a[j]){
                    k=j;
                 }
            }
            if(k!=i){
                temp = a[i];
                a[i] = a[k];
                a[k] = temp;
            }
        }
        for(int i=0; i<a.length; i++){
            System.out.print(a[i] + " ");
        }
    }
}

下面我们用数组里面装一个日期类型做排序的示例，用了冒泡排序。

publicclass TestDateSort{
    publicstaticvoid main(String args[]){
        Date[] date = new Date[5];
        date[0] = new Date(2006,5,4);
        date[1] = new Date(2006,7,4);
        date[2] = new Date(2008,5,4);
        date[3] = new Date(2004,5,9);
        date[4] = new Date(2006,5,4);

        bubbleSort(date);

        for(int i=0; i < date.length; i++){
            System.out.println(date[i]);
        }
    }
    publicstatic Date[] bubbleSort(Date[] a){
        int len = a.length;
        for(int i=len; i>=1; i--){
            for(int j=0; j<i-1; j++){
                if(a[j].compare(a[j+1])>0){
                    Date temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
                }
            }
        }
        return a;
    }
}
class Date{
    privateint year,month,day;
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    publicint compare(Date date){
        return year>date.year?1
               :year<date.year?-1
               :month>date.month?1
               :month<date.month?-1
               :day>date.day?1
               :day<date.day?-1
               :0;
    }
    public String toString(){
        return "year,month,day ---- " +year+" - "+month+" - "+day;
    }
}

有了数组之后，我们可以设计各种各样的排序算法。然后在排好序的时候，我们又可以设计各种各样的查找算法，接下来，我们用数组实现一个简单的二分法查找算法

publicclass TestSearch{
    publicstaticvoid main(String args[]){
        int[] a = {12,23,41,53,24,57,32,52,98,43,19,73};
        int postion = binarySearch(a,57);
        System.out.println(postion);
    }
    publicstaticint binarySearch(int[] a, int searchNum){

        if(a.length==0)return -1;

        int startFlag = 0;
        int endFlag = a.length-1;
        int m = (startFlag+endFlag)/2;
        while(startFlag<=endFlag){
            if(a[m] == searchNum){
                return m;
            }elseif(a[m]<searchNum){
                startFlag = m+1;
            }elseif(a[m]>searchNum){
                startFlag = m+1;
            }
            m = (startFlag+endFlag)/2;
        }
        return -1;
    }
}

二维数组

二维数组可以理解是数组的数组。

二维数组基础

基本的定义方式有两种形式，如：
type[][] i = new type[2][3];（推荐）
type i[][] = new type[2][3];
如下程序：

publicclass ArrayTest3
{
      publicstaticvoid main(String[] args)
      {

             int[][] i = newint[2][3];

             System.out.println("Is i an Object? "
                           + (i instanceof Object));

             System.out.println("Is i[0] an int[]? "
                           + (i[0] instanceofint[]));

      }
}

输出结果是两个true。

变长的二维数组

二维数组的每个元素都是一个一维数组，这些数组不一定都是等长的。
声明二维数组的时候可以只指定第一维大小，空缺出第二维大小，之后再指定不同长度的数组。但是注意，第一维大小不能空缺（不能只指定列数不指定行数）。
如下程序：

publicclass ArrayTest4
{
    publicstaticvoid main(String[] args)
    {
        //二维变长数组int[][] a = newint[3][];
        a[0] = newint[2];
        a[1] = newint[3];
        a[2] = newint[1];

        //Error: 不能空缺第一维大小
        //int[][] b = new int[][3];    
     }
}

二维数组也可以在定义的时候初始化，使用花括号的嵌套完成，这时候不指定两个维数的大小，并且根据初始化值的个数不同，可以生成不同长度的数组元素。
如下程序：

publicclass ArrayTest5
{
    publicstaticvoid main(String[] args)
    {

        int[][] c = newint[][]{{1, 2, 3},{4},{5, 6, 7, 8}};

        for(int i = 0; i < c.length; ++i)
        {
            for(int j = 0; j < c[i].length; ++j)
            {
                System.out.print(c[i][j]+" ");        
            }

            System.out.println();
        }

    }
}

输出：
　　1 2 3
　　4
　　5 6 7 8

二维数组的应用

二维数组：
　　1、二维数组可以看成是以数组为元素的数组。例如：
　　　　int a[][] = {{1,2},{3,4,5,6},{7,8,9}};
　　2、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];//这种声明是非法的
二维数组初始化：
1、静态初始化：
　　　　int intA[][] = {{1,2},{2,3},{3,4,5}};
　　　　int intB[3][2] = {{1,2},{,2,3},{4,5}};//非法声明方式
2、动态初始化：
　　　　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];
二维数组举例：

publicclass Test{
    publicstaticvoid 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("["+i+"]"+"["+j+"]="+a[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

二维数组举例（引用类型的二维数组）：

publicclass Test{
    publicstaticvoid main(String args[]){
        String s[][];
        s = new String[3][];
        s[0] = new String[2];
        s[1] = new String[3];
        s[2] = new String[2];

        for(int i=0; i<s.length; i++){
            for(int j=0; j<s[i].length; j++){
                s[i][j] = new String("我的位置是："+i+","+j);
            }
            System.out.println();
        }
        for(int i=0; i<s.length; i++){
            for(int j=0; j<s[i].length; j++){
                System.out.print(s[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

数组的拷贝：
　　1、使用java.lang.system类的静态方法
　　　　public static void arrayCopy(object src,int srcPos,object dest,int destPos,int length){}
　　2、可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的lenght个元素。
　　3、如果源数据数目超过目标数组边界会抛出IndexOutOfBoundsException异常。
数据拷贝举例：

import java.lang.System;
publicclass TestArrayCopy{
    publicstaticvoid main(String args[]){
        String[] s = {"Microsoft","IBN","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.print(sBak[i]+" ");
        }
        System.out.println();

        int[][] intArray = {{1,2},{1,2,3},{3,4}};
        int[][] intArrayBak = newint[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();
        }
    }
}