Random

Random的使用步骤

  • 使用步骤(和Scanner类似)
    • 导包
      • import java.util.Random;
    • 创建对象
      • Random r = new Random();
    • 获取随机数
      • int number = r.nextInt(10);
      • 产生的数据在0到10之间,包括0,不包括10。
      • 括号里面的10是可以变化的,如果是100,就是0-100之间的数据

代码案例-random格式

package com.yeyufan01;
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
	Random r = new Random();
	for (int x = 0; x < 10; x++) {
		// 获取随机数
		int number = r.nextInt(10);
		// 输出随机数
		System.out.println("number:" + number);
	}
	System.out.println("--------------------");
	// 如何获取到一个1-100之间的随机数呢?
			int i = r.nextInt(100) + 1;
			System.out.println("i:" + i);

}
}

代码案例-猜数字小游戏

package com.yeyufan01;
import java.util.Random;
import java.util.Scanner;
/*
 * 猜数字小游戏案例
 *		系统产生一个1-100之间的随机数,请猜出这个数据是多少。
 * 分析:
 * 		A:系统产生一个随机数1-100之间的。
 * 			int number = r.nextInt(100) + 1;
 * 		B:键盘录入我们要猜的数据
 * 			用Scanner实现
 *		C:比较这两个数据(用if语句)
 *			大了:给出提示大了
 *			小了:给出提示小了
 *			猜中了:给出提示,恭喜你,猜中了
 *		D:多次猜数据,而我们不知道要猜多少次,怎么办呢?
 *			while(true) {循环的内容}
 */

public class GameRandom {
	public static void main(String[] args) {
		// 系统产生一个随机数1-100之间的。
		Random r = new Random();
		int number = r.nextInt(100) + 1;

		while(true){
			// 键盘录入我们要猜的数据
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入你要猜的数字(1-100):");
			int guessNumber = sc.nextInt();
	
			// 比较这两个数据(用if语句)
			if (guessNumber > number) {
				System.out.println("你猜的数据" + guessNumber + "大了");
			} else if (guessNumber < number) {
				System.out.println("你猜的数据" + guessNumber + "小了");
			} else {
				System.out.println("恭喜你,猜中了");
				break;
			}
		}
	}

}

数组

数组概述

数组是存储多个变量(元素)的东西(容器) 这多个变量的数据类型要一致

代码案例-数组格式

package com.yeyufan02;
/*
 * 数组:存储同一种数据类型的多个元素的容器。
 * 
 * 定义格式:
 * 		A:数据类型[] 数组名;
 * 		B:数据类型 数组名[];
 * 举例:
 * 		A:int[] a; 定义一个int类型的数组,数组名是a
 * 		B:int a[]; 定义一个int类型的变量,变量名是a数组
 * 
 * 数组初始化:
 * 		A:所谓初始化,就是为数组开辟内存空间,并为数组中的每个元素赋予初始值
 * 		B:我们有两种方式对数组进行初始化
 * 			a:动态初始化	只指定长度,由系统给出初始化值
 * 			b:静态初始化	给出初始化值,由系统决定长度
 * 
 * 动态初始化:
 * 		数据类型[] 数组名 = new 数据类型[数组长度];
 */

public class ArrayDemo {
	public static void main(String[] args) {
		//数据类型[] 数组名 = new 数据类型[数组长度];
		int[] arr = new int[3];
		/*
		 * 左边:
		 * 		int:说明数组中的元素的数据类型是int类型
		 * 		[]:说明这是一个数组
		 * 		arr:是数组的名称
		 * 右边:
		 * 		new:为数组分配内存空间
		 * 		int:说明数组中的元素的数据类型是int类型
		 * 		[]:说明这是一个数组
		 * 		3:数组的长度,其实就是数组中的元素个数
		 */
	
	}

}

代码案例-数组静态初始化

package com.yeyufan02;
/*
 * 静态初始化的格式:
 * 		数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
 * 
 * 		简化格式:
 * 			数据类型[] 数组名 = {元素1,元素2,...};
 * 
 * 		举例:
 * 			int[] arr = new int[]{1,2,3};
 * 
 * 		简化后:
 * 			int[] arr = {1,2,3};
 */

public class ArrayDemo2 {
public static void main(String[] args) {
	int[] arr=new int[] {1,2,3};
	System.out.println(arr);
	System.out.println(arr[0]);
	System.out.println(arr[1]);
	System.out.println(arr[2]);

}
}

