Java SE面向对象--07.Scanner类、Random类、ArrayList类

版权声明：转载请注明原始链接 https://blog.csdn.net/sswqzx/article/details/82701375

学习目标

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