（3）数组

1.数组的类型可以是任意类型吗？数组元素有序吗？

数组的类型可以是任意类型，不过数组中的元素类型必须是相同的。

数组的元素是有序的，按照索引的顺序。

2.数组的元素可变不？数组的长度属于哪个属性？数组下标范围是？

数组一旦声明就不能更改，

长度属性为length，

范围是 0 ~ 数组名.length-1。

3.数组是引用类型，数组是对象，对吗？

对，数组是引用数据类型，数组也是对象。

4.数组中的元素就像对象的成员变量一样，初始化方式也一样吗？

对。

5.数组的三种初始化方式是什么？

//静态初始化
int [] a = {1,2,3};

//动态初始化
int [] a = new int[2];
a[0] = 1;
a[1] = 2;

//默认初始化
int [] a = new int[2]; //0,0

6.数组的初始化代码，下面的代码有没有不合理的地方：

Dog[] dogs = {
    new Dog("大黄",1)，
    new Dog("小强",2)，
};

有，第二个new Dog（）后去掉逗号。

7.编写程序，循环遍历输出数组中的26个大写字母

public class Test {
     public static void main(String[] args) {
        char[] s;
        s = new char[26];
        for(int i=0;i<26;i++) {
            s[i] = (char)('A'+i);
            System.out.println(s[i]);
        }
    }
}

8.对于数组的定义，下列哪些语句是正确的？

A. int a[][] = new int[3,3];         B. int a[3][3] = new int[][];         C. int a[][] = new int[3][3];   

D. int []a[] = new int[3][3];        E. int[][]a = new int[3][3];           F. int[][] a = new int[2][];      

G. int[][] a = new int[][4];          H. int a[][4] = new int[3][4];        I. int a[2][3];

上述C、D、E、F正确

9.定义一个长度为10的一维字符串数组，在每一个元素存放一个单词，然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，否则，打印“No”。

public class Test {
    public static boolean isFind(String [] arr,String word) {
        boolean isFlag = false;
        for(int i=0; i<arr.length; i++) {
            if(word.equals(arr[i])) {
                isFlag = true;
                break;
           }
        }
        return isFlag;
    }

    public static void main(String [] args) {
        String[] arr = {"hello","java","Oracle","iPhone","web","Internet","wechat","baidu","Alibaba","Yahoo"};       
        System.out.println(isFind(arr,args[0])?"Yes":"No");
    }
}

10.冒泡排序的基本思路，代码实现用冒泡排序法给数组元素排序

基本思路：

1）.整个数列分成两部分：前面是无序数列，后面是有序数列；

2).初始状态下，整个数列都是无序的，有序数列是空的；

3).如果一个数列有n个元素，则至多需要n-1趟才能保证数列有序；

4).每一趟循环可以让无序数列最大数排到最后，也就是有序数列元素增加1；

5).每一趟从数列的第一个元素开始进行比较，依次比较相邻的两个元素，比较到无序数列的末尾；

6).如果前一个大于后一个，交换；

7).根据是否交换判断数组是否已经有序。

代码实现数组的冒泡排序：

public class Test {
    public static void main(String[] args) {
        int[] array = {34,52,25,78,9,19};
	    for(int i=0; i<array.length-1; i++) {
		boolean flag = true;
		for(int j=0; j<array.length-1-i; j++) {
		    if(array[j]>array[j+1]) {
			int temp = array[j];
			array[j] = array[j+1];
			array[j+1] = temp;
			flag = false;
		    }
		}
		if(flag) {
		    break;
		}
	    }
            for(int i=0; i<array.length; i++) {
            System.out.println(array[i]+"\t");
        }
    }
}

11.可变参数的作用与其用法：

作用：

     适用于参数个数不确定、类型确定的情况，Java把可变参数当作数组处理

用法：

     只能出现在参数列表的最后

     ...位于变量类型和变量名之间，前后有无空格都可以

     调用可变参数的方法时，编译器为该可变参数隐含创建了一个数组，在方法体中以数组的形式访问可变参数。

12.如何给main方法传递实参？

通过命令行参数给main方法传递实参。

13.使用二重循环求出二维数组b所有元素的和。

public class Test {
    public static void main(String[] args) {   
        int[][] b = {{11},{21,22},{31,32,33}};
	int sum = 0;
	for(int i=0; i<b.length; i++) {
	   for(int j=0; j<b[i].length; j++) {
		sum += b[i][j];
	   }
	}
	System.out.println("和为："+sum);
    }
}

14.画图说明初始化元素为基本类型的数组在内存的变化。

public class Array1 {
    public static void main(String[] args) {
        int[] s;
        s = new int[5];
        for(int i=0;i<5;i++) {
            s[i] = i;
        }
    }
}

15.画图说明初始化元素为引用类型的数组在内存的变化。

public class Array2Date {
    public static void main(String[] args) {
        Date[] days;
        days = new Date[3];
        for(int i=0; i<3; i++) {
            days[i] = new Date(2018,4,11);
        }
    }
}

class Date {
    int year;
    int month;
    int day;
    Date(int year,int month,int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

注意：元素为引用数据类型的数组，其中的每一个元素都需要被初始化。

16.写一个元素为整型的数组选择排序的方法。

public class Array3SelectedSort {
    public static void main(String[] args) {
        int a[] = {5,45,15,2,7,81,2};
        print(a);
        System.out.println();
        selectIntSort(a);
        print(a);
    }
    //打印数组元素
    public static void print(int[] a) {
        for(int i=0; i<a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }

    //给int类型数组排序
    public static int[] selectIntSort(int[] a) {
        int k,temp; //i每增加1，k用于标记没排序中最小的那个数，然后与i所在位置的数交换，i之前的都是排好的不用去管
        for(int i=0; i<a.length; i++) {
            k = i;
            for(int j=k+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;
            }
        }
        return a;
    }

}