Java基础

一.数组

1.1数组的简介

数组是一种数据结构，可以用来储存一堆类型相同（基本数据类型和引用数据类型都可以）的并且是有序的数据的容器，我们可以通过数组的下标来访问数组中的元素。

数组没有固定的类名，每一个数组都是对象（基本数据类型的数据，称作值，不叫对象）

注意：

数组是一个固定长度的容器，一旦初始化长度，就不能改变

数组的长度，代表数组中可以储存多少个元素，类似容量

元素，即储存在数组中的每一个数据，称作数组的元素

1.2数组的实例化

我们在定义一个数组时，需要用到 [ ] ,可以理解为要存储一堆数据

1.使用new关键字，来实例化数组对象，同时初始化具体元素

2.使用new关键字，只定义数组的长度

注意：在我们只规定数组的长度时，本质上也存入了默认类型的元素

//new+直接初始化具体元素
        String[] names = new String[]{"小红","小明","小强","张三","李四"};
        System.out.println(Arrays.toString(names));

上述代码中，我们使用new关键字直接实例化了一个数组，存入了5个字符串类型的元素

//new+长度  注意：其实是有长度个默认元素
        int[] nums = new int[5]; //byte,short,int,long对应的默认元素时0
        System.out.println(Arrays.toString(nums));
        double[] prices = new double[5]; //float,double对应的默认元素是0.0
        System.out.println(Arrays.toString(prices));
        char[] chars = new char[5]; // char对应的默认元素是  \u0000
        System.out.println(Arrays.toString(chars));
        boolean[] bools = new boolean[5]; //boolean对应的默认元素是false
        System.out.println(Arrays.toString(bools));
        String[] adds = new String[5]; // 引用类型对应的默认元素是null
        System.out.println(Arrays.toString(adds));

上述代码中，我们使用类型名[ ]  = new [长度]的方式创建了不同类型的数组，并打印数组的元素，需要注意的是：在使用打印命令打印数组时，需要使用Arrays.toString(数组名)的方式

 

可以发现，每个基本数据类型都是有默认值的，引用类型的默认值时null

在我们使用静态初始化数组时，不能像声明变量一样，可以先声明再初始化

1.3数组的访问

我们需要通过下标来访问数组中的元素   下标就是数组中元素的索引值。从0开始，最后一个元素的下标length-1

数组的长度可以表示为    数组名.length

如何通过下标访问   变量名 = 数组名[index]

