第二阶段 day02【Scanner类、Random类、ArrayList类】
今日内容
- API概述
- Scanner类
- Random类
- ArrayList类
目标:
能够明确API的使用步骤
能够使用Scanner类获得键盘录入数据
能够使用Random类生成随机数
能够使用数组存储自定义类型并遍历
能够使用ArrayList集合的构造方法创建ArrayList集合对象
能够使用ArrayList集合存储数据
能够使用ArrayList集合中常用的方法
能够使用ArrayList集合存储字符串并遍历
能够使用ArrayList集合存储自定义对象并遍历
能够使用ArrayList类作为形式参数和返回值类型
第一章 API
概述
API(Application Programming Interface),应用程序编程接口。Java API是一本程序员的字典 ,是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来,我们不需要关心这些类是如何实现的,只需要学习这些类如何使用即可。所以我们可以通过查询API的方式,来学习Java提供的类,并得知如何使用它们。
API使用步骤
- 打开帮助文档。
- 点击显示,找到索引,看到输入框。
- 你要找谁?在输入框里输入,然后回车。
- 看包。java.lang下的类不需要导包,其他需要。
- 看类的解释和说明。
- 学习构造方法。
- 使用成员方法
第二章 Scanner类
了解了API的使用方式,我们通过Scanner类,熟悉一下查询API,并使用类的步骤。
2.1 什么是Scanner类
一个可以解析基本类型和字符串的简单文本扫描器。 例如,以下代码使用户能够从 System.in 中读取一个数:
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
备注:System.in 系统输入指的是通过键盘录入数据
2.2 引用类型使用步骤
导包:
使用import关键字导包,在类的所有代码之前导包,引入要使用的类型,java.lang包下的所有类无需导入。 格式:
import 包名.类名;
举例:
java.util.Scanner;
创建对象
使用该类的构造方法,创建一个该类的对象,格式:
数据类型 变量名 = new 数据类型(参数列表);
举例:
Scanner sc = new Scanner(System.in);
调用方法:
调用该方法,完成指定功能。格式:
变量名.方法名();
举例:
int age = sc.nextInt(); // 键盘录入一个int类型的整数
2.3 Scanner 使用步骤
查看类:
- java.util.Scanner :该类需要import导入后使用。
查看构造方法:
- public Scanner(InputStream source): 构造一个新的Scanner, 它生成的值是从指定输入流扫描的。
查看成员方法:
- public int nextInt() :将输入信息的下一个标记扫描为一个int值
使用Scanner类,完成键盘录入数据的操作,代码如下:
package com.witty.web.demo01;
import java.util.Scanner;
/*
Scanner使用步骤
1 导包
2 创建对象
3 调用方法
*/
public class Demo01_Scanner {
public static void main(String[] args) {
// 1 导包
// 2 创建对象
Scanner sc = new Scanner(System.in);
// 3 调用方法
System.out.println("请输入成绩:");
int grade = sc.nextInt();
System.out.println("年龄:" + grade);
}
}
2.4 练习
求和
键盘录入两个数据并求和,代码如下:
package com.witty.web.demo02;
import java.util.Scanner;
/*
2.4 练习 :
键盘录入两个数据并求和,代码如下:
*/
public class sum01 {
public static void main(String[] args) {
// 1 导包 创建对象
Scanner sc = new Scanner(System.in);
// 2 使用对象方法
System.out.println("请输入一个数:");
int num1 = sc.nextInt();
System.out.println("请输入一个数:");
int num2 = sc.nextInt();
// 求和
sum(num1, num2);
}
public static void sum(int num1, int num2) {
int sum1 = num1 + num2;
System.out.println("和:" + sum1);
}
}
取最值:
键盘录入三个数据并获取最大值,代码如下:
package com.witty.web.dmeo03;
import java.util.Scanner;
/*
取最值:
键盘录入三个数据并获取最大值,代码如下:
*/
public class MaxDemo01 {
public static void main(String[] args) {
// 1 导包 创建对象
Scanner sc = new Scanner(System.in);
// 2 调用方法 输入三个数
System.out.println("请输入一个数:");
int num1 = sc.nextInt();
System.out.println("请输入一个数:");
int num2 = sc.nextInt();
System.out.println("请输入一个数:");
int num3 = sc.nextInt();
maxInt(num1, num2, num3);
}
private static void maxInt(int num1, int num2, int num3) {
int max = num1;
max = max > num2 ? max : num2;
max = max > num3 ? max : num3;
System.out.println("最大值:" + max);
}
}
2.5 匿名对象【需要了解】
概念
创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量,虽然是创建对象的简化写法,但是应用场景很优先。
- 匿名对象:没有变量名的对象
格式:
new 类名(参数列表)
举例:
new Scanner(System.in);
应用场景
1 创建匿名对象直接调用方法,没有变量名:
new Scanner(System.in).nextInt();
2 一旦调用两次方法,就是创建两次对象,造成浪费,请看如下代码:
new Scanner(System.in).nextInt();
new Scanner(System.in),nextInt();
注意:一个匿名对象只能使用一次
3 匿名对象可以作为方法的参数和返回值
- 作为参数:
package com.witty.web.dmeo03;
import java.util.Scanner;
/*
3. 匿名对象可以作为方法的参数和返回值
作为参数:
*/
public class Test {
public static void main(String[] args) {
// 普通方式
Scanner sc = new Scanner(System.in);
input(sc);
// 作为参数
input(new Scanner(System.in));
}
private static void input(Scanner sc) {
System.out.println(sc);
}
}
- 作为返回值:
package com.witty.web.dmeo03;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
// 普通方式
Scanner sc = getScanner();
System.out.println(sc);
}
private static Scanner getScanner() {
// 普通模式
/*Scanner sc = new Scanner(System.in);
return sc;*/
// 匿名对象作为方法返回值
return new Scanner(System.in);
}
}
第三章 Random类
3.1 什么是Random类
此类的实例用于生成伪随机数。
例如,以下代码使用户能够得到一个随机数:
Random r = new Random();
int i = r.nextInt();
3.2 Random使用步骤
查看类
java.util.Random :该类需要 import导入使后使用。
查看构造方法
public Random() :创建一个新的随机数生成器。
查看成员方法
public int nextInt(int n) :返回一个伪随机数,范围在 0 (包括)和指定值 n (不包括)之间的
int 值。
使用Random类,完成生成3个10以内的随机整数的操作,代码如下:
package com.witty.web.demo04Random;
import java.util.Random;
/*
使用Random类,完成生成3个10以内的随机整数的操作,代码如下:
*/
public class Demo01_Random {
public static void main(String[] args) {
// 1导包 创建对象
Random r = new Random();
// 2 使用方法
int[] arr = new int[3];
for (int i = 0; i < arr.length; i++) {
int num = r.nextInt(10);
arr[i] = num;
System.out.println(arr[i]);
}
}
}
备注:创建一个Random 对象,每次调用nextInt() 方法,都会生成一个随机数。
3.3 练习
获取随机数
获取1-n之间的随机数,包含n,代码如下:
package com.witty.web.demo04Random;
import java.util.Random;
/*
获取1-n之间的随机数,包含n,代码如下:
*/
public class Demo02_Random {
public static void main(String[] args) {
// 1 导包 创建对象
Random r = new Random();
// 2 使用对象 n = 100
int n = 100;
int num = r.nextInt(n) + 1;
System.out.println(num);
}
}
猜数字小游戏
游戏开始时,会随机生成一个1-100之间的整数number 。玩家猜测一个数字guessNumber ,会与number 作比较,系统提示大了或者小了,直到玩家猜中,游戏结束。
小贴士:先运行程序代码,理解此题需求,经过分析后,再编写代码
package com.witty.web.demo04Random;
import java.util.Random;
import java.util.Scanner;
/*
猜数字小游戏
游戏开始时,会随机生成一个1-100之间的整数number 。玩家猜测一个数字guessNumber ,
会与number 作比较,系统提示大了或者小了,直到玩家猜中,游戏结束。
小贴士:先运行程序代码,理解此题需求,经过分析后,再编写代码
*/
public class Demo03_Random {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 1 产生一个随机数1-100之间
int number = new Random().nextInt(100) + 1;
// 2 猜数字
int count = 0;
while (true) {
System.out.println("请猜数字 1- 100之间。");
int num = sc.nextInt();
count++;
if (num > number) {
System.out.println("大了。");
System.out.println("猜了:" + count + " 次。");
} else if (num < number) {
System.out.println("小了。");
System.out.println("猜了:" + count + " 次。");
} else {
System.out.println("恭喜你猜对了。");
System.out.println("猜了:" + count + " 次。");
break;
}
}
}
}
第四章 ArrayList类
4.1 引入 – 对象数组
使用学生数组,存储三个学生对象,代码如下:
package com.witty.web.demo05_ArrayList;
/*
使用学生数组,存储三个学生对象,代码如下:
*/
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.witty.web.demo05_ArrayList;
/*
使用学生数组,存储三个学生对象,代码如下:
*/
public class ArrayListTest {
public static void main(String[] args) {
// 创建学生数组
Student[] stu = new Student[3];
// 创建学生对象
Student stu0 = new Student("李庚希", 19);
Student stu1 = new Student("张子枫", 17);
Student stu2 = new Student("冯宝宝", 190);
// 把学生对象赋值给数组
stu[0] = stu0;
stu[1] = stu1;
stu[2] = stu2;
// 循环遍历数组
for (int i = 0; i < stu.length; i++) {
System.out.println(stu[i]);
}
}
}
到目前为止,我们想存储对象数据,选择的容器,只有对象数组。而数组的长度是固定的,无法适应数据变化的需求。为了解决这个问题,Java提供了另一个容器java.util.ArrayList 集合类,让我们可以更便捷的存储和操作对象数据
4.2 什么是ArrayList类
java.util.ArrayList 是大小可变的数组的实现,存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。 ArrayList 中可不断添加元素,其大小也自动增长。
4.3 ArrayList使用步骤
查看类
java.util.ArrayList :该类需要 import导入使后使用。
,表示一种指定的数据类型,叫做泛型。E ,取自Element(元素)的首字母。在出现E 的地方,我们使用一种引用数据类型将其替换即可,表示我们将存储哪种引用类型的元素。代码如下:
ArrayList<String>, ArrayList<Student>
查看构造方法:
- public ArrayList() : 构造一个内容为空的集合。
基本格式:
ArrayList<String> list = new ArrayList<String>();
在JDK 7后,右侧泛型的尖括号之内可以留空,但是<>仍然要写。简化格式:
ArrayList<String> list = new ArrayList<>();
查看成员方法
- public boolean add(E e) : 将指定的元素添加到此集合的尾部。
参数 E e ,在构造ArrayList对象时, 指定了什么数据类型,那么add(E e) 方法中,只能添加什么数据
类型的对象。使用ArrayList类,存储三个字符串元素,代码如下:
package com.witty.web.demo06_ArrayList;
import java.util.ArrayList;
/*
类型的对象。使用ArrayList类,存储三个字符串元素,代码如下:
*/
public class TestArrayList {
public static void main(String[] args) {
// 1 导包,创建ArrayList对象 import java.util.ArrayList;
ArrayList<String> list = new ArrayList<>();
// 2 创建三个String字符串数组
String s1 = "姚明";
String s2 = "易建联";
String s3 = "刘翔";
// 3 调用方法 将字符串存入可变数组【集合】
list.add(s1);
list.add(s2);
list.add(s3);
// 4 循环遍历可变数组【集合】
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
4.4 常用方法和遍历
对于元素的操作,基本体现在——增、删、查。常用的方法有:
- public boolean add(E e) :将指定的元素添加到此集合的尾部。
- public E remove(int index) :移除此集合中指定位置上的元素。返回被删除的元素。
- public E get(int index) :返回此集合中指定位置上的元素。返回获取的元素。
- public int size() :返回此集合中的元素数。遍历集合时,可以控制索引范围,防止越界。
这些都是最基本的方法,操作非常简单,代码如下:
package com.witty.web.demo06_ArrayList;
import java.util.ArrayList;
/*
* public boolean add(E e) :将指定的元素添加到此集合的尾部。
* public E remove(int index) :移除此集合中指定位置上的元素。返回被删除的元素。
* public E get(int index) :返回此集合中指定位置上的元素。返回获取的元素。
* public int size() :返回此集合中的元素数。遍历集合时,可以控制索引范围,防止越界。
*/
public class TestArrayList02 {
public static void main(String[] args) {
// 1 创建ArrayList集合
ArrayList<String> list = new ArrayList<>();
// * public boolean add(E e) :将指定的元素添加到此集合的尾部。
boolean bo = list.add("中国"); // 返回知否添加成功
list.add("俄罗斯");
list.add("美国");
System.out.println(bo); // true
// * public E remove(int index) :移除此集合中指定位置上的元素。
// 返回被删除的元素。
String remove = list.remove(1);
System.out.println(remove); // 俄罗斯
// * public E get(int index) :返回此集合中指定位置上的元素。
// 返回获取的元素。
String s1 = list.get(1);
System.out.println(s1); // 中国
System.out.println("-----------------");
// * public int size() :返回此集合中的元素数。
// 遍历集合时,可以控制索引范围,防止越界。
int size = list.size();
System.out.println(size);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
4.5 如何存储基本数据类型
ArrayList对象不能存储基本类型,只能存储引用类型的数据。类似 不能写,但是存储基本数据类型对应的包装类型是可以的。所以,想要存储基本类型数据, <> 中的数据类型,必须转换后才能编写,转换写法如下:
基本类型 | 基本类型包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
我们发现,只有Integer 和Character 需要特殊记忆,其他基本类型只是首字母大写即可。那么存储基本类型数据,代码如下
package com.witty.web.demo06_ArrayList;
import java.util.ArrayList;
/*
只有Integer 和Character 需要特殊记忆,其他基本类型只是首字母大写即可。
*/
public class Demo03ArrayListMethod {
public static void main(String[] args) {
// 存储基本数据类型Integer
ArrayList<Integer> list = new ArrayList<>();
list.add(11);
list.add(22);
System.out.println(list.get(1));
// 存储基本数据类型character
ArrayList<Character> charList = new ArrayList<>();
charList.add('你');
charList.add('好');
for (Character character : charList) {
System.out.print(character);
}
}
}
4.6 ArrayList集合
数值添加到集合
生成6个1~33之间的随机整数,添加到集合,并遍历
package com.witty.web.demo07_ArrayList;
import java.util.ArrayList;
import java.util.Random;
/*
**生成6个1~33之间的随机整数,添加到集合,并遍历**
*/
public class ArrayListWork {
public static void main(String[] args) {
// 1 创建ArrayList集合,
ArrayList<Integer> list = new ArrayList<>();
Random r = new Random();
// 2 生成随机数
for (int i = 0; i < 6; i++) {
int num = r.nextInt(33) + 1;
list.add(num);
System.out.print(num + " ");
}
}
}
对象添加到集合
自定义4个学生对象,添加到集合,并遍历
package com.witty.web.demo07_ArrayList;
import java.util.ArrayList;
/*
**自定义4个学生对象,添加到集合,并遍历**
*/
public class ArrayListWork01 {
public static void main(String[] args) {
// 0 创建ArrayList集合对象
ArrayList<Student> list = new ArrayList<>();
// 1 创建学生对象
Student stu1 = new Student("李庚希", 19);
Student stu2 = new Student("天天", 17);
Student stu3 = new Student("李月", 17);
Student stu4 = new Student("李瑶", 19);
// 2 添加学生对象到集合中
list.add(stu1);
list.add(stu2);
list.add(stu3);
list.add(stu4);
// 4 遍历集合
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
打印集合方法
定义以指定格式打印集合的方法(ArrayList类型作为参数),使用{}扩起集合,使用@分隔每个元素。格式参照 {元素@元素@元素}。
package com.witty.web.demo07_ArrayList;
import java.util.ArrayList;
/*
打印集合方法
**定义以指定格式打印集合的方法(ArrayList类型作为参数),使用{}括起集合,
使用@分隔每个元素。格式参照 {元素@元素@元素}。**
*/
public class ArrayListWork02 {
public static void main(String[] args) {
// 1 创建集合list
ArrayList<String> list = new ArrayList<>();
//2 添加集合元素
list.add("李庚希");
list.add("李月如");
list.add("李逍遥");
list.add("赵灵儿");
// 3 遍历集合, 以指定格式打印集合。
for (int i = 0; i < list.size(); i++) {
if (i == 0) {
System.out.print("{" + list.get(i));
} else if (i == list.size() - 1) {
System.out.print("@" + list.get(i) + "}");
} else {
System.out.print("@" + list.get(i));
}
}
}
}
获取集合方法
定义获取所有偶数元素集合的方法(ArrayList类型作为返回值)
package com.witty.web.demo07_ArrayList;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Random;
/*
获取集合方法
**定义获取所有偶数元素集合的方法(ArrayList类型作为返回值)**
*/
public class ArrayListWork03 {
public static void main(String[] args) {
// 1 创建随机数对象
Random r = new Random();
// 2 创建集合list
ArrayList<Integer> list = new ArrayList<>();
// 3 产生随机数1-100存入list集合中
for (int i = 0; i < 20; i++) {
int num = r.nextInt(100) + 1;
list.add(num);
}
// 4 创建方法 传入list, 返回偶数集合listEven
ArrayList<Integer> listEven = Even(list);
for (Integer integer : listEven) {
System.out.print(integer + " ");
}
}
private static ArrayList<Integer> Even(ArrayList<Integer> list) {
// 创建偶数集合
ArrayList<Integer> listEven = new ArrayList<>();
// 遍历集合
for (int i = 0; i < list.size(); i++) {
// 判断偶数添加到新集合
if (list.get(i) % 2 == 0) {
listEven.add(list.get(i));
}
}
return listEven;
}
}