java学习--基础知识第四天-- Random、数组

今日内容介绍

u Random

u 数组

第1章 Random

1.1 产生整数随机数

1.1.1 Random的使用步骤

我们想产生1~100(包含1和100)的随机数该怎么办呢? 我们不需要自己去写算法,因为Java已经为我们提供好了产生随机数的类---Random:

作用:

– 用于产生一个随机数

? 使用步骤(和Scanner类似)

– 导包

? import java.util.Random;

– 创建对象

? Random r = new Random();

– 获取随机数

? int number = r.nextInt(10);

? 产生的数据在0到10之间,包括0,不包括10。

? 括号里面的10是可以变化的,如果是100,就是0-100之间的数据

1.1.2 案例代码一:

package com.itheima;

import java.util.Random;

/*

* Random:用于产生随机数

*

* 使用步骤:

* A:导包

* import java.util.Random

* B:创建对象

* Random r = new Random();

* C:获取随机数

* int number = r.nextInt(10);

* 获取的是0-10之间的随机数,包括0,不包括10

*

* 需求:如何获取到一个1-100之间的随机数呢?

*/

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);

}

}

1.2 猜数字小游戏案例:

1.2.1 系统产生一个1-100之间的随机数,请猜出这个数据是多少。

1.2.2 案例代码二:

package com.itheima;

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 RandomTest {

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;

}

}

}

}

第2章 数组

2.1 数组概述

需求:现在需要统计某公司员工的工资情况,例如计算平均工资、找到最高工资等。假设该公司有80名员工,用前面所学的知识,程序首先需要声明80个变量来分别记住每位员工的工资,然后在进行操作,这样做会显得很麻烦。为了解决这种问题,Java就提供了数组供我们使用。

那么数组到底是什么呢?有什么特点呢?通过上面的分析:我们可以得到如下两句话:

数组是存储多个变量(元素)的东西(容器)

这多个变量的数据类型要一致

2.2 数组的定义格式

2.2.1 数组概念

数组是存储同一种数据类型多个元素的容器。

数组既可以存储基本数据类型,也可以存储引用数据类型。

2.2.2 数组的定义格式

格式1:数据类型[] 数组名;

格式2:数据类型 数组名[];

注意:这两种定义做完了,数组中是没有元素值的。

2.3 数组的初始化

2.3.1 数组初始化概述:

Java中的数组必须先初始化,然后才能使用。

所谓初始化:就是为数组中的数组元素分配内存空间,并为每个数组元素赋值。

2.3.2 数组的初始化方式

2.3.2.1 动态初始化:初始化时只指定数组长度,由系统为数组分配初始值

格式:数据类型[] 数组名 = new 数据类型[数组长度];

数组长度其实就是数组中元素的个数。

举例:

int[] arr = new int[3];

解释:定义了一个int类型的数组,这个数组中可以存放3个int类型的值。

2.3.2.2 案例代码三:

package com.itheima_01;

/*

* 数组:存储同一种数据类型的多个元素的容器。

*

* 定义格式:

* 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:数组的长度,其实就是数组中的元素个数

*/

}

}

2.3.2.3 静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度

2.3.2.4 案例代码四:

package com.itheima_01;

/*

* 静态初始化的格式:

* 数据类型[] 数组名 = 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 = {1,2,3};

//输出数组名和元素

System.out.println(arr);

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

System.out.println(arr[1]);

System.out.println(arr[2]);

}

}

2.4 数组的内存分配

2.4.1 JVM内存划分

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

栈 存储局部变量

堆 存储new出来的东西

方法区 (面向对象进阶讲)

本地方法区 (和系统相关)

寄存器 (给CPU使用)

2.4.2 一个数组的内存图

定义一个数组,输出数组名及元素。然后给数组中的元素赋值,再次输出数组名及元素

2.4.2.1 案例代码五:

package com.itheima_01;

/*

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

*/

public class ArrayTest {

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] = 100;

arr[2] = 200;

//再次输出数组名及元素

System.out.println(arr);

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

System.out.println(arr[1]);

System.out.println(arr[2]);

}

}

2.4.2.2 代码内存图解:

2.4.3 两个数组的内存图

定义两个数组,分别输出数组名及元素。然后分别给数组中的元素赋值,分别再次输出数组名及元素

