JAVA数组

数组

一维数组

数组声明：数据类型[ ] 数组名
例：int[] name： 这里的int[] 是应用数据类型，[]表示该变量是一个数组，int 表示数组里的每一个元素都是一个整数。name：变量名

创建数组：数组名 = new 数据类型 [ 数组长度 ]; 数组长度可以为任意整数。
例：int [] a=new int[10]
a:表示引用；，指向数组

数组赋值与访问数组

int [] ages = {12,18,9,33,45,60}; 
ages[0]=12;

package first;
import java.util.Scanner;
public class Oneday {
    public static void main(String[] args) {
        //Scanner s=new Scanner(System.in);
        int[] a=new int[]{1,2,3};

        int []b={1,2,3};

        //int[] a=new int[3]{1,2,3}; 如果指定了数组的内容，就不能同时设置数组的长度
        
    }
}

数组元素（例如上面的12）既可以是基本类型的值，也可以是对象（实际上保存的是对象的引用变量）
访问：访问数组通过他的下标来访问，其中的某个数字代表具体的值。

实例1：求最小值

package first;
import java.util.Scanner;
public class Oneday {
    public static void main(String[] args) {
        //Scanner s=new Scanner(System.in);
        int[] a = new int[5];
        for (int j=0;j<5;j++){
            a[j]=(int)(Math.random()*100);
            //System.out.print(a[j]+" ");
        }
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
            int min = a[0];
            for (int i = 0; i < a.length; i++) {

                if (a[i] < min) {
                    min = a[i];
                } else {
                    continue;
                }

            }
        System.out.println("最小值为："+ min);

    }
}

选择排序法

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(" ");       
    }
}

增强for循环

package first;
import java.util.Scanner;
public class Oneday {
    public static void main(String[] args) {
        //Scanner s=new Scanner(System.in);
        int each[] = new int[]{18, 62, 68, 82, 65, 9};
        for (int i = 0; i < each.length; i++) {
            System.out.print(each[i] + " ");
        }

        for(int values:each){   //values 为变量，each为应用
            System.out.println(values);
        }
    }
}

数组copy

package first;
import java.lang.*;
import java.util.Scanner;
public class Oneday {
    public static void main(String[] args) {
        //Scanner s=new Scanner(System.in);
        int a[] = new int[]{18, 62, 68};
        int b[] =new int[3];
        for (int i=0;i<a.length;i++){
            b[i]=a[i];
            System.out.println(b[i]);
        }

        //src: 源数组
        //srcPos: 从源数组复制数据的起始位置
        //dest: 目标数组
        //destPos: 复制到目标数组的启始位置
        //length: 复制的长度       
        System.arraycopy(a, 1, b, 1, 2);
        for(int i=0;i<a.length;i++){
            System.out.println(b[i]);
        }
    }
}

二维数组

这是一个一维数组, 里面的每一个元素，都是一个基本类型int

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

这是一个二维数组，里面的每一个元素，都是一个一维数组
所以二维数组又叫数组的数组

package first;
import java.lang.*;
import java.util.Scanner;
public class Oneday {
    public static void main(String[] args) {
        //Scanner s=new Scanner(System.in);

        //初始化二维数组，
        int a[][] = new int[2][3]; //有两一维数组，每个一维数组的长度是3
        int b[][] = new int[][]{{1, 2, 3}, {2, 2, 2}};
        System.out.println(b[0][2]);//数组从0开始，输出3
        a[1][2] = 2;  //可以直接访问一维数组，因为已经分配了空间

        int[][] c = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配
        c[0]  =new int[3]; //必须事先分配长度，才可以访问
        c[0][2] = 5;
    }
}

数组使用：Arrays

数组复制

与使用System.arraycopy进行数组复制类似的， Arrays提供了一个copyOfRange方法进行数组复制。
不同的是System.arraycopy，需要事先准备好目标数组，并分配长度。 copyOfRange 只需要源数组就就可以了，通过返回值，就能够得到目标数组了。
除此之外，需要注意的是 copyOfRange 的第3个参数，表示源数组的结束位置，是取不到的。

package first;
import kotlin.reflect.jvm.internal.impl.load.kotlin.KotlinJvmBinaryClass;
import java.lang.*;
import java.util.Arrays;
import java.util.Scanner;
public class Oneday {
    public static void main(String[] args) {
        //Scanner s=new Scanner(System.in);
        int[] a=new int[3];
        int b []={1,2,3};

        int [] c= Arrays.copyOfRange(b,0,3);
        for(int i=0;i<c.length;i++){
            System.out.println(c[i]);
        }

    }
}

转换为字符串

package first;
import kotlin.reflect.jvm.internal.impl.load.kotlin.KotlinJvmBinaryClass;

import java.lang.*;
import java.util.Arrays;
import java.util.Scanner;
public class Oneday {
    public static void main(String[] args) {
        //Scanner s=new Scanner(System.in);
        int[] a=new int[3];
        int b []={1,2,3};
        
        String content=Arrays.toString(b);
        for(int i=0;i<b.length;i++){
            System.out.println(content);
        }

    }
}

排序

package first;
import java.lang.*;
import java.util.Arrays;
import java.util.Scanner;
public class Oneday {
    public static void main(String[] args) {
        //Scanner s=new Scanner(System.in);
        int[] a=new int[3];
        int b []={4,2,3};

        System.out.println("排序之前");
        System.out.println(Arrays.toString(b));

        System.out.println("排序之后");
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));

        for(int i=0;i<b.length;i++){
            //System.out.println(content);
        }

    }
}

搜寻

package first;
import java.lang.*;
import java.util.Arrays;
import java.util.Scanner;
public class Oneday {
    public static void main(String[] args) {
        //Scanner s=new Scanner(System.in);
        int[] a=new int[]{4,2,3;
        int b []={4,2,3};
        

        Arrays.sort(b);
        System.out.println(Arrays.toString(b));
        //使用binarySearch之前，必须先使用sort进行排序
        System.out.println("数字3出现的位置"+Arrays.binarySearch(b,3));

    }
}

判断是否想等

package first;
import java.lang.*;
import java.util.Arrays;
import java.util.Scanner;
public class Oneday {
    public static void main(String[] args) {
        //Scanner s=new Scanner(System.in);
        int[] a=new int[]{4,2,3};
        int b []={4,2,3};
        System.out.println(Arrays.equals(a,b));

    }
}

填充

package first;
import java.lang.*;
import java.util.Arrays;
import java.util.Scanner;
public class Oneday {
    public static void main(String[] args) {
        //Scanner s=new Scanner(System.in);
        int[] a=new int[10];
        int b []={4,2,3};
        Arrays.fill(a,6);
        System.out.println(Arrays.toString(a));

    }
}