Java语言入门||02_面向对象与常用类||day07_Scanner类，Random类，ArrayList类

第一章 API

1.1 API的概述和使用步骤

概述：
- API，应用程序编程接口。
- Java API是一本程序员的++字典++，是JDK中提供给我们使用的类的++说明文档++。

第二章 Scanner类

2.1 什么是Scanner类

官方：一个可以解析基本数据类型和字符串的简单文本扫描器
- 例：下面代码使用户能够从system.in中读取一个数
```
    Scanner sc = new Sacnner(System.in);
    int i = sc.nextInt();
```
- 注：++System.in++系统输入指的是通过键盘录入数据
Scanner类的功能：可以实现键盘输入数据，到程序当中。
++引用类型++的++一般使用步骤++：（除了基本类型都是）
1. 导包
  - import 包路径.类名称;
  - 注：++如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写++
  - 注：++只用java.lang包下的内容不需要导包，其他的包都需要import语句++
2. 创建
  - 类名称对象名 = new 类名称();
3. 使用
  - 对象名成员方法名();

2.2 Scanner使用步骤（都可从API查询）

导包
- java.util.Scanner
创建
- Scanner sc = new Scanner(System.in);
使用
- 获取键盘输入的一个int数字：int num = sc.nextInt(); //有返回值;将字符串next转化为数值int
- 获取键盘输入的一个字符串：String str = sc.next();

注：运行结果中绿色代表输入

    import java.util.Scanner;   //1.导包

    public class Demo01Scanner {
        public static void main(String[] args) {
            //2.创建
            Scanner sc = new Scanner(System.in);
            //3.使用：获取键盘输入的一个int数字
            int num = sc.nextInt();
            System.out.println("输入的int数字是：" + num);
            //使用：获取键盘输入的一个字符串
            String str = sc.next();
            System.out.println("输入的字符串是：" + str);
        }
    }

2.3 Scanner练习一：键盘输入两个数字求和

注：需要的是两个数字，所以要调用两次nextInt()方法

    import java.util.Scanner;

    public class Demo01SacnnerSum {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第一个数：");
            int num1 = sc.nextInt();
            System.out.println("请输入第二个数：");
            int num2 = sc.nextInt();
            int sum = num1 + num2;
            System.out.println("两数求和为：" + sum);
        }
    }

2.4 Scanner练习二：键盘输入三个数字求最大值

     import java.util.Scanner;

     public class Demo02ScannerMax {
         public static void main(String[] args) {
             Scanner sc = new Scanner(System.in);
             System.out.println("请输入第一个数：");
             int num1 = sc.nextInt();
             System.out.println("请输入第二个数：");
             int num2 = sc.nextInt();
             System.out.println("请输入第三个数：");
             int num3 = sc.nextInt();
             int temp = num1 > num2 ? num1 : num2;
             int maxN = temp > num3 ? temp : num3;
             /*int maxN = num1;
             if(num2 > maxN){
                 maxN = num2;
             }else if(num3 > maxN){
                 maxN = num3;
             }*/
             System.out.println("最大值是：" + maxN);
         }
     }

2.5 匿名对象的说明

创建对象的标准格式：
- 类名称对象名 = new 类名称();

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符

new 类名称();
注：++匿名对象只能使用唯一一次，下次再用不得不再创建一个新的对象。++
使用建议：如果确定一个对象只需要使用唯一的一次，就可以使用匿名对象

        public static void main(String[] args) {
        //创建对象的标准格式
        Person one = new Person();
        one.name = "高圆圆";
        one.showName();
        System.out.println("============");
        //匿名对象
        new Person().name = "赵又廷";
        new Person().showName();    //null(赵又廷放到了第二个对象中)
    }

2.6 匿名对象作为方法的参数和返回值

    public class Demo02Anonymous {
        public static void main(String[] args) {
            //普通使用方式
    //        Scanner sc = new Scanner(System.in);
    //        int num = sc.nextInt();
    
            //匿名对象
    //        int num = new Scanner(System.in).nextInt();
    //        System.out.println("输入的是：" + num);
    
            //使用一般方法传入参数
    //        Scanner sc = new Scanner(System.in);
    //        methodParam(sc);
    
            //使用匿名对象进行传参
    //        methodParam(new Scanner(System.in));
            Scanner sc = methodReturn();
            int num = sc.nextInt();
            System.out.println("输入的是:" + num);
        }
    
        public static void methodParam(Scanner sc){
            int num = sc.nextInt();
            System.out.println("输入的是：" + num);
        }
    
        public static Scanner methodReturn(){
    //        Scanner sc = new Scanner(System.in);
    //        return sc;
            return new Scanner(System.in);
        }
    }