2.4.3.1 案例代码六:

package com.itheima_01;

/*

* 需求:定义两个数组,分别输出数组名及元素。然后分别给数组中的元素赋值,分别再次输出数组名及元素。

*/

public class ArrayTest2 {

public static void main(String[] args) {

//定义两个数组

int[] arr = new int[2];

int[] arr2 = new int[3];

//分别输出数组名及元素

System.out.println(arr);

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

System.out.println(arr[1]);

System.out.println(arr2);

System.out.println(arr2[0]);

System.out.println(arr2[1]);

System.out.println(arr2[2]);

//然后分别给数组中的元素赋值

arr[1] = 100;

arr2[0] = 200;

arr2[2] = 300;

//再次输出数组名及元素

System.out.println(arr);

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

System.out.println(arr[1]);

System.out.println(arr2);

System.out.println(arr2[0]);

System.out.println(arr2[1]);

System.out.println(arr2[2]);

}

}

2.4.3.2 代码内存图解:

2.4.4 两个数组指向同一个地址的内存图

定义两个数组,先定义一个数组,赋值,输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值,再次输出两个数组的名及元素

2.4.4.1 案例代码七:

/*

* 需求:定义两个数组,先定义一个数组,赋值,输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。

* 然后给第二个数组赋值,再次输出两个数组的名及元素。

*/

public class ArrayTest3 {

public static void main(String[] args) {

// 先定义一个数组,赋值,输出

int[] arr = new int[3];

arr[0] = 100;

arr[1] = 200;

arr[2] = 300;

System.out.println(arr);

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

System.out.println(arr[1]);

System.out.println(arr[2]);

// 然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组

int[] arr2 = arr;

// 然后给第二个数组赋值

arr2[0] = 111;

arr2[1] = 222;

arr2[2] = 333;

// 再次输出两个数组的名及元素

System.out.println(arr);

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

System.out.println(arr[1]);

System.out.println(arr[2]);

System.out.println(arr2);

System.out.println(arr2[0]);

System.out.println(arr2[1]);

System.out.println(arr2[2]);

}

}

2.4.4.2 代码内存图解:

2.5 数组的使用

2.5.1 数组的元素访问

2.5.1.1 案例代码八:

package com.itheima_01;

