数组使用

1、Random

Random的使用，java中Random是一个随机数的类，使用的使用需要导入
import Random

例子

/*
具体使用：
导入类   import java.util.Random
创建Random对象
开始使用，接受随机数
*/
import java.util.Random;

public class DemoRandom{
	public static void main(String[] args){
		// 创建Random对象
		Random random = new Random();
		// 接受随机数
		int num = random.nextInt(10); // 0-9数字
		System.out.println(num);
	}
}

练习

猜数字游戏
import java.util.Random;
import java.util.Scanner;
public class DemoRandomStudy{
	public static void main(String[] args){
		Random random = new Random();
		// 创建Scanner
		System.out.println("请输入一个数字：");
		Scanner sc = new Scanner(System.in);
		int num = random.nextInt();
		int myNum = sc.nextInt();
		if (myNum>num){
			System.out.println("你的数字太大了");
		}
		else if (myNum==num){
			System.out.println("恭喜你，猜正确了");
		}
		else{
			System.out.println("你的数字太小了");
		}
	}
}

2、数组

概念：数组用于存储多个相同数据的元素对象

2.1、数组的定义

数组的问题： a: ArrayIndexOutofBoundsException，数组索引越界异常产生原因：没有找到对应的索引 b: NullPointerException，空指针异常产生原因：数组为null,而去访问数中的元素 int[] array = null;

定义格式：

使用静态初始化的时候,格式可以省略一下
标准格式:
数据类型[] 数据名称 = new 数据类型[数组长度]
数据类型[] 数据名称 = new 数据类型[] {元素1, 元素2...};
省略格式:
数据类型[] 数组名称 = {元素1, 元素2...}

注意事项:
1.静态初始化没有直接给定长度, 但是仍然自动推算出长度
2.静态初始化标准格式可以拆分为两个步骤.
3.动态初始化的两个步骤
4.静态初始化不能使用两个步骤

使用建议:
1.如果不确定数组的内容,用动态初始化, 否则使用静态初始化

数组的初始化：
1. 动态初始化：
  - 给定长度，由系统分配元素初始化值
  - int[ ] arr = new int[3]； //数组的长度是3
2. 静态初始化：
  - 给定元素初始值，由系统分配长度
  - int[] array = new int[ ]{1， 2，3};
  - 简写为： int[] array={1，2，3}

2.2、数组的索引以及数值问题

1.数组的默认值问题

使用动态初始化的时候,其中的元素将会自动拥有一个默认值规则如下: 数字类型: 默认为0 浮点类型: 默认是0.0 字符类型: 默认是'u0000' 布尔类型: 默认是false 引用数据: 默认是null

注意事项:静态初始化也有默认值, 程序系统默认将值快速的赋值了元素对应的值

例子

public class ArrayDemo{
  public static void main(String[] args){
    // 定义一个数组
    int[] array = new int[3]; // 动态的定义长度为三的整型数组
    System.out.println(array); // 返回的是一个  地址哈希值
    System.out.println(array[0]); // 获取第一个元素值
    System.out.println(array[1]); // 获取第二个元素值
    System.out.println(array[2]); // 获取第三个元素值
    // 默认值为： 0，0，0
    // 元素赋值操作
    array[0] = 123;
    System.out.println(array[0]); // 获取第一个元素值
    // 输出  123
  }
}

改变数组中的值

public class arrayDemo{
  public static void main(String[] args){
    // 定义一个数组
    int[] array = {1,2,3};
    // 赋值操作
    array[0] = 100;
    array[2] = 200;
    System.out.println("改变后的值是"+array[0]);
    System.out.println("改变后的值是"+array[2]);
  }
}

2.3、数组的遍历操作

while遍历

public class ArrayDemo01{
  public static void main(String[]  args){
    int[] array = {11,22,33,44,55,66};
    int num = 0;
    while (num<array.length){
      System.out.println(array[num]);
      num++;
    }
  }
}
/*
11
...
66 */

for遍历

public class ArrayDemo{
  public static void main(String[] args){
    int[] array = {11,22,33,44,55};
    for(int i=0;i<array.length;i++){
      System.out.println(array[i]);
    }
  }
}

2.4、数组的最大值和最小值

最小值

public class ArrayMin{
  public static void main(String[] args){
    int[] array = {11,12,13,14,15};
    int min = array[0];
    for(int i=0;i<array.length;i++){
      if(array[i]<min){
        min = array[i];
      }
    }
	System.out.println(min);
  }
}

最大值

public class ArrayMax{
  public static void main(String[] args){
    int[] array = {11,22,3,33,444};
    int max = array[1];
    for(int i=0;i<array.length;i++){
      if(array[i]>max){
        max = array[i];
      }
    }
    System.out.println(max);
  }
}

2.5、数组的反转

思路：
初始化语句：int min=0，int max = array.length-1
条件判断：min < max
步进表达式：min++，max—;

循环体：第三个变量

public class ArrayReverse{
  public static void main(String[] args){
    int[] array = {11,22,33,44,55};
    for(int min=0,int max = array.length-1;min<max;min++,max--){
      int temp = array[min];
      array[min] = array[max];
      array[max] = temp;
    }
    for(int i=0;i<array.length;i++){
      System.out.println(array[i]);
    }
  }
}

2.6、数组的传参

将数组作为参数传递，传递的是哈希地址值

public class ArrayParam{
  public static void main(String[] args){
    int[] array = {11,22,33};
    arrayPrint(array);
  }
  public static void arrayPrint(int[] array){
    for(int i=0;i<array.length;i++){
      System.out.println(array[i]);
    }
  }
}