1.数组

  1. 数组的定义：数组是可以存储多个变量（元素）的容器，这多个变量的数据类型要一致
  2. 数组可以存储基本数据类型也可以存储引用数据类型
    （1）基本数据类型：四类八种
  • byte short int long
  • float double
  • boolean
  • char
    （2）引用数据类型：数组，类，接口，枚举等

2.一维数组

1. 一维数组的定义（动态初始化）：
（1）数据类型[] 数组名 = new 数据类型[数组长度]

int[] arr = new int[5]  //长度为5的一个int类型数组

（2）动态初始化只指定长度，由系统给出初始化的值

  • byte short int long 整型数组的默认值都为0
  • float double 浮点型数组的默认值都为0.0
  • boolean 布尔类型数组的默认值为false
  • char char类型数组的默认值是空格字符 "\u0000"

2. 数组的赋值与访问数组元素
（1）数组的赋值：通过元素的索引来对数组元素进行赋值

int[] arr = new int[5]  //长度为5的一个int类型数组
	//赋值
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;

（2）数组元素的访问：通过元素的索引来进行访问

int[] arr = new int[5]  //长度为5的一个int类型数组
	//赋值
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;

	//访问数组元素（方法1）：直接访问
	System.out.println(arr[0]);  //10
	System.out.println(arr[2]);  //30
	System.out.println(arr[4]);  //50

	//访问数组元素（方法2）：间接访问
	int one = arr[1];
	System.out.println(one);  //20

（3）访问数组的地址值：直接通过System.out.println(数组名称)

3. 数组的内存图解
（1）Java中内存分配以及栈和堆的区别

  • 栈：存放的是局部变量（在方法定义中或者方法声明上的变量都是局部变量）
  • 堆：存放的是所有new出来的东西
    特点：
    a.每一个new出来的东西都会为其分配地址值
    b.每一个变量都有一个默认值
    c.使用完毕后就变成了垃圾，等待垃圾回收期对其回收

    （2）一个数组的内存图解

    （3）两个数组的内存图解

    （4）三个数组的内存图解

4. 数组的定义（静态初始化）
（1）数据类型[] 数组名 = {元素1,元素2,…}

int[] arr = {10,20,30,40};

（2）静态初始化：给出初始化值，由系统决定长度

5. 数组操作的两个常见问题
（1）ArrayIndexOutOfBoundsException：数组索引越界异常
原因：你访问了不存在的索引
（2）NullPointerException:空指针异常
原因：数组已经不在指向堆内存了，而你还用数组名去访问元素

6. 数组的常见操作
（1）数组的遍历

public class Test{
		public static void main(String[] args){
			int[] arr = {10,20,30,40,50,60}
			showArr(arr);
		}

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

		
	}

（2）获取最值

public class Test{
		public static void main(String[] args){
			int[] arr = {10,20,30,40,50,60}
			int max = getMax(arr)
			System.out.println(max);
		}

		public static int getMax(int[] arr){
			int max = arr[0];
			for(int i = 0; i < arr.length; i++){
				if(arr[i] > max){
					max = arr[i];
				}
			}
			return max;
		}	
	}

（3）数组反转

public class Test{
		public static void main(String[] args){
			int[] arr = {10,20,30,40,50,60}
			reverseArr(arr);
			//遍历新数组
			for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        	}
		}

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

（4）数组的查表法

//根据索引，查找数组中的元素
	public class Test{
		public static void main(String[] args){
			String[] week = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"}
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入索引 0-6");
       	 	int index= scanner.nextInt();
        	String ele=getEle(index,week);
        	System.out.println(ele);
		}

		public static String getEle(int index,String[] week){
			if(index >= 0 && index <= 6){
				String str = week[index];
				return str;
			}else{
				return "输入错误";
			}
		}
	}

（5）数组的基本查找

//根据输入内容，查找索引值
	public class Test{
		public static void main(String[] args){
			String[] week = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"}
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入：星期一~星期天");
       	 	String str = sc.nextLine();
        	int index =getIndex(str,week);
        	System.out.println(index);
		}

		public static int getIndex(String str,String[] week){
			for(int i = 0;i < week.length;i++){
				if(week[i].equals(str)){
					return i;
				}else{
					return -1;  //表示没找到
				}
			}
		}
	}