day06 Scanner类、Random类、匿名对象、ArrayList类

2020年2月08日

API(Application Programming Interface)，应用程序编程接口，java API是JDK中提供给我们使用的类的说明文档，这些类将底层的代码实现封装了起来。我们可以通过查询API的方式，来学习java提供的类。

Scanner类

一个可以解析基本类型和字符串的简单文本扫描器

System.in系统输入指的是通过键盘录入数据

  1. 导包
格式

import 包名.类名;

  1. 创建对象
格式

数据类型 变量名 = new 数据类型(参数列表);

  1. 调用方法
格式

变量名.方法名();

Scanner类的使用步骤

查看类
  • java.util.Scanner:该类需要import导入后使用
查看构造方法
  • public Scanner(InputStream source)构造一个新的Scanner,它生成的值是从指定的输入流扫描的
查看成员方法
  • public int nextInt();将输入信息的下一个标记扫描为一个int值

使用Scanner类,完成接受键盘录入数据的操作,代码如下:

import java.util.Scanner;

/*
Scanner类的功能：可以实现键盘输入数据，到程序当中

引用类型的一般使用步骤：
1.导包
import 包路径.类名称；
如果需要使用的目标类，和当前类位于同一包下，则可以省略导包语句不写
只有java.lang包下的内容不需要导包，其他的包都需要import语句
2.创建
类名称 对象名=new 类名称（）;
对象名.成员方法名（)
3.使用
 */
public class Demo01Scanner {
    public static void main(String[] args) {
        //2.创建
        //备注:System.in代表从键盘进行输入
        Scanner sc = new Scanner(System.in);
        //3.获取键盘输入的int数字
        int num = sc.nextInt();
        System.out.println("输入的int数字是" + num);
        //4.获取键盘输入的字符串
        String str = sc.next();
        System.out.println("输入的字符串是" + str);
    }
}

练习

求和
/*
题目：键盘输入两个int数字，并且求出和值
思路：
1.需要键盘输入，就用Scanner
2.Scanner三步骤：导包、创建、使用
3.需要的是两个数字，需要调用两次nextInt（）
4.得到两个数字，需要加在一起
5.将结果打印输出
 */

import java.util.Scanner;

public class Demo02Scanner {
    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 = add(num1, num2);
        System.out.println(sum);
    }

    public static int add(int num1, int num2) {
        return num1 + num2;
    }
}
取最值
import java.util.Scanner;

/*
题目：
键盘上输入三个int数字，然后求出其中的最大值。
思路：
1.键盘输入，需要用到Scanner
2.Scanner三个步骤；导包、创建、使用nextInt()方法
3.既然是三个数字，就调用三个nextInt（）方法，得到三个int变量
4，无法同时判断三个数字谁最大，应转换成两个步骤
    4.1 首先判断前两个中谁最大，得到前两个的最大值
    4.2 拿着前两个数字的最大值，再和第三个数字比较，得到三个数字中的最大值
5.打印结果
 */
public class Demo03ScannerMax {
    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 max=temp>num3?temp:num3;
        System.out.println("max is "+max);
    }
}

匿名对象

概念

没有变量名的对象,创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量.虽然是创建对象的简化写法,但是应用场景非常有限.

应用场景
  1. 创建匿名对象直接调用方法,没有变量名
  2. 一旦调用了两次方法,就是创建了两个对象,造成浪费
  3. 匿名对象可以作为方法的参数和返回值
  • 作为参数
/*
创建对象的标准格式：
类名称 对象名=new 类名称（）；
匿名对象就是只有右边的对象，没有左边的名字和赋值运算符
注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
使用建议：如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象。
 */
public class Demo01Anonymous {
    public static void main(String[] args) {
        Person one = new Person();
        one.name = "Amy";
        one.showName();
        //匿名对象
        new Person().name = "Han";
        new Person().showName();
    }
}
  • 作为返回值
import java.util.Scanner;

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 num1=sc.nextInt();
        System.out.println(num1);
    }
    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

用于生成伪随机数

查看类
  • java.util.Random
查看构造方法
  • public Random():创建一个新的随机数生成器
查看成员方法
  • public int nextInt(int n):返回一个伪随机数,范围在[0,n)之间的int值

使用Random类,完成生成100个10以内的随机整数的操作

import java.util.Random;

public class Demo02Random {
    public static void main(String[] args) {
        Random r=new Random();
        for (int i = 0; i < 100; i++) {
            int num = r.nextInt(10);
            System.out.println(num);
        }
    }
}

备注:创建一个Random对象,每次调用nextInt()方法,都会生成一个随机数

练习

获取随机数

获取1-n之间的随机数,包含n,代码如下:

import java.util.Random;

