Java学习笔记day05

数组

作用

记录一组数据类型相同的数据
特点: 长度不可变

名词

长度: 数组中最大可存储的元素个数
元素: 数组中存储单个值
下标(索引): 元素在数组中的位置，从0开始，到长度-1结束

步骤

声明

数据类型[] 数组名;
    数组名就是数组的变量名
如: int[] ages;
    String[] names;
    double[] moneys;

创建

1.动态创建
    特点: 声明可以与创建分开
    不带值
        数组名 = new 数据类型[长度];
    带值
        数组名= new 数据类型[]{值1,值2,值3,...};
        创建时值的个数就是数组的长度
    
    声明并创建:
        不带值
            数据类型 数组名 = new 数据类型[长度];
        带值
            数据类型 数组名 = new 数据类型[]{值1,值2,值3,...};
            创建时值的个数就是数组的长度
2.静态创建
    特点: 必须在声明时创建
    数据类型[] 数组名 = {值1,值2,值3,...};
    创建时值的个数就是数组的长度
    
动态创建与静态创建的区别:
    1.使用的区别: 动态创建可以初始化也可以修改，静态创建只能初始化时使用
    2.内存的区别: 
        new关键字:
            含义: 新建
            作用: 在堆内存开辟一片空间
        静态创建在常量池中存储
        动态创建在堆内存中存储
    3.静态创建没有默认值，动态有默认值，基本数据类型默认为0，引用数据类型默认为null

操作

删
改
    修改数组中指定位置的元素
        数组名[下标] = 值;
    修改整个数组
        动态创建的语法
查
    查询数组中指定位置的元素
        数组名[下标]
    查询数组长度
        数组名.length
​
常见的错误(了解):
    数组下标越界异常
        ArrayIndexOutOfBoundsException
        解决方案: 修改下标到范围内
    空指针异常:
        NullPointerException
        解决方法: 保证不要使用null调用属性或方法

使用

遍历

将数组或集合中的数据，逐个取出
步骤:
    1.开启循环，变量的取值范围就是下标的取值范围
    2.在循环中通过变量获取数组中对应位置的值
    
增强for循环(foreach):
    遍历
    for(数据类型 变量名:要遍历的集合或数组){
        循环体
    }
    执行流程:
        1.取出数组或集合中的第0个元素，赋值给变量名
        2.执行循环体
        3.取出数组或集合中的第一个元素，赋值给变量名
        4.执行循环体
        5.取出数组或集合中的第二个元素，赋值给变量名
        6.执行循环体
        ...
        取出数组或集合中最后一个元素，赋值给变量名
        执行循环体
        结束循环
    foreach比for快3倍

查找

寻找数组是否存在指定元素
步骤:
    1.遍历
    2.使用获取的元素与指定元素对比，如果没有找到继续寻找，如果找到了结束遍历

复制

将数组A中的内容复制到数组B中
要求:
    数组B的长度要等与数组A
    数组B的数据类型要与数组A一致
思想:
    1.遍历数组A
    2.将取出的元素赋值给B数组对应的位置

扩容

将数组A的长度变大
思路:
    1.创建数组B，要求数组B长度大于数组A，并且与数组A数据类型一致
    2.将数组A中的数据复制到数组B中
    3.将数组B赋值给数组A

数组在参数中使用

形参

如:
    public static void add(int[] nums){
    
    }

实参

如:
    int[] nums = new int[]{1, 3, 5, 7};
    add(nums);

返回值

如:
    public static int[] add(int a, int b){
        int[] nums = new int[3];
        nums[0] = a;
        nums[1] = b;
        nums[2] = a + b;
        return nums;
    }

可变参数

是什么?
    形参中使用数组的变形
好处:
    传递参数时，可以传递数组，也可以多个值
语法:
    数据类型... 变量名
注意:
    只能在形参末尾使用，一个方法只能使用一个可变参数

练习