第三章 Random类

3.1 概述和基本使用

Random类的功能：用来生成随机数字
使用步骤：
1. 导包
  - java.util.Random
2. 创建
  - Random r = new Random(); //留空即可
3. 使用
  - 获取一个随机的int数字（是int所有范围，有正负两种）
  - int num = r.nextInt();

    import java.util.Random;

    public class Demo01Random {
        public static void main(String[] args) {
            Random r = new Random();
            int num = r.nextInt();
            System.out.println("随机数是：" + num);
        }
    }

3.2 Random生成指定范围的随机数

获取一个随机的int数字（参数代表了范围，左闭右开区间）

int num = r.nextInt(3);
实际上表示的含义是：++[0,3)—>也就是0~2++

        public static void main(String[] args) {
        Random r = new Random();

        for (int i = 0; i < 100; i++) {
            int num = r.nextInt(10);    //0~9
            System.out.println(num);
        }
    }

3.3 Random练习一：生成1~n的随机数

注：可以取到1和n（左闭右闭区间）
注：+++1一定要写在外面++

思路：
1. 定义一个int变量n，可以随意赋值（正）
2. 使用Random:导包，创建，使用
3. 如果写10，那么是0_{9，想要的是1}10，发现：++整体+1即可++(r.nextInt(num) + 1)
4. 打印

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入n的值：");
        int num = sc.nextInt();
        Random r = new Random();
        int num1 = r.nextInt(num) + 1;  //本来范围是[0, n)——>都加1[1, n+1)——>[1, n]
        System.out.println("1~n的随机数是：" + num1);
    }

3.4 Random练习二：猜数字小游戏

注：可以对半猜（二分法查找）

思路：

产生一个随机数字，一旦产生不在变化：用到Random的nextInt方法(有参)
键盘输入：Scanner
获取键盘输入的数字：用到Scanner的nextInt方法
已经得到了两个数字，判断（if）：
- 如果大：提示大，重试
- 如果小：提示小，重试
- 如果猜对：游戏结束
重试就是再来一次，循环次数不确定:while(true)

    public static void main(String[] args) {
        Random r = new Random();
        int numR = r.nextInt(10) + 1;  //[1, 10]
        System.out.println("随机数生成！！");
        while (true){
            System.out.println("请输入猜的值：");
            Scanner sc = new Scanner(System.in);
            int numS = sc.nextInt();
            if(numR == numS) {
                System.out.println("猜对了！！");
                break;
            }else if(numR > numS){
                System.out.println("猜小了");
                continue;   //也可以不写
            }else if(numR < numS){
                System.out.println("猜大了");
                //continue;
            }
        }
        System.out.println("游戏结束");
    }

3.5 对象数组

定义一个数组，用来存储3个Person对象
数组有一个缺点：一旦创建，程序运行期间长度不可以发生改变

    //定义一个类：Person.java
    public class Person {
        private String name;
        private int age;
    
        public Person() {
        }
    
        public Person(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;
        }
    }
    //创建一个对象：Demo01Array.java
    public static void main(String[] args) {
        //创建一个数组，用来存储3个对象
        Person[] arrayA = new Person[3];

        Person one = new Person("魂", 18);
        Person two = new Person("斗", 22);
        Person three = new Person("罗", 44);

        //将one当中的地址值，赋值到地址的0号元素位置
        arrayA[0] = one;
        arrayA[1] = two;
        arrayA[2] = three;

        //输出的地址
        System.out.println(arrayA[0]);
        System.out.println(arrayA[1]);
        System.out.println(arrayA[2]);

        //Person person = arrayA[1];
        //System.out.println(person.getName());
        //上面简写：
        System.out.println(arrayA[1].getName());
    }

第四章 ArrayList集合类

4.1 概述和基本使用

与数组的区别：
- ++数组的长度不可以发生改变++
- ++ArrayList集合的长度是可以随意变化的++
对于ArrayLIst来说，有一个尖括号代表泛型（++类型的一种约束++）
- 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型
- 注：泛型只能是引用类型，不能是基本类型

注：++从JDK1.7==+==开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的++
注：++对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。++
- 如果内容是空，得到的是空的中括号：++[]++

    public static void main(String[] args) {
        //创建了一个ArrayList集合，集合的名称listA，里面装的全都是String字符串类型的数据
        //注：从JDK1.7开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的
        ArrayList<String> listA = new ArrayList<>();

        System.out.println(listA);  //输出的是：[]

        //向集合中添加一些数据，需要用到add方法
        listA.add("赵丽娟");
        System.out.println(listA);  //[赵丽娟]
        listA.add("魂");
        listA.add("斗");
        listA.add("罗");
        listA.add("！！！");
        System.out.println(listA);  //[赵丽娟，魂，斗，罗，！！！]
    }