/*
要求：
根据int变量n的值，来获取随机数字，范围是[1,n]
思路：
1.定义一个int变量n，随意赋值
2.要使用Random：三个步骤：导包、创建、使用
3.整体+1即可
4.打印
 */
public class Demo03Random {
    public static void main(String[] args) {
        int n=5;
        Random r=new Random();
        for (int i = 0; i < 100; i++) {
            int result = r.nextInt(n)+1;
            System.out.println(result);
        }
    }
}
猜数字小游戏
/*
猜数字，数字在1-100之间
思路：
1.产生一个随机数字，产生后不再变化，用Random的nextInt方法
2.键盘输入，用Scanner
3.用Scanner的nextInt获得键盘上的数字
4.判断（if）三种情况
5.重试就是再来一次，循环次数不确定，可以用while（true）
 */
import java.util.Random;
import java.util.Scanner;

public class Demo04Random {
    public static void main(String[] args) {
//        int n = 100;
//        Random r = new Random();
//        int num = r.nextInt(n)+1;//[1,100]
//        int count=1;
//        System.out.println("猜猜这是几？");
//        Scanner in=new Scanner(System.in);
//        int guessNum = in.nextInt();
//        while (guessNum!=num){
//            if(guessNum>num){
//                System.out.println("大了");
//            }else {
//                System.out.println("小了");
//            }
//            System.out.println("继续猜猜这是几？");
//            guessNum=in.nextInt();
//            count++;
//        }
//        System.out.println("congratulation!you are right!");
//        System.out.println("一共猜了"+count+"次");
        Random r=new Random();
        int randomNum=r.nextInt(100)+1;
        Scanner sc=new Scanner(System.in);
        while (true){
            System.out.println("输入猜测的数字");
            int guessNum = sc.nextInt();
            if(guessNum>randomNum){
                System.out.println("大了");
            }else if(guessNum<randomNum){
                System.out.println("小了");
            }else {
                System.out.println("猜对啦");
                break;
            }
        }
        System.out.println("游戏结束");
    }
}

ArrayList类

对象数组
/*
定义一个数组，用来存储三个Person对象
数组有一个缺点，一旦创建，程序运行期间长度不可以改变
 */
public class Demo01Arraylist {
    public static void main(String[] args) {
        //首先创建一个长度为3的数组,用来存放Person类型的对象
        Person[] array=new Person[3];
        Person one=new Person("小红",18);
        Person two=new Person("小明",28);
        Person three=new Person("小东",38);

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

数组的长度是固定的,无法适应数据变化的需求,java提供另一个容器java.util.ArrayList集合类,让我们可以更便捷地存储和操作对象数据

ArrayList中可不断添加元素,其大小也自动增长

ArrayList使用步骤

查看类
  • java.util.ArrayList<E>
  • <E>,表示一种指定的数据类型 ,叫做泛型.E,取自Element的首字母,出现E的地方用一种引用数据类型将其替换即可,表示我们将存储哪种引用类型的元素
查看构造方法
  • public ArrayList():构造一个内容为空的集合
查看成员方法
  • public boolean add(E e):将指定的元素添加到此集合的尾部
import java.util.ArrayList;

/*
数组的长度不可以发生改变
ArrayList的长度可以随意变化
对于ArrayList来说，有一个尖括号<E>代表泛型
泛型：装在集合当中的所有元素，全都是统一的什么类型
注意：泛型只能是引用类型，不能是基本类型
注意事项：
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容
如果内容是空，得到的是空的中括号：[]
 */
public class Demo02ArrayList {
    public static void main(String[] args) {
        //创建了一个ArrayList集合，集合的名称是list，里面装的全是String字符串类型的数据
        /*
        备注:从JDK1.7+开始,右侧的尖括号内部可以不写内容,但是<>本身还是要写的.
         */
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);//[]
        //向集合当中添加一些数据,需要用到add方法
        list.add("小明");
        list.add("小东");
        list.add("小红");
        System.out.println(list);

    }
}
常用方法和遍历
  • public boolean add(E e):将指定元素添加到集合尾部
  • public E remove(int index):移除此集合中指定位置上的元素,返回被删除的元素
  • public E get(int index):返回此集合中指定位置上的元素,返回获取的元素
  • public int size():返回此集合中的元素数,遍历集合时,可以控制索引范围,防止越界
/*
ArrayList当中的常用方法有：
public boolean add（E e）：向集合当中添加元素，参数的类型和泛型一致
备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用
但是对于其他集合来说，add添加动作不一定成功，
public E get（int index）：从集合当中获取元素，参数是索引编好，返回值就是对应位置的元素
public E remove(int index):从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素
public int size（）：获取集合的尺寸长度，返回值是集合中包含的元素个数
 */
public class Demo03ArrayListMethod {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //向集合中添加元素：add
        list.add("小明");
        list.add("小红");
        list.add("小东");
        System.out.println(list);
        //从集合中获取元素：get。索引值从0开始
        String name = list.get(0);
        System.out.println("第零号索引位置" + name);
        //从集合中删除元素：remove。索引值从0开始
        String whoRemove = list.remove(2);
        System.out.println("被删除的人是" + whoRemove);
        System.out.println(list);
        //获取集合的长度尺寸，也就是其中元素的个数
        int size = list.size();
        System.out.println("集合的长度是" + size);
    }

}
存储基本数据类型

