JAVA SE之一维数组的介绍和使用

今日内容

​ 数组：一维数组；

2.31 数组

一维数组概述和定义格式说明

1.数组概念
	数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
	数组既可以存储基本数据类型（4类8种），也可以存储引用数据类型。
2.数组定义格式
	格式1： 数据类型[] 数组名；
	格式2： 数据类型   数组名[];
举例：
	int[] a； 	定义了一个int类型的数组a；（推荐）
	int a[];	定义了一个int类型的a数组。

一维数组的初始化动态初始化

1.数组的初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
2.初始化的分类：
	a:动态初始化:只指定长度，由系统给出初始化值；
	b:静态初始化:给出初始化值，由系统决定长度。
	注意事项： 这两种方式，只能使用一种，不能进行动静结合。
3.动态初始化的格式：
	数据类型[] 数组名 = new 数据类型[数组长度];
	数组长度其实就是数组中元素的个数。
	举例： int[] arr = new int[3];	定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。
4.案例演示	
	输出数组名称和数组元素

public class MyDemo {
    public static void main(String[] args) {
        //动态初始化定义数组的语法
        int[] arr=new int[5]; //定义了一个int类型的数组，数组的长度为5
        double[] arr2=new double[10];
        boolean[] arr3=new boolean[2];

        //定义数组的语法2
        byte arr4[]=new byte[4]; 

        int one=arr[0];
        arr[0]=100; //为数组的第一个元素重新赋值

        System.out.println(arr[0]);
    }
}

Java中的内存分配以及栈和堆的区别

1.栈: 存放的是**局部变量**：在方法定义中或者方法声明上的变量都是局部变量。
2.堆: 存放的是所有new出来的东西
	特点：
		a: 每一个new出来的东西都会为其分配一个地制值。
		b: 每一个变量都有一个默认的值
			byte，short，int，long  -- 0
			float，double 		       -- 0.0
			char 				      -- '\u0000'
			boolean 				-- false
			引用数据类型	 -- null		
		c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收
3.方法区:(面向对象部分讲解)
4.本地方法区:(和系统相关)
5.寄存器:(cpu使用)

一维数组的内存图解1：一个数组

定义一个数组，输出数组名称和数组中的元素值，给数组赋值，再次输出数组名称和数组中的元素值。

public class MyTest {
    public static void main(String[] args) {
        int[] arr1=new int[3];
        arr1[0]=10;
        arr1[1] = 20;
        arr1[2] = 30;

        int[] arr2 = new int[3];
        arr2[0] = 60;
        arr2[1] = 120;
        arr2[2] = 130;

        int[] arr3=arr1;
        arr3[0]=74;
        arr3[1]=1000;

        System.out.println(arr1[0]);   //10
        System.out.println(arr1[1]);   //20
        System.out.println(arr1[2]);    //30
        System.out.println("==============================");
        System.out.println(arr2[0]);//60
        System.out.println(arr2[1]);//120
        System.out.println(arr2[2]);//130
        System.out.println("================================");
        System.out.println(arr3[0]);//74
        System.out.println(arr3[1]);//1000
        System.out.println(arr3[2]);//30
        System.out.println("=========================================");
        System.out.println(arr1);
        System.out.println(arr2);
        System.out.println(arr3);
    }
}

一维数组的内存图解2：二个数组

定义两个数组，分别输出数组名称和数组中的元素值，分别给两个数组赋值，再次输出数组名称和数组中的元素值。

一维数组的内存图解3：三个引用2个数组

	定义第一个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。定义第二个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致)，通过第三个数组的名称去把元素重新赋值。最后，再次输出第一个数组数组名称和元素。

一维数组的初始化静态初始化及内存图

静态初始化的格式：
	格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
		举例： int[] arr = new int[]{1,2,3};
	简化格式：
		数据类型[] 数组名 = {元素1,元素2,…};
		举例： int[] arr = {1,2,3};

一维数组操作的两个常见小问题越界和空指针

a:ArrayIndexOutOfBoundsException:数组索引越界异常
		原因：你访问了不存在的索引。
b:NullPointerException:空指针异常
		原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

一维数组的操作1：遍历

public class MyTest3 {
    public static void main(String[] args) {
        //数组的遍历
        int[] arr={20,30,40,50,60,70,80,90,100};
        //int one=arr[0];
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

        System.out.println("===============================");
        //反向遍历

        for(int i=arr.length-1;i>=0;i--){
            System.out.println(arr[i]);
        }
        System.out.println("===================================");
        //软件一键遍历 arr.length.fori
        for (int i = 0; i < arr.length; i++) {

        }
         // arr.length.forr  反向遍历  稍微修改下
        for (int length = arr.length-1; length >= 0; length--) {

        }
    }
}

一维数组的操作2：获取最值

   //求最大值
public class ArrayDemo3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,6};//定义一个数组存放指定元素

        int sum = arr[0];//假设第一个元素是最大值
        //for循环遍历数组中元素，每次循环跟数组索引为0的元素比较大小
        for (int i = 0; i < arr.length; i++){
            if (sum < arr[i]){//数组中的元素跟sum比较，比sum大就把它赋值给sum作为新的比较值
                sum = arr[i];
            }
        }
        System.out.println(sum);//输出数组中的最大值
    }
}

一维数组的操作3：反转（元素对调）

public class MyTest {
    public static void main(String[] args) {
        //思路：首尾交换值，利用中间变量来交换
        int[] arr = {10, 20, 30, 40, 50}; //{50,40,30,20,10}
        for (int i = 0,j=arr.length-1; i <j; i++,j--) {
            int t=arr[i];
            arr[i]=arr[j];
            arr[j]=t;
        }
        System.out.println("=========================");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("================================");
        int[] arr2 = {10, 20, 30, 40, 1,50}; //{50,40,30,20,10}
        int max = getMax(arr2);
        System.out.println(max);
        System.out.println("==========================");
        int[] arr3 = {10, 20, 30, 40, 1, 50};
        reverseArr(arr3);
        showArr(arr3);
    }

    public static int getMax(int[] arr){
        //定义一个参照值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    public static void reverseArr(int[] arr){
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
    }

    public static void showArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+",");
        }
    }
}

一维数组的操作4：查表法（根据键盘录入索引，查找对应星期）

public class MyTest {
    public static void main(String[] args) {
        String[] arr={"星期一","星期二","星期三","星期四","星期五","星期六","星期天"};
        Scanner sc = new Scanner(System.in);
        System.out.println("输入数字 0---6");
        int num = sc.nextInt();
        //根据索引找元素
        String element = getElement(num, arr);
        System.out.println(element);

    }
    public static String getElement(int index, String[] arr){
        if(index>=0&&index<arr.length){
            return arr[index];
        }else{
            return "你输入的索引不合理";
        }
    }
}

一维数组的操作5：基本查找

public class MyTest2 {
    public static void main(String[] args) {
        //根据元素找索引
        String[] arr = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        System.out.println("请输入星期 比如星期一到星期天");
        Scanner scanner = new Scanner(System.in);
        String ele = scanner.nextLine();
        int index = getIndexByEle(ele, arr);
        System.out.println(index);

    }
    public static int getIndexByEle(String ele, String[] arr){

        int index=-1;
        for (int i = 0; i < arr.length; i++) {
            //"星期一"=="星期一"  0x002==0x001
            //如果你要比较两个字符串字面上的内容是否相同 用方法来比较
            if(ele.equals(arr[i])){
               // return i;
                index=i;
                break;
            }
        }
        //return -1; // 如果没有找到，就返回-1  -1大家约定俗成了，-1 表示没有找到。
        return index;
    }
}