数组的内存分配

JVM内存划分

Java 程序在运行时,需要在内存中的分配空间。为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。

  • 栈 存储局部变量
  • 堆 存储new出来的东西
  • 方法区
  • 本地方法区 (和系统相关)
  • 寄存器 (给CPU使用)

案例代码-数组练习1

package com.yeyufan02;
/*
 * 需求:定义一个数组,输出数组名及元素。然后给数组中的元素赋值,再次输出数组名及元素。
 */

public class ArrayDemo3 {
public static void main(String[] args) {
	int[] arr =new int[3];
	System.out.println(arr);
	System.out.println(arr[0]);
	System.out.println(arr[1]);
	System.out.println(arr[2]);
	 arr[0] = 1;
	 arr[1] = 2;
	 arr[2] = 3;
	System.out.println(arr[0]);
	System.out.println(arr[1]);
	System.out.println(arr[2]);
	 
	
}
}

案例代码-数组练习2

package com.yeyufan02;
/*
 * 需求:定义两个数组,先定义一个数组,赋值,输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
 * 然后给第二个数组赋值,再次输出两个数组的名及元素。
 */

public class ArrayDemo4 {
public static void main(String[] args) {
	int[] arr1 =new int[]{1,2,3};
	System.out.println("输出数组1");
	for (int i = 0; i < arr1.length; i++) {
		System.out.println(arr1);
		System.out.println(arr1[i]);
	}
	int[] arr2 =arr1;
	arr2[0] = 111;
	arr2[1] = 222;
	arr2[2] = 333;
	System.out.println("-------\n输出数组2");
	for (int i = 0; i < arr2.length; i++) {
		System.out.println(arr2);
		System.out.println(arr2[i]);
	}
	
}
}

数组的使用

案例代码-数组的元素访问

package com.yeyufan02;
/*
 * 定义格式:
 * 		A:数据类型[] 数组名;
 * 		B:数据类型 数组名[];
 * 举例:
 * 		A:int[] a; 定义一个int类型的数组,数组名是a
 * 		B:int a[]; 定义一个int类型的变量,变量名是a数组
 * 数组初始化:
 * 		A:所谓初始化,就是为数组开辟内存空间,并为数组中的每个元素赋予初始值
 * 		B:我们有两种方式对数组进行初始化
 * 			a:动态初始化	只指定长度,由系统给出初始化值
 * 			b:静态初始化	给出初始化值,由系统决定长度
 * 动态初始化:
 * 		数据类型[] 数组名 = new 数据类型[数组长度];
 */

public class ArrayDemo5 {
	public static void main(String[] args) {
		//数据类型 [] 数组名 = new 数据类型[数组长度];
		  int   [] arr = new int[3];
		/*
		 * 左边:
		 * 		int:说明数组中的元素的数据类型是int类型
		 * 		[]:说明这是一个数组
		 * 		arr:是数组的名称
		 * 右边:
		 * 		new:为数组分配内存空间
		 * 		int:说明数组中的元素的数据类型是int类型
		 * 		[]:说明这是一个数组
		 * 		3:数组的长度,其实就是数组中的元素个数
		 */
		System.out.println(arr); //[I@3fa5ac,地址值
		//获取到地址值没有意义,要的是数组中的数据值,该怎么办
		//数组中的每个元素都是有编号的,编号是从0开始的,最大的编号就是数组的长度-1
		//用数组名和编号的配合我们就可以获取数组中的指定编号的元素
		//这个编号的专业叫法:索引
		//格式:数组名[编号] -- 数组名[索引]
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
	}
}

案例代码-两个小问题

package com.yeyufan02;
/*
 * 两个常见小问题:
 * 		A:java.lang.ArrayIndexOutOfBoundsException
 * 			数组越界异常
 * 			产生的原因:就是你访问了不存在的索引元素。
 * 		B:java.lang.NullPointerException
 * 			空指针异常
 * 			产生的原因:数组已经不指向堆内存的数据了,你还使用数组名去访问元素。
 * 		编程不仅仅是把代码写出来,还得在出现问题的时候能够快速的解决问题。
 */