/*

* 数组:存储同一种数据类型的多个元素的容器。

*

* 定义格式:

* 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:数组的长度,其实就是数组中的元素个数

*/`

System.out.println(arr); //[[email protected],地址值

//我们获取到地址值没有意义,我要的是数组中的数据值,该怎么办呢?

//不用担心,java已经帮你想好了

//其实数组中的每个元素都是有编号的,编号是从0开始的,最大的编号就是数组的长度-1

//用数组名和编号的配合我们就可以获取数组中的指定编号的元素

//这个编号的专业叫法:索引

//格式:数组名[编号] -- 数组名[索引]

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

System.out.println(arr[1]);

System.out.println(arr[2]);

}

}

2.5.2 数组使用的两个小问题

2.5.2.1 案例代码九:

package com.itheima_02;

/*

* 两个常见小问题:

* A:java.lang.ArrayIndexOutOfBoundsException

* 数组越界异常

* 产生的原因:就是你访问了不存在的索引元素。

* B:java.lang.NullPointerException

* 空指针异常

* 产生的原因:数组已经不指向堆内存的数据了,你还使用数组名去访问元素。

* 为什么我们要记住这样的小问题呢?

* 编程不仅仅是把代码写出来,还得在出现问题的时候能够快速的解决问题。

*/

public class ArrayDemo {

public static void main(String[] args) {

// 定义数组

int[] arr = { 1, 2, 3 };

//System.out.println(arr[3]);

//引用类型:类,接口,数组

//常量:空常量 null,是可以赋值给引用类型的

//arr = null;

System.out.println(arr[1]);

}

}

2.6 一维数组练习

2.6.1 一维数组遍历

2.6.1.1 案例代码十:

package com.itheima_03;

/*

* 需求:数组遍历(依次输出数组中的每一个元素)

* 获取数组中元素的个数:数组名.length

*/

public class ArrayTest {

public static void main(String[] args) {

// 定义数组

int[] arr = { 11, 22, 33, 44, 55 };

// 原始做法

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

System.out.println(arr[1]);

System.out.println(arr[2]);

System.out.println(arr[3]);

System.out.println(arr[4]);

System.out.println("--------------------");

// 用for循环改进

for (int x = 0; x < 5; x++) {

System.out.println(arr[x]);

}

System.out.println("--------------------");

//为了解决我们去数数组中元素个数的问题,数组就提供了一个属性:length

//用于获取数组的长度

//格式:数组名.length

System.out.println("数组共有:"+arr.length+"个");

System.out.println("--------------------");

for(int x=0; x<arr.length; x++) {

System.out.println(arr[x]);

}

}

}

2.6.2 数组操作之获取最值:

2.6.2.1 案例代码十一:

package com.itheima_03;

/*

* 需求:数组获取最值(获取数组中的最大值最小值)

*/

public class ArrayTest2 {

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);

}

}

2.7 二维数组

2.7.1 二维数组概述

我们黑马程序员的Java基础班每个班有很多个学生,所以,可以用数组来存储,而我们又同时有很多个Java基础班。这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用。

由此可见:其实二维数组其实就是一个元素为一维数组的数组。

2.7.2 二维数组格式

定义格式

数据类型[][] 数组名;

数据类型 数组名[][]; 不推荐

数据类型[] 数组名[]; 不推荐

初始化方式

数据类型[][] 变量名 = new 数据类型[m][n];

数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};

简化版格式:数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

2.7.2.1 案例代码十二:

package com.itheima_04;

/*

* 二维数组:就是元素为一维数组的数组。

*

* 定义格式:

* A:数据类型[][] 数组名;

* B:数据类型 数组名[][]; 不推荐

* C:数据类型[] 数组名[]; 不推荐

*

* 如何初始化呢?

* A:动态初始化

* 数据类型[][] 数组名 = new 数据类型[m][n];

* m表示这个二维数组有多少个一维数组

* n表示每一个一维数组的元素有多少个

* B:静态初始化

*      数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...};

* 简化格式:

* 数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};

*/

public class ArrayArrayDemo {

public static void main(String[] args) {

// 数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};

int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

System.out.println(arr); // [[[email protected]

System.out.println(arr.length); // 二维数组中的一维数组的个数

System.out.println(arr[0]);// [[email protected]

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

System.out.println(arr[1]);// [[email protected]

System.out.println(arr[2]);// [[email protected]

//我如何获取到一个二维数组的元素呢?

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

System.out.println(arr[1][1]);

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

}

}

2.7.3 二维数组的遍历

遍历思想:首先使用循环遍历出二维数组中存储的每个一维数组,然后针对每个遍历到的一维数组在使用循环遍历该一维数组中的元素

2.7.3.1 案例代码十三:

package com.itheima_04;

/*

* 二维数组遍历

*

* System.out.println():输出内容并换行

* System.out.print():输出内容

* System.out.println():换行

*/

public class ArrayArrayTest {

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]);

// }

// System.out.println("hello");

// System.out.println("world");

// System.out.print("hello");

// System.out.print("world");

/*

// 第一个一维数组的元素

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();

}

}

}

原文地址:https://www.cnblogs.com/bigorangehasc/p/8639198.html

时间: 2024-09-26 22:31:10

java学习--基础知识第四天-- Random、数组的相关文章

java学习--基础知识进阶第四天--笔记

今日内容 包 权限修饰符 内部类 包(package) 包的作用 用来分类管理Java文件 包的特点 (1)可以有多层,每一层之间用.来隔开 (2)相同包下不能有同名的类,不同包下可以有同名的类 (3)包声明使用package关键字,包声明必须位于文件的第一行有效代码 包的命名规范: 全部都小写,如果有多层使用.来隔开 一般都是公司域名倒着写,www.itheima.com->com.itheima 不同包的下的类互相访问 相同包下的类可以互相访问 不同包下的类的访问需要导包,使用import关

java学习--基础知识进阶第二天--继承、匿名对象&amp;final、抽象类

今日内容介绍 u 继承 u 抽象类 第1章 继承 1.1 继承的概述 在现实生活中,继承一般指的是子女继承父辈的财产.在程序中,继承描述的是事物之间的所属关系,通过继承可以使多种事物之间形成一种关系体系. 1.2 继承的格式&使用  在程序中,如果想声明一个类继承另一个类,需要使用extends关键字. 格式: class 子类 extends 父类 {} 1.2.1 案例代码一: package com.itheima_01; /* * 继承:多个类有共同的成员变量和成员方法,抽取到另外一个类

java学习--基础知识进阶第三天--接口、多态

今日内容介绍 u 接口 u 多态 第1章 接口 1.1 接口的概述 接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的"类". 接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口的子类)来完成.这样将功能的定义与实现分离,优化了程序设计. 1.2 接口的格式&使用 1.2.1 接口的格式 与定义类的class不同,接口定义时需要使用interface关键字. 定义接口所在的仍为.java文件,虽然声明时使用的为interface关键字

java学习--基础知识进阶第一天--static静态关键字、代码块

今日内容介绍 u 知识回顾 u static静态关键字 u 代码块 第1章 知识回顾 1.1 方法的回顾 1.1.1 案例代码一: package com.itheima_01; /* * 需求:定义一个方法求两个数的和,并在主方法中调用 * * 方法:类中的一段具有特定功能的程序,提高了代码的复用性和可维护性 * 定义格式: * public static 返回值类型(没有返回值写void) 方法名(参数类型 参数名,参数类型 参数名2) {//形参 * 方法体; * } * 调用方式: *

java反射基础知识(四)反射应用实践

反射基础 p.s: 本文需要读者对反射机制的API有一定程度的了解,如果之前没有接触过的话,建议先看一下官方文档的Quick Start. 在应用反射机制之前,首先我们先来看一下如何获取一个对象对应的反射类Class,在Java中我们有三种方法可以获取一个对象的反射类. 通过getClass方法 在Java中,每一个Object都有一个getClass()方法,通过getClass方法我们可以获取到这个对象对应的反射类: 1 2 String s = "ziwenxie"; Class

java学习--基础知识进阶第十二天--网络编程概述、UDP协议、TCP协议

今日内容介绍 u  网络编程概述 u  UDP u  TCP 第1章 网络编程概述 1.1 网络协议 通过计算机网络可以使多台计算机实现连接,位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则,这就好比在道路中行驶的汽车一定要遵守交通规则一样.在计算机网络中,这些连接和通信的规则被称为网络通信协议,它对数据的传输格式.传输速率.传输步骤等做了统一规定,通信双方必须同时遵守才能完成数据交换. 网络通信协议有很多种,目前应用最广泛的是TCP/IP协议(Transmission Contro

java学习--基础知识阶段性总结--基础面试题

1. 静态变量和实例变量的区别 局部变量不能用静态的,如果用了静态的,则不会从静态区消失 * 静态变量也叫类变量  成员变量也叫对象变量 * A:所属不同 * 静态变量属于类,所以也称为为类变量 * 成员变量属于对象,所以也称为实例变量(对象变量) * B:内存中位置不同 * 静态变量存储于方法区的静态区 * 成员变量存储于堆内存 * C:内存出现时间不同 * 静态变量随着类的加载而加载,随着类的消失而消失 * 成员变量随着对象的创建而存在,随着对象的消失而消失 * D:调用不同 * 静态变量可

java从基础知识(四)java内存机制

Java内存管理:深入Java内存区域 上面的文章对于java的内存管理机制讲的非常细致,在这里我们只是为了便于后面内容的理解,对java内存机制做一个简单的梳理. 程序计数器:当前线程所执行的字节码的行号指示器,虚拟机下一条需要执行的字节码指令,分支.循环.跳转.异常处理.线程恢复等基础功能都需要依赖改变这个计数器的值来完成. 栈:保存局部变量.引用,方法调用结束即被释放.每个方法被执行的时候都会同时创建一个栈帧(Stack Frame)用于存储局部变量表.操作栈.动态链接.方法出口 等信息.

java学习--基础知识第八天--笔记

今日内容 如何查看API文档 键盘录入字符串数据 String类 StringBuilder类 API 就是Java给我们提供的类 Scanner类 nextLine():获取键盘录入的字符串数据 String类 字符串,它是常量,定义之后就不能改变 // 方式一: String s = new String("abc"); // 方式二: char[] chs = {'a','b','c'}; String s = new String(chs);// abc // 方式三: cha