4.2 常用方法和遍历

ArrayList常用的方法：

public boolean add(E e); //向集合当中添加元素，参数的类型和泛型一致(返回值代表添加是否成功)
- 注：对应++ArrayList集合来说，add添加动作一定成功++，返回值可用可不用
- 但是！对于++其他集合++（后面学习）来说，++add添加动作不一定成功++
public E get(int index); //从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素
public E remove(int index); //从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素
public int size(); //获取集合的尺寸长度，返回值是集合中包含的元素个数
- 注：++数组中求长度没有()：num.length++

    public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        System.out.println(listA);  //[]

        //添加元素：add
        boolean success = listA.add("柳岩");
        System.out.println(listA);
        System.out.println("添加动作是否成功：" + success);

        listA.add("霍元甲");
        listA.add("陈正");
        listA.add("叶问");
        System.out.println(listA);  //[柳岩， 霍元甲， 陈正， 叶问]

        //获取元素：get（0开始）
        String name = listA.get(1);
        System.out.println("第1号索引位置：" + name);  //霍元甲

        //删除元素：remove（0开始）
        String whoRemove = listA.remove(2);
        System.out.println("被删除的人是：" + whoRemove);  //陈正
        System.out.println(listA);  //[柳岩， 霍元甲， 叶问]

        //获取长度：size,也就是元素的个数
        int size = listA.size();
        System.out.println("集合长度是：" + size);
    }

遍历集合：

快捷生成：listA.fori

    public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        listA.add("黄飞鸿");
        listA.add("霍元甲");
        listA.add("陈正");
        listA.add("叶问");

        //遍历集合（原来）
        //        for(int i = 0; i < array.length; i++){
        //            System.out.println(array[i]);
        //        }
        //遍历集合
        for(int i = 0; i < listA.size(); i++){
            System.out.println(listA.get(i));
        }
        for(String list : listA){
            System.out.println(list);
        }
    }

4.3 ArrayList集合存储基本数据类型

++如果希望向ArrayList集合当中存储基本数据类型，必须使用基本类型对应的++包装类
基本数据类型：
- byte
- short
- int
- long
- float
- double
- char
- boolean
包装类(引用类型，包装类都位于java.lang—不需要导入):
- Byte
- Short
- Integer
- Long
- Float
- Double
- Character
- Boolean
从JDK1.5开始，支持自动拆箱，自动装箱。
- 自动装箱：基本类型 --> 引用类型(自动变成)
- 自动拆箱：引用类型 --> 基本类型(自动)

4.4 ArrayList练习一：存储随机数字

要求：
- 生成6个1~33之间的随机整数，添加到集合，并遍历
思路：
1. 需要储存6个数字，创建一个集合，
2. 产生随机数：Random
3. 循环6次，（确定了次数）：for
4. 循环内调用r.Random(int n),参数是33， 0~32，整体+1 --> 0~33
5. 把数字添加到集合中：add
6. 遍历集合：for,size,get

    public static void main(String[] args) {
        ArrayList<Integer> listA = new ArrayList<>();

        Random r = new Random();

        for (int i = 0; i < 6; i++) {
            listA.add(r.nextInt(33) + 1);
//          int num = r.nextInt(33) + 1;
//          listA.add(num);
        }

        for (int i = 0; i < listA.size(); i++) {
            System.out.println("随机6个数分别是：" + listA.get(i));
        }
        System.out.println(listA);
    }

4.5 ArrayList练习二：存储自定义对象

要求：
- 自定义4个学生对象，添加到集合，遍历
思路：
1. 自定义Student类，四个部分
2. 创建一个集合，用来存储学生对象。泛型：
3. 根据类，创建4个对象，并赋值。
4. 将四个对象添加到集合中：add
5. 遍历集合：for，size，get

    //定义一个类：Student.java
    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;
        }
    }
    //创建一个学生对象：Demo01ArrayListStudent.java
    public static void main(String[] args) {
        ArrayList<Student> listA = new ArrayList<>();

        Student student1 = new Student("王力宏", 18);
        Student student2 = new Student("王祖蓝", 44);
        Student student3 = new Student("任达华", 33);
        Student student4 = new Student("刘德华", 55);

        listA.add(student1);
        listA.add(student2);
        listA.add(student3);
        listA.add(student4);

        for (int i = 0; i < listA.size(); i++) {
            System.out.println("第" + (i + 1) + "个同学名字是" + listA.get(i).getName() + "年龄：" + listA.get(i).getAge());
//            Student stu = listA.get(i);
//            System.out.println("学生：" + stu.getName() + "姓名：" + stu.getAge());
        }
    }

