学习目标
Scanner类
Random类
ArrayList类
一、 Scanner类
1.1 什么是Scanner类
如果想把数据改进为键盘录入,提高程序的灵活性。想要完成键盘录入的功能就需要使用java中的Scanner类。
例如,以下代码使用户能够从 System.in 中读取一个数:
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();//获取一个整数
备注:System.in 系统输入指的是通过键盘录入数据。
1.2 引用类型使用步骤
导包
因为我们要使用的类本身和我们自己定义的类无关 ,所以想要使用某个类中的方法来解决需求的时候,首先需要使用import关键字导包,将需要使用的类导入到我们自己书写的类中。导入位置放到class和package之间。引入要使用的类型。java.lang包下的所有类无需导入。IDEA自动导包快捷键ALT+ENTER
格式:
import 包名.类名;
举例:
java.util.Scanner;
创建对象
想要使用类中的方法就需要使用类的对象,先查看该类的有无构造方法。如果有就使用该类的构造方法,创建一个该类的对象。
格式:
数据类型 变量名 = new 数据类型(参数列表);
举例:
Scanner sc = new Scanner(System.in);
调用方法
调用该类的成员方法,完成指定功能。后期学习或者自学的方式就是使用哪个类就去API中查找,查看是否提供构造方法,如果有提供就创建那个类的对象,然后使用对象调用类中的方法,测试方法的作用。
格式:
变量名.方法名();
举例:
int i = sc.nextInt(); // 接收一个键盘录入的整数
1.3 Scanner使用步骤
查看类
java.util.Scanner
:该类需要import导入后使用。
查看构造方法
该类提供了大量的构造方法用来创建对象,键盘录入的构造方法用如下:
public Scanner(InputStream source)
: 构造一个新的Scanner
,它生成的值是从指定的输入流扫描的。
查看成员方法
该类或其他类提供了大量的方法用来完成各种功能,因为方法较多,用到哪个讲哪个。
public int nextInt()
:将输入信息的下一个标记扫描为一个int
值。
使用Scanner类,完成接收键盘录入数据的操作,代码如下:
//1. 导包
import java.util.Scanner;
public class Demo01_Scanner {
public static void main(String[] args) {
//2. 创建键盘录入数据的对象
Scanner sc = new Scanner(System.in);
//3. 接收数据
System.out.println("请录入一个整数:"); // 录入前提示
int i = sc.nextInt(); // 输入int类型数据并将值赋值给左侧变量
double dou = sc.nextDouble(); // 输入double类型数据并将值赋值给左侧变量
String src = sc.next(); // 输入String类型数据并将值赋值给左侧变量
char c = sc.next().charAt(0); // 输入char类型数据并将值赋值给左侧变量
//4. 输出数据
System.out.println("i=" + i + "dou=" + dou + "src=" +src + "c=" + c);
}
}
1.4 练习
求和
键盘录入两个数据并求和,代码如下:
import java.util.Scanner;
public class Test01Scanner {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);
// 接收数据
System.out.println("请输入第一个数据:");
int a = sc.nextInt();
System.out.println("请输入第二个数据:");
int b = sc.nextInt();
// 对数据进行求和
int sum = a + b;
System.out.println("sum:" + sum);
}
}
取最值
键盘录入三个数据并获取最大值,代码如下:
import java.util.Scanner;
public class Test02Scanner {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);
// 接收数据
System.out.println("请输入第一个数据:");
int a = sc.nextInt();
System.out.println("请输入第二个数据:");
int b = sc.nextInt();
System.out.println("请输入第三个数据:");
int c = sc.nextInt();
// 如何获取三个数据的最大值
int temp = (a > b ? a : b);
int max = (temp > c ? temp : c);
System.out.println("max:" + max);
// 改造为使用循环和数组的方式求最值
// 创建数组,将录入的数据保存到数组中
int[] arr = new int[3];
// 循环录入数据
for (int i = 1; i <= 3; i++) {
System.out.print("请输入第" + i + "个数据:");
// 依次将录入的数据保存到数组中,下标从0开始,所以i要-1
arr[i -1 ] = sc.nextInt();
}
// 对数组进行排序
Arrays.sort(arr); // 方法功能:对数组进行由小到大排序(Arrays工具类后面会学到)
// 最大值一定是数组的最后一个下标对应的数据
System.out.println("max = " + arr[arr.length - 1]);
}
}
1.5 匿名对象【理解】
概念
匿名:匿名指的是没有名字。
匿名对象:是指没有名称的对象。创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量。虽然是创建对象的简化写法,但是应用场景非常有限。
正常对象的创建格式:
类名 对象名 = new 类名(参数列表);
举列: Scanner sc = new Scanner(System.in);
说明: =号右侧的对象创建结果赋值给了左侧的变量空间,可以通过变量多次引用
匿名对象创建格式:
new 类名(参数列表);
举例: new Scanner(System.in); new Student();
说明: new对象语句创建完对象之后没有赋值,只能通过当前对象使用一次
匿名对象应用方式
// 演示匿名对象调用成员
class Person{
// 成员变量
String name; // 姓名
int age; // 年龄
// 成员方法
public void say() {
System.out.println("name = " + name + " , age = " + age );
}
}
public class PersonTest {
public static void main(String[] args) {
// 创建匿名对象,并调用成员变量赋值
new Person().age = 19;
new Person().name = "班长";
/*
创建匿名对象,并调用成员方法:
输出的结果为name = null , age = 0。原因是多次使用
new关键字在创建对象,没使用一次new关键字就相当于
创建出一个对象。
*/
new Person().say();
}
}
匿名对象使用场景和总结
结论:
1、匿名对象可以调用成员变量并赋值,但是这样的使用方式并没有意义。同时匿名对象在调用方法时,如果方法本身有访问到成员变量,方法的执行结果依然没有意义。
2、匿名对象通常是在对象只需要访问成员一次的情况下使用,如果对象需要多次的操作成员,就不能使用匿名对象来访问。
3、匿名对象可以简化代码的书写,并且匿名对象没有指针指向引用,一旦匿名对象代码执行结束,这时这个对象就立刻变成垃圾。节约内存成本。
如果对象只使用一次,这时可以采用匿名对象,如果这个对象要使用多次,必须给对象起名。
匿名对象作为参数传递(理解)
public static void main(String[] args) {
// 普通方式 传递对象
// 创建Scanner对象,作为参数传递给show方法
Scanner sc = new Scanner(System.in);
// 调用show方法
show(sc);
// 使用匿名对象的方式
show( new Scanner(System.in) );
}
// 参数调用时需要传递一个Scanner对象、后面大量用到这种写法、当条件满足再写成lambda
public static void show( Scanner sc ) {
System.out.println("sc = " + sc);
}
二、 Random类
2.1 什么是Random类
Java中使用Random类来封装和描述随机数这类事物。此类的实例用于生成随机数。
例如,以下代码使用户能够得到一个随机数:
Random r = new Random();
int i = r.nextInt();//在整数范围内的任意随机数
2.2 Random使用步骤
查看类
java.util.Random
:该类需要 import导入使后使用。
查看构造方法
public Random()
:创建一个新的随机数生成器。
查看成员方法
public int nextInt(int n)
:返回一个伪随机数,范围在0
(包括)和指定值 n
(不包括)之间的int
值。 ( java设计api原则:包头不包尾 )举例:
• int number = r.nextInt(10);
• 产生的数据在0到10之间,包括0,不包括10。
• 括号里面的10是可以变化的,如果是100,就是0-100之间的数据,包括0,不包括100.
需求:使用Random类,完成生成3个10以内的随机整数的操作
代码如下:
//1. 导包
import java.util.Random;
public class Demo01_Random {
public static void main(String[] args) {
//2. 创建键盘录入数据的对象
Random r = new Random();
// 使用循环,快速完成3个随机数的乘车
for(int i = 0; i < 3; i++){
//3. 随机生成一个数据
int number = r.nextInt(10);
//4. 输出数据
System.out.println("number:"+ number);
}
}
}
备注:创建一个
Random
对象,每次调用nextInt(n)
方法,都会生成一个随机数。
2.3 练习
获取随机数
获取1-n之间的随机数,包含n,代码如下:
// 导包
import java.util.Random;
public class Test01Random {
public static void main(String[] args) {
int n = 100;
// 创建对象
Random r = new Random();
// 获取随机数
int number = r.nextInt(n) + 1;
// 输出随机数
System.out.println("number:" + number);
}
}
猜数字小游戏案例
需求:猜数字小游戏案例,系统产生一个1-100之间的随机数,请猜出这个数据是多少。
案例代码如下所示:
import java.util.Random;
import java.util.Scanner;
// 猜数字游戏代码演示
public class Test_Random {
public static void main(String[] args) {
// 生成一个随机数
Random r = new Random();
int ran_number = r.nextInt(100) + 1;
//System.out.println( ran_number );
// 键盘录入
Scanner sc = new Scanner(System.in);
// 循环开始猜数字是否猜对
while (true) {
// 输入猜的数字
System.out.print("请输入要猜的数字:");
int guessNumber = sc.nextInt();
// 比较录入的数字和系统产生的随机数是否相等
if ( ran_number == guessNumber) {
System.out.println("恭喜您猜对了!真聪明!!");
break; // 相等不用继续猜,结束循环
// 如果不相等在比较其他可能, 如果随机数比录入的数字小说明猜大了
} else if (ran_number < guessNumber) {
System.out.println("猜大了!!");
// 进入else说明前面两种关系都不成立,只能是猜小了
}else {
System.out.println("猜小了!!");
}
}
}
}
三、 ArrayList类(very important)
3.1 对象数组
只能存引用类型的集合、底层用的是数组
描述学生类,创建3个学生对象并保存,代码如下:
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;
}
publicvoid setName(String name) {
this.name = name;
}
publicint getAge() {
return age;
}
publicvoid setAge(int age) {
this.age = age;
}
}
public class Test01StudentArray {
public static void main(String[] args) {
//创建学生数组
Student[] students = new Student[3];
//创建学生对象
Student s1 = new Student("曹操",40);
Student s2 = new Student("刘备",35);
Student s3 = new Student("孙权",30);
//把学生对象作为元素赋值给学生数组
students[0] = s1;
students[1] = s2;
students[2] = s3;
//遍历学生数组
for(int x=0; x<students.length; x++) {
Student s = students[x];
System.out.println(s.getName()+"---"+s.getAge());
}
}
}
当我们可以随着程序运行增加的新的数据时就要用到ArrayList
Java提供了另一个容器java.util.ArrayList
集合类,让我们可以更便捷的存储和操作对象数据。
3.2 集合概述
什么是集合?
集合也是一种容器,作用是用来存储对象的。随着我们学习技术的深入,那么我们在程序中创建的对象也会越来越多。这时在程序中就要想办法先把这些对象给存储起来,然后在需要使用这些对象的时候再从容器中把对象取出,最后使用这些对象。
3.3 集合与数组区别
1)从长度来讲:
数组:需要固定长度。
集合:长度可以改变,可以根据保存的数据进行扩容。
2)从存储内容上:
数组:可以存储基本类型数据,同时可以存储引用类型的数据
集合:只能存储引用类型的数据,也就是说集合只能存储类的对象。
3)从存储类型上:
数组:只能存储相同类型的数据。
集合:可以存储不同类型的数据,集合中可以存储任意类型的引用数据类型。
3.4 ArrayList类
集合容器从jdk1.2之后形成了一个庞大的继承体系,而我们这里先学习集合中的一种,叫做ArrayList集合类,
后面会学到 二大体系:collection 单列集合(List、Set)、Map 双列集合(hashMap)
java.util.ArrayList是大小可变的数组的实现,存储在集合内的数据称为元素。此类提供一些方法来操作内部存储的元素。
ArrayList 中可不断添加元素,其大小也自动增长。
3.5 ArrayList使用步骤
查看类
java.util.ArrayList <E>
:该类需要 import导入使后使用。
<E>
,表示一种指定的数据类型,叫做泛型。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对象时,<E>
指定了什么数据类型,那么add(E e)
方法中,只能添加什么数据类型的对象。
需求:使用ArrayList类,存储三个字符串元素
代码如下:
public class Test02StudentArrayList {
public static void main(String[] args) {
//创建集合对象
ArrayList<String> list = new ArrayList<>();
//定义字符串对象
String s1 = "曹操";
String s2 = "刘备";
String s3 = "孙权";
//打印ArrayList集合
System.out.println(list);
//把字符串作为元素添加到集合
list.add(s1);
list.add(s2);
list.add(s3);
//打印ArrayList集合
System.out.println(list);
}
}
3.4 常用方法和遍历
对于元素的操作,基本体现在——增、删、改、查。常用的方法有:
public boolean add(E e)
:将指定的元素添加到此集合的尾部。public E remove(int index)
:移除此集合中指定位置上的元素。返回被删除的元素。public E get(int index)
:返回此集合中指定位置上的元素。返回获取的元素。public e set(int index, E element) 用指定的元素替换此列表中指定位置的元素、返回原来的元素。
public int size()
:返回此集合中的元素数。遍历集合时,可以控制索引范围,防止越界。
这些都是最基本的方法,操作非常简单,代码如下:
public class Demo01ArrayListMethod {
public static void main(String[] args) {
//创建集合对象
ArrayList<String> list = new ArrayList<String>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//public E get(int index):返回指定索引处的元素
System.out.println("get:"+list.get(0));
System.out.println("get:"+list.get(1));
System.out.println("get:"+list.get(2));
//public int size():返回集合中的元素的个数
System.out.println("size:"+list.size());
//public E remove(int index):删除指定索引处的元素,返回被删除的元素
System.out.println("remove:"+list.remove(0));
//遍历输出
for(int i = 0; i < list.size(); i++){
System.out.println(list.get(i));
}
}
}
3.5 如何存储基本数据类型
ArrayList集合不能存储基本类型,只能存储引用类型的数据。类似<int>
属于基本不能写,但是存储基本数据类型对应的包装类型是可以的。所以java将基本类型数据包装成对应的包装类,然后使用对应类中的方法,这样就可以有更广泛的操作了。这样也符合java的万物皆对象的理论。
所以,想要存储基本类型数据,<>
中的数据类型,必须转换后才能编写,转换写法如下:
基本类型 | 基本类型包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
我们发现,只有Integer
和Character
需要特殊记忆,其他基本类型只是首字母大写即可。那么存储基本类型数据,代码如下:
public class Demo02ArrayListMethod {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
System.out.println(list);
}
}
3.6 ArrayList练习
数值添加到集合
生成6个1~33之间的随机整数,添加到集合,并遍历
public class Test01ArrayList {
public static void main(String[] args) {
// 创建Random 对象
Random random = new Random();
// 创建ArrayList 对象
ArrayList<Integer> list = new ArrayList<>();
// 添加随机数到集合
for (int i = 0; i < 6; i++) {
int r = random.nextInt(33) + 1;
list.add(r);
}
// 遍历集合输出
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
对象添加到集合
自定义4个学生对象,添加到集合,并遍历
public class Test02ArrayList {
public static void main(String[] args) {
//创建集合对象
ArrayList<Student> list = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("赵丽颖",18);
Student s2 = new Student("唐嫣",20);
Student s3 = new Student("景甜",25);
Student s4 = new Student("柳岩",19);
//把学生对象作为元素添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
//遍历集合
for(int x = 0; x < list.size(); x++) {
Student s = list.get(x);
System.out.println(s.getName()+"---"+s.getAge());
}
}
}
打印集合方法
定义以指定格式打印集合的方法(ArrayList类型作为参数),使用{}扩起集合,使用@分隔每个元素。格式参照 {元素@元素@元素}。
public class Test03ArrayList {
public static void main(String[] args) {
// 创建集合对象
ArrayList<String> list = new ArrayList<String>();
// 添加字符串到集合中
list.add("张三丰");
list.add("宋远桥");
list.add("张无忌");
list.add("殷梨亭");
// 调用方法
printArrayList(list);
}
public static void printArrayList(ArrayList<String> list) {
// 拼接左括号
System.out.print("{");
// 遍历集合
for (int i = 0; i < list.size(); i++) {
// 获取元素
String s = list.get(i);
// 拼接@符号
if (i != list.size() - 1) {
System.out.print(s + "@");
} else {
// 拼接右括号
System.out.print(s + "}");
}
}
}
}
获取集合方法
定义获取所有偶数元素集合的方法(ArrayList类型作为返回值)。
分析:将生成的1-1000的随机数添加到集合ArrayList中,一共添加10个随机数。
public class Test04ArrayList {
public static void main(String[] args) {
// 创建Random 对象
Random random = new Random();
// 创建ArrayList 对象
ArrayList<Integer> list = new ArrayList<>();
// 添加随机数到集合
for (int i = 0; i < 10; i++) {
int r = random.nextInt(1000) + 1;
list.add(r);
}
// 调用偶数集合的方法
ArrayList<Integer> arrayList = getArrayList(list);
System.out.println(arrayList);
}
public static ArrayList<Integer> getArrayList(ArrayList<Integer> list) {
// 创建小集合,来保存偶数
ArrayList<Integer> smallList = new ArrayList<>();
// 遍历list
for (int i = 0; i < list.size(); i++) {
// 获取元素
Integer num = list.get(i);
// 判断为偶数,添加到小集合中
if (num % 2 == 0){
smallList.add(num);
}
}
// 返回小集合
return smallList;
}
}
**
补充内容:集合遍历总结(了解)
**
Java集合遍历的几种方法:
Map遍历方式:
1、通过获取所有的key按照key来遍历
//Set<Integer> set = map.keySet(); //得到所有key的集合
for (Integer in : map.keySet()) {
String str = map.get(in);//得到每个key多对用value的值
}
2、通过Map.entrySet使用iterator遍历key和value
Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Integer, String> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
3、通过Map.entrySet遍历key和value,推荐,尤其是容量大时
for (Map.Entry<Integer, String> entry : map.entrySet()) {
//Map.entry<Integer,String> 映射项(键-值对) 有几个方法:用上面的名字entry
//entry.getKey() ;entry.getValue(); entry.setValue();
//map.entrySet() 返回此映射中包含的映射关系的 Set视图。
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
4、通过Map.values()遍历所有的value,但不能遍历key
for (String v : map.values()) {
System.out.println("value= " + v);
}
List遍历方式:
第一种:
for(Iterator iterator = list.iterator();iterator.hasNext();){
int i = (Integer) iterator.next();
System.out.println(i);
}
第二种:
Iterator iterator = list.iterator();
while(iterator.hasNext()){
int i = (Integer) iterator.next();
System.out.println(i);
}
第三种:
for (Object object : list) {
System.out.println(object);
}
第四种:
for(int i = 0 ;i<list.size();i++) {
int j= (Integer) list.get(i);
System.out.println(j);
}