java学习（数组）

本学习内容来自HOW2J.CN

数组的声明与创建

声明数组：int[] a;
注意：声明不会创建数组。
创建数组：a=new int[5];
也可以连起来写：int[] a=new int[5];
取数组长度.length

数组初始化

创建数组没有初始化时，int默认为0。
创建同时赋值：

int[] a=new int[]{1,2,3,4,5};
int[] b={1,2,3,4,5};

数组排序

选择排序

把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来
比较完后，第一位就是最小的
然后再从第二位和剩余的其他所有进行比较，只要比第二位小，就换到第二个位置来
比较完后，第二位就是第二小的，一直循环到最后一位

public class HelloWorld {
    public static void main(String[] args) {
        int a [] = new int[]{18,62,68,82,65,9};
        //排序前，先把内容打印出来
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");
        //选择法排序
        //第一步： 把第一位和其他所有位进行比较
        //如果发现其他位置的数据比第一位小，就进行交换
        for (int i = 1; i < a.length; i++) {
            if(a[i]<a[0]){  
                int temp = a[0];
                a[0] = a[i];
                a[i] = temp;
            }
        }
        //把内容打印出来
        //可以发现，最小的一个数，到了最前面
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");
        //第二步： 把第二位的和剩下的所有位进行比较
        for (int i = 2; i < a.length; i++) {
            if(a[i]<a[1]){  
                int temp = a[1];
                a[1] = a[i];
                a[i] = temp;
            }
        }
        //把内容打印出来
        //可以发现，倒数第二小的数，到了第二个位置
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");       
        //可以发现一个规律
        //移动的位置是从0 逐渐增加的
        //所以可以在外面套一层循环
        for (int j = 0; j < a.length-1; j++) {
            for (int i = j+1; i < a.length; i++) {
                if(a[i]<a[j]){  
                    int temp = a[j];
                    a[j] = a[i];
                    a[i] = temp;
                }
            }
        }
        //把内容打印出来
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");       
    }
}

冒泡排序

第一步：从第一位开始，把相邻两位进行比较
如果发现前面的比后面的大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的
第二步： 再来一次，只不过不用比较最后一位

public class HelloWorld {
    public static void main(String[] args) {
        int a [] = new int[]{18,62,68,82,65,9};
        //排序前，先把内容打印出来
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");
        //冒泡法排序
        //第一步：从第一位开始，把相邻两位进行比较
        //如果发现前面的比后面的大，就把大的数据交换在后面 
        for (int i = 0; i < a.length-1; i++) {
            if(a[i]>a[i+1]){  
                int temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
            }
        }
        //把内容打印出来
        //可以发现，最大的到了最后面
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");
        //第二步： 再来一次，只不过不用比较最后一位
        for (int i = 0; i < a.length-2; i++) {
            if(a[i]>a[i+1]){  
                int temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
            }
        }
        //把内容打印出来
        //可以发现，倒数第二大的到了倒数第二个位置
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");       
        //可以发现一个规律
        //后边界在收缩
        //所以可以在外面套一层循环
        for (int j = 0; j < a.length; j++) {
            for (int i = 0; i < a.length-j-1; i++) {
                if(a[i]>a[i+1]){  
                    int temp = a[i];
                    a[i] = a[i+1];
                    a[i+1] = temp;
                }
            }
        }
        //把内容打印出来
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");       
    }
}

其他

数组长度再分配好空间之后就是不可变的。

for循环快速取值

针对数组，有特殊的for循环进行快速取值：

int[] arr=new int[]{1,2,3,4,5};
for(int i:arr){
	System.out.println(i);
}

复制数组

System.arraycopy(src, srcPos, dest, destPos, length)
//src: 源数组
//srcPos: 从源数组复制数据的起始位置
//dest: 目标数组
//destPos: 复制到目标数组的起始位置
//length: 复制的长度

通过数组复制合成数组：

static void array() {
		int len1=(int)(Math.random()*5+5);
		int len2=(int)(Math.random()*5+5);
		int len3=len1+len2;
		int[] arr1=new int[len1];
		int[] arr2=new int[len2];
		int[] arr3=new int[len3];
		for(int i=0;i<len1;++i) {
			arr1[i]=(int)(Math.random()*100);
			System.out.print(arr1[i]+" ");
		}
		System.out.println();
		for(int i=0;i<len2;++i) {
			arr2[i]=(int)(Math.random()*100);
			System.out.print(arr2[i]+" ");
		}
		System.out.println();
		System.out.print("合成数组为：");
		System.arraycopy(arr1, 0, arr3, 0, len1);
		System.arraycopy(arr2, 0, arr3, len1, len2);
		for(int i=0;i<len3;++i) {
			System.out.print(arr3[i]+" ");
		}
	}

二维数组

初始化二维数组

public class HelloWorld {
    public static void main(String[] args) {
        //初始化二维数组，
        int[][] a = new int[2][3]; //有两个一维数组，每个一维数组的长度是3
        a[1][2] = 5;  //可以直接访问一维数组，因为已经分配了空间
        //只分配了二维数组
        int[][] b = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配
        b[0]  =new int[3]; //必须事先分配长度，才可以访问
        b[0][2] = 5;
        //指定内容的同时，分配空间
        int[][] c = new int[][]{
            {1,2,4},
            {4,5},
            {6,7,8,9}
        };
    }
}

Arrays类

Arrays是针对数组的工具类，需要import java.util.Arrays;。

Arrays类中的方法

方法	说明	输出
copyOfRange	数组复制	数组
toString	转换为字符串	字符串
sort	排序	数组
binarySearch	搜索	int
equals	判断相同	boolean
fill	填充	数组

数组复制 Arrays.copyOfRange(arr, int from, int to)

// copyOfRange(int[] original, int from, int to)
        // 第一个参数表示源数组
        // 第二个参数表示开始位置(取得到)
        // 第三个参数表示结束位置(取不到)
int arr[] = new int[] { 1,2,3,4,5 };
int[] arr2=Arrays.copyOfRange(arr,0,3)

排序 Arrays.sort(arr)

排序后直接改变原数组

比较数组 Arrays.equals(arr1, arr2)

相同返回true，不同返回false

填充 Arrays.fill(arr, int num)

用num填充整个数组