java 获取数组第一个值 java取数组第一个元素

数组的特点：

　　①数组是有序排列的

　　②数组属于引用数据类型。但是他的元素可以是基本数据类型也可以是引用数据类型

　　③创建数组会在内存开辟一整块连续的空间

　　④数组的长度一旦确定就不能修改

 一维数组

1.数组的初始化

int[] arr1;//声明
        int[] arr2;
        //静态初始化
        arr1 = new int[]{100,200,300,400};
        //动态初始化
        arr2 = new int[4];
        String[]  strs = new String[5];

 

2.调用数组的指定位置元素

通过索引/角标来调用。索引和角标都是从0开始，数组长度-1结束。基本上所有的索引都是从0开始。例:string.charAt[0]----获取字符串的第一个字符

strs[0] = "aaa";
        strs[1] = "bbb";
        strs[2] = "ccc";
        strs[3] = "ddd";
        strs[4] = "eee";

System.out.println(strs[1]);

3.数组的长度

System.out.println(strs.length);//5
        System.out.println(arr1.length);//4

4.遍历数组元素

 

for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }

 

 

 

5.默认初始化值
    整形：0
    浮点型：0.0
    字符型：0  注意不是'0'
    布尔：false
    对象数组：null

 

6.堆和栈
简单说栈存放的是局部变量
推存放new出来的结构，对象和数组
方法区：有常量池（字符串），静态域，类加载等等

 

 

 

 

由于声明数组都是在main方法里，所有这里arr，arr1都在栈中

当执行到第5行代码时，其中的0x12ab可能会被自动垃圾回收

这里的“刘德华”“张学友”是放在常量池中的

 

 

练习：从键盘中输入学生个数与学生成绩，求出最大值以及对应的等级

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入学生人数:");
    int num = sc.nextInt();
    int[] arr = new int[num];
    for (int i = 0; i <arr.length ; i++) {
        System.out.println("请输入第"+ (i+1) +"个同学的成绩");
        arr[i] = sc.nextInt();
    }
    //获取数组中的最大值
    int maxNum = 0;
    for (int i = 0; i < arr.length; i++) {
        if (maxNum < arr[i]){
            maxNum = arr[i];
        }
    }
    for (int i = 0; i < arr.length; i++) {
        String flags;
        if (arr[i] > 90){
            flags = "A";
        }else if (arr[i] > 60 && arr[i] <= 90){
            flags = "B";
        }else {
            flags = "C";
        }
        System.out.println("这"+num+"个同学的等级分别是" + flags);
    }
    System.out.println("最高成绩是" + maxNum);
}

 

 二维数组

1.初始化

int [][] arr = new int[][]{{1,3,4},{3,6},{1,45,6}};
        int [][] arr2 = new int[4][5];
        String[][] stt = new String[3][];

2.输出指定位置元素

 

System.out.println(arr[0][2]);//4

//会报空指针异常
System.out.println(stt[1][0]);//再此之前应该先初始化stt[1] = new String[4]

3.初始化值

 

方式一： int[][] arrTwo = new int[3][4];
外层元素初始化值为地址值
内层元素初始化值为 与一维数组相同（根据类型判断）
方拾二： int[][] arrTwo = new int[3][];
外层元素初始化为 null
内层元素没有值，如果取的话会报空指针异常

int[][] arrTwo = new int[3][4];
        System.out.println(arrTwo[1]);//[I@1b6d3586  存的是地址，类似于c中的指针
        System.out.println(arrTwo[1][0]);//0
        System.out.println(arr);//[[I@4554617c

数组的复制以及二分查找

/*
        1.先声明2个数组，arr1，arr2
        2.将arr1赋值8个素数，输出arr1
        3.再将arr1赋值给arr2，修改arr2的偶元素索引，使其等于索引值
         */
        int[] arr1,arr2;
        arr1 = new int[]{2,3,5,7,11,13,17,19};
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }
        //这里的arr1，arr2的地址相同
        arr2 = arr1;//这里不能算是复制。因为这里只是把地址赋值给了arr2，在堆空间中只开辟了一个{2,3,5,7,11,13,17,19}，有点类似对一个文件夹创建了一个快捷方式
       System.out.println();
        for (int i = 0; i < arr2.length; i++) {
            if (i % 2 == 0){
                arr2[i] = i;
            }
        }
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr1[i] + " ");
        }
        System.out.println();
        /*
        数组的反转
         */
        String[] strs = new String[]{"a","b","c","d","e","f"};
         for (int i = 0; i < strs.length / 2; i++) {
            String temp = strs[i];
            strs[i] = strs[strs.length - (i + 1)];
            strs[strs.length - (i+1)] = temp;
        }
        for (int i = 0; i < strs.length; i++) {
            System.out.print(strs[i]);
        }

 

二分查找
前提：数组必须是有序的

int[] arr = new int[]{-21,-3,2,43,65,78,97};
        int num = 4;
        int head = 0;
        int end = arr.length - 1;
        boolean flags = true;
        while (head <= end) {
            int mid = (head + end) / 2;
            if (arr[mid] == num){
                System.out.println("找到了,位置是：" + mid);
                flags = false;
                break;
            }else if (arr[mid] > num){
                end = mid -1;
            }else if (arr[mid] < num){
                head = mid + 1;
            }
        }
        if (flags){
            System.out.println("找不到");
        }