4.6 ArrayList练习三：按照指定格式遍历集合字符串

注：锻炼用集合作为参数
注：方法参数列表传入的其实是地址值

要求：
1. 定义一个集合
2. 方法将ArrayList类型作为参数
3. 要求将[]换成{}
4. 要求将,换成@
思路：
1. 原来：System.out.println(listA); //[1, 4, 5]
2. 现在：printArrayList(listA); //{1@ 4@ 5}
3. 创建一个集合
5. 定义方法的三要素：
  - 返回类型：只进行打印，没有运算和结果：void
  - 方法名称：printArrayList
  - 参数列表：ArrayList

    public class Demo03ArrayListPrint {
        public static void main(String[] args) {
            ArrayList<String> listA = new ArrayList<>();
            listA.add("黄飞鸿");
            listA.add("霍元甲");
            listA.add("张三丰");
            listA.add("李小龙");
            System.out.println(listA);
    
            //调用
            printArrayList(listA);
        }
    
        /*
        定义方法的三要素：
            返回类型：只进行打印，没有运算和结果：void
            方法名称：printArrayList
            参数列表：ArrayList
         */
    
        public static void printArrayList(ArrayList<String> listA){
            System.out.print("{");
            for (int i = 0; i < listA.size(); i++) {
                String name = listA.get(i);
                if(i == listA.size() - 1){
                    System.out.print(name + "}");
                }else{
                    System.out.print(name + "@ ");
                }
            }
        }
    }

4.7 ArrayList练习四：筛选集合中的随机数

要求：
1. 用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中
2. 要求使用自定义的方法进行筛选
思路：
1. 创建一个大集合，来存储int数字：
2. 随机数字用：Random的nextInt
3. 循环20次，把随机数放到大集合：for,add
4. 自定义一个方法，用来进行筛选
  - 筛选：根据大集合，筛选元素，放到小集合
  - 三要素：
    - 返回值类型：ArrayList小集合（里面元素个数不确定）
    - 方法名称：getSmallList
    - 参数列表：ArrayList大集合（装20个随机数字的）
5. 判断是不是偶数：(num%2==0),if
6. 如果是偶数，就放到小集合，否则不放
7. ++在main方法中新建一个小集合来接收一下++
8. 便利这个小集合：for

++注：集合可以当做方法的参数和返回值：++
- 集合如果是参数：传递进去的是地址值
- 集合如果是返回值：返还回来的也是地址值

    public static void main(String[] args) {
        ArrayList<Integer> listBig = new ArrayList<>();

        Random r = new Random();

        for (int i = 0; i < 20; i++) {
            int num = r.nextInt(100) + 1;   //[1, 100]
            listBig.add(num);
        }

        //创建一个接收小集合
        ArrayList<Integer> smallList = getSmallList(listBig);   //这是新建的集合
        System.out.println("大集合中偶数总共有：" + smallList.size() + "分别是：");
        for (int i = 0; i < smallList.size(); i++) {
            System.out.print(smallList.get(i) + " ");
        }
    }

    //这个方法，接收大集合，返回小集合结果
    public static ArrayList<Integer> getSmallList(ArrayList<Integer> listBig){
        //创建一个小集合，用来装偶数结果
        ArrayList<Integer> listSmall = new ArrayList<>();
        for (int i = 0; i < listBig.size(); i++) {
            Integer num = listBig.get(i);
            if(num % 2 == 0){   //是偶数
                listSmall.add(num);
            }
        }
        return listSmall;
    }

狂野小白兔

发布了42 篇原创文章 · 获赞 6 · 访问量 1143

私信关注

Java语言入门||02_面向对象与常用类||day07_Scanner类，Random类，ArrayList类

第一章 API

1.1 API的概述和使用步骤

第二章 Scanner类

2.1 什么是Scanner类

2.2 Scanner使用步骤（都可从API查询）

2.3 Scanner练习一：键盘输入两个数字求和

2.4 Scanner练习二：键盘输入三个数字求最大值

2.5 匿名对象的说明

2.6 匿名对象作为方法的参数和返回值

第三章 Random类

3.1 概述和基本使用

3.2 Random生成指定范围的随机数

3.3 Random练习一：生成1~n的随机数

3.4 Random练习二：猜数字小游戏

3.5 对象数组

第四章 ArrayList集合类

4.1 概述和基本使用

4.2 常用方法和遍历

4.3 ArrayList集合存储基本数据类型

4.4 ArrayList练习一：存储随机数字

4.5 ArrayList练习二：存储自定义对象

4.6 ArrayList练习三：按照指定格式遍历集合字符串

4.7 ArrayList练习四：筛选集合中的随机数

猜你喜欢