ArrayList对象不能存储基本数据类型,只能存储引用类型的数据.所以,需要存储基本类型数据,<>中的数据类型,必须转换后才能编写

基本类型 基本类型包装型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean 
/*
如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”
基本类型    包装类
byte        Byte
short       Short
int         Integer     【特殊】
long        Long
float       Float
double      Double
char        Character   【特殊】
boolean     Boolean
从JDK1.5+开始，支持自动装箱、自动拆箱
自动装箱：基本类型-->包装类型（int-->Integer)
自动拆箱：包装类型-->基本类型(Integer-->int)
 */

import java.util.ArrayList;

public class Demo05ArrayListBasic {
    public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        //错误写法！泛型只能是引用类型，不能是基本类型
//        ArrayList<int> listB=new ArrayList<>();
        ArrayList<Integer> listC = new ArrayList<>();
        listC.add(100);
        listC.add(200);
        System.out.println(listC);
        Integer num = listC.get(1);
        System.out.println("第一号元素是" + num);
    }
}

练习

数值添加到集合
/*
生成6个1~33之间的随机整数，添加到集合，并遍历集合
思路：
1.存储六个数字，创建一个集合<Integer>
2.用Random类产生随机数
3.用循环6次，产生6个随机数，for循环
4.循环内调用r.nextInt（int n）
5.把数字添加到集合中:add
6.遍历集合：for、size、get
 */
public class Demo06ArrayListRandam {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Random r = new Random();
        for (int n = 0; n < 6; n++) {
//            list.add(r.nextInt(33)+1);
            int num = r.nextInt(33) + 1;
            list.add(num);
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}
对象添加到集合
import java.util.ArrayList;

/*
自定义4个学生对象，添加到集合，并遍历
1.定义Student类
2.创建一个集合，用来存储学生对象。泛型：<Student>
3.根据类，创建4个对象
4.将4个学生对象添加到集合中：add
5.遍历集合：for、size、add
 */
public class Demo07ArrayListStudent {
    public static void main(String[] args) {
        Student stu1=new Student("小林",18);
        Student stu2=new Student("小李",28);
        Student stu3=new Student("小赵",38);
        Student stu4=new Student("小孙",48);

        ArrayList<Student> list=new ArrayList<>();
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        list.add(stu4);
        for (int i = 0; i < list.size(); i++) {
//            System.out.println("名字是"+list.get(i).getName()+"年龄是"+list.get(i).getAge());
            Student stu=list.get(i);
            System.out.println("姓名"+stu.getName()+"年龄"+stu.getAge());
        }
    }
}
打印集合方法
import java.util.ArrayList;

/*
定义以指定格式打印集合的方法（ArrayList类型作为参数），使用{}括起集合，使用@分隔每个元素
格式参照{元素@元素@元素}
 */
public class Demo08ArrayListPrint {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Tom");
        list.add("Tommy");
        list.add("Jenny");
        list.add("Jam");
        list.add("lay");
        print(list);
    }

    public static void print(ArrayList<String> list) {
        System.out.print("{");
        for (int i = 0; i < list.size() - 1; i++) {
            System.out.print(list.get(i) + "@");
        }
        System.out.print(list.get(list.size() - 1) + "}");
    }
}
获取集合方法
import java.util.ArrayList;
import java.util.Random;

/*
用一个集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合中
要求使用自定义的方法实现筛选
 */
public class Demo09ArrayListReturn {
    public static void main(String[] args) {
        ArrayList<Integer> listA = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 20; i++) {
            listA.add(r.nextInt());
        }
        ArrayList<Integer> listB = choose(listA);
        for (int i = 0; i < listB.size(); i++) {
            System.out.println(listB.get(i));
        }
        System.out.println("偶数共有多少个：" + listB.size());
    }

    public static ArrayList<Integer> choose(ArrayList<Integer> list) {
        ArrayList<Integer> listB = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i) % 2 == 0) {
                listB.add(list.get(i));
            }
        }
        return listB;
    }
}
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/ningdeblog/p/12285327.html