public class ArrayDemo6 {
	public static void main(String[] args) {
		// 定义数组
		int[] arr = { 1, 2, 3 };
		
		//System.out.println(arr[3]);
		
		//引用类型:类,接口,数组
		//常量:空常量 null,是可以赋值给引用类型的
		arr = null;
		System.out.println(arr[1]);
	}

}

一维数组

案例代码-一维数组遍历

package com.yeyufan02;
/*
 * 需求:数组遍历(依次输出数组中的每一个元素)
 * 获取数组中元素的个数:数组名.length
 */

public class ArrayDemo7 {
public static void main(String[] args) {
	//定义一个长度为3的一维数组
	int[] arr= new int[] {1,2,3};
	//遍历数组
	for (int i = 0; i < arr.length; i++) {
		System.out.println("---"+arr[i]+"---\n");
	}
	//输出数组的长度
	System.out.println(arr.length);
}
}

案例代码-获取最值

package com.yeyufan02;
/*
 * 需求:数组获取最值(获取数组中的最大值最小值)
 */

public class ArrayDemo8 {
	public static void main(String[] args) {
		//定义数组
		int[] arr = {12,98,45,73,60};
		
		//定义参照物
		int max = arr[0];
		
		//遍历数组,获取除了0以外的所有元素,进行比较
		for(int x=1; x<arr.length; x++) {
			if(arr[x] > max) {
				max = arr[x];
			}
		}
		System.out.println("数组中的最大值是:"+max);
	}

}

二维数组

案例代码-二维数组格式

package com.yeyufan02;
/*
 * 二维数组:就是元素为一维数组的数组。
 * 定义格式:
 * 		A:数据类型[][] 数组名;
 * 		B:数据类型 数组名[][];	不推荐
 * 		C:数据类型[] 数组名[];	不推荐
 * 如何初始化呢?
 * 		A:动态初始化
 * 			数据类型[][] 数组名 = new 数据类型[m][n];
 * 			m表示这个二维数组有多少个一维数组
 * 			n表示每一个一维数组的元素有多少个
 * 		B:静态初始化
 * 	      数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...};
 * 			简化格式:
 * 			数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
 */

public class ArrayDemo9 {
	public static void main(String[] args) {
		// 数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
		int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

		System.out.println(arr); // [[I@104c575
		System.out.println(arr.length); // 二维数组中的一维数组的个数
		System.out.println(arr[0]);// [I@3fa5ac
		System.out.println(arr[0].length);
		System.out.println(arr[1]);// [I@95cfbe
		System.out.println(arr[2]);// [I@179dce4
		
		//我如何获取到一个二维数组的元素呢?
		System.out.println(arr[0][0]);
		System.out.println(arr[1][1]);
		System.out.println(arr[2][2]);
	}

}

案例代码-二维数组的遍历

package com.yeyufan02;

/*
 * 二维数组遍历
 * 
 * System.out.println():输出内容并换行
 * System.out.print():输出内容
 */
public class ArrayDemo10 {
	public static void main(String[] args) {
		// 定义二维数组
		int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
		// 二维数组中的一维数组名称:二维数组名[索引]
		// arr[0] 其实就是二维数组中的第一个一维数组的名称
		// arr[1] 其实就是二维数组中的第二个一维数组的名称
		// arr[2] 其实就是二维数组中的第三个一维数组的名称

		// for (int x = 0; x < arr[0].length; x++) {
		// System.out.println(arr[0][x]);
		// }


		/*
		 * // 第一个一维数组的元素 for (int x = 0; x < arr[0].length; x++) {
		 * System.out.print(arr[0][x] + "  "); } System.out.println();
		 * 
		 * // 第二个一维数组的元素 for (int x = 0; x < arr[1].length; x++) {
		 * System.out.print(arr[1][x] + "  "); } System.out.println();
		 * 
		 * // 第三个一维数组的元素 for (int x = 0; x < arr[2].length; x++) {
		 * System.out.print(arr[2][x] + "  "); } System.out.println();
		 */

//			for(int y=0; y<3; y++) {
//				for (int x = 0; x < arr[y].length; x++) {
//					System.out.print(arr[y][x] + "  ");
//				}
//				System.out.println();
//			}

		for (int y = 0; y < arr.length; y++) {
			for (int x = 0; x < arr[y].length; x++) {
				System.out.print(arr[y][x] + "  ");
			}
			System.out.println();
		}

	}
}