1.创建一个数组,存储身边6个人的年龄
2.创建一个数组,存储身边6个人的名称
3.创建一个数组,存储身边6个人的性别
4.获取年龄数组,名称数组,性别数组第3位的值,并打印
5.修改年龄数组,名称数组,性别数组第3位的值,为18,张三,男
6.遍历名称数组,要求打印格式如下
    [xxx,xxx,xxx,xxx,...]
7.将姓名数组扩容到10个长度,并获取最后一个元素打印输出
8.将年龄数组扩容到10个长度,并获取最后一个元素打印输出
9.使用可变参数计算多个数的乘积,并返回
10.查找张三在不在年龄数组中
11.点名器

//数组使用

public class Test01 {
	public static void main(String[] args) {
		int[] ages = {18, 19, 20, 21, 22, 23};
		String[] names = {"小明", "小鹏", "小俊", "小豪", "小红", "小圆"};
		char[] sexs = {'男', '男', '男', '男', '女', '女'};
		
		System.out.println("年龄: " + ages[2]);
		System.out.println("姓名: " + names[2]);
		System.out.println("性别: " + sexs[2]);
		
		ages[2] = 18;
		names[2] = "张三";
		sexs[2] = '男';
		
		System.out.print("[");
		for (int i = 0; i < names.length; i++) {
			if(i != names.length - 1) {
				System.out.print(names[i] + ",");
			}
			else {
				System.out.print(names[i]);
			}		
		}
		System.out.println("]");
		
		//获取扩容后的姓名数组
		String[] newNames = extendName(names);
		String name = newNames[newNames.length - 1];
		System.out.println("最后一个元素为: " + name);
		for (String s : newNames) {
			System.out.print(s + ",");
		}
		System.out.println();
		
		//获取扩容后的年龄数组
		int[] newAges = extendAge(ages);
		int age = newAges[newAges.length - 1];
		System.out.println("最后一个元素为: " + age);
		for (int i : newAges) {
			System.out.print(i + ",");
		}
		System.out.println();
		
		boolean b = findName("张三", newNames);
		if(b) {
			System.out.println("在数组中");
		}
		else {
			System.out.println("不在数组中");
		}
	}
	
	public static String[] extendName(String[] names) {
		String[] newNames = new String[names.length + 4];
		for(int i = 0; i < names.length; i++) {
			newNames[i] = names[i];
		}
		names = newNames;
		return names;
	}
	
	public static int[] extendAge(int[] ages) {
		int[] newAges = new int[ages.length + 4];
		for(int i = 0; i < ages.length; i++) {
			newAges[i] = ages[i];
		}
		ages = newAges;
		return ages;
	}
	
	//查找张三在不在姓名数组中
	public static boolean findName(String name, String[] names) {
		for (String s : names) {
			if(name.equals(s)) {
				return true;
			}
		}
		return false;
	}
}




//可变参数

public class Test02 {
	public static void main(String[] args) {
		int n = mul(1, 2, 3, 4, 5);
		System.out.println("1到5的乘积为: " + n);
	}
	
	public static int mul(int... nums) {
		int n = 1;
		for (int i : nums) {
			n *= i;
		}
		return n;
	}
}




//点名器

import java.util.Random;
import java.util.Scanner;

public class Test03 {
	public static void main(String[] args) {
		String[] names = {"张三", "李四", "王五", "马六", "候七", "龙八", "小红", "小丽", "老王"};	
		Scanner scanner = new Scanner(System.in);
		Random random = new Random();
		while(true) {
			System.out.println("是否要点名?\n1.点名\n2.不点名\n3.退出");
			int tag = scanner.nextInt();
			if(tag == 1) {
				int num = random.nextInt(names.length);
				System.out.println("请" + names[num] + "同学回答问题!");
			}
			else if(tag == 2) {
				continue;
			}
			else if(tag == 3) {
				System.out.println("欢迎下次使用!");
				break;
			}
			else {
				System.out.println("请重新输入!");
			}
		}
	}
}