public static void main(String[] args) {
        int[] ages = new int[]{20,18,19,20,19,30};
        //获取ages中的第一个元素

首先我们通过new关键字直接进行初始化int类型的长度为6的一个数组，他们的索引是0，1，2，3，4，5。

我们如果需要获取数组中的第一个元素

int first = ages[0];
        System.out.println("first: " + first);

可以设置一个int 类型的变量first来接受，然后打印出来同理，我们也可以打印出其他的变量

//获取ages中的第四个元素
        int four = ages[3];
        System.out.println("four: " + four);
        //打印ages的长度
        System.out.println("长度："+ages.length);
        //获取ages中的最后一个元素
        System.out.println("最后一个元素："+ages[ages.length-1]);

如果需要打印长度的话，可以使用变量名.length的方式，在获取最后一个元素时，也可以使用

[变量名.length-1] 的方式.

如果我们需要对数组中的元素进行赋值，可以直接使用索引来实现，比如：

 //将年龄39存入到第二个位置
        ages[1] = 39;
        //将年龄50存入到最后一个位置
        ages[ages.length-1] = 50;
        System.out.println(Arrays.toString(ages));

我们可以把39存入索引[1]位置，也就是数组的第二个位置，把50存入数组的最后一个位置，也就是索引[ages.length-1]的位置

可以看出，我们成功访问了 需要的一些元素，并且成功对第二个元素和最后一个元素赋值

//创建一个具有5个长度的long类型数据
        long[] ns = new long[5];
        //将数字10，20，30，40，50分别放入
        ns[0] = 10;
        ns[1] = 20;
        ns[2] = 30;
        ns[3] = 40;
        ns[4] = 50;
        System.out.println(Arrays.toString(ns));

我们可以通过new关键字创建一个long类型长度为5的数组，并把每个元素都进行赋值

//将数字1~10存入到int类型的数组scores里
        int[] scores= new int[10];
        for(int i=0;i<10;i++){
            scores[i]=i+1;
        }
        System.out.println(Arrays.toString(scores));

我们还可以先使用关键字创建长度一定的数组，然后再使用for循环对其内部的元素每个进行赋值

1.4数组下标越界异常

在编译期间不会报错，但是在运行期间会报错

.ArrayIndexOutOfBoundsException

当我们输入的下标大于等于数组的长度或下标小于0时就会发生。

运行时异常：  如果不对错误进行处理，那么jvm会暴力中止该程序

空指针异常：指使用了空值去访问各种方法或者属性

比如：  null.length   null.name

public static void main(String[] args) {
        int[] nums = {1,3,2,4,5};
        int e1 = nums[5];
        System.out.println(e1);
        int e2 = nums[nums.length];

根据上述代码，我们使用了int关键字先定义了一个数组，长度是5，但是在访问时下标输入的是5，等于了数组的长度，数组的索引最多是4，就会出现下标越界异常

第二次访问的e2变量也是同样的道理，索引值与数组的长度相同

 String[] names = {"小明","mike",null,""};
//        打印每个元素的字符长度
        System.out.println(names[0].length());
        System.out.println(names[1].length());
        System.out.println(names[2].length());
        System.out.println(names[3].length());

通过上述的代码，我们把第三个元素设置为空，最后一个元素设置为空字符串

那么此时打印2索引的的时候会遇到空值，没有长度，此时就会报空指针异常

为了解决这个问题，我们使用for循环，在元素遇到空时跳过该元素

 for (int i = 0; i < names.length; i++) {
            if (names[i]==null) { //处理null情况
                continue;
            }
            System.out.println(names[i].length());
        }

通过运行结果，我们可以发现，打印命令跳过了[2]索引，直接执行了下一个索引

1.5数组的遍历

我们可以使用两种方式来进行数组的遍历，第一种是用经典for循环，第二种是使用增强的for循环

语法：  

for( 元素类型 变量名:数组|集合|枚举){

 }

 int[] nums = new int[5];
        nums[0] = 10;
        nums[1] = 20;
        nums[2] = 30;
        nums[3] = 40;
        nums[4] = 50;
        //直接打印数组的变量
        System.out.println("数组变量："+nums); //直接打印数组名，得到的是类全名+@+内存地址的16进制数字
        //调用Arrays.toString();
        System.out.println("数组字符串："+ Arrays.toString(nums));

首先我们创建一个长度为5的int类型数组，并对其中的元素进行赋值，如果我们直接打印数组名nums的话，会得到类全名@内存地址，我们如果像看到数组中的元素，就需要使用Arrays.toString()的方法，

//使用经典for循环，通过下标遍历
        for (int i = 0; i < nums.length; i++) {
             //i充当下标
             System.out.print(nums[i]+" ");
//           System.out.print(nums[i]);  一样的，只是换行了
        }

        System.out.println("-----增强for循环-------");

        //使用foreach循环遍历上面的数组nums
        for(int n:nums){
            System.out.print(n+" ");
        }
    }
}

根据上述代码，使用经典for循环时，我们需要使用下标进行遍历，声明一个int类型的变量i来充当下标，并初始化i = 0；i的循环条件时小于数组的长度

然后我们就可以进行数组的遍历，打印出nums[ i ]，数组的长度是5，所以会循环五次，加上“ ”的目的是为了让每次打印的结果不换行，间隔一个空格

如果我们使用增强for循环的话，就可以定义一个接受变量n，来直接遍历数组，然后打印出来就可以了，两种方式是一样的，只是增强for循环的执行效率更高