Scanner, Random, Arraylist类

最新推荐文章于 2024-10-01 18:51:18 发布

WRZLLZ

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量99

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_47044513/article/details/120117107

版权

API：应用程序编程接口，有很多现成的类

Scanner键盘输入：

import java.util.Scanner; //导包

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

引用类型一般步骤：

1 导包
import 包路径.类名称
如果需要使用目标类，和当前类位于同一个包下，可以省略不写
只有java.lang下的包内容不需要导包，其他都需要import语句

2 创建
类名称 对象名 = new 类名称();

3 使用
对象名.成员方法名();

获取键盘输入的一个int数字：int num = sc.nextInt();
但是获取键盘输入的一个字符串为：String str = str.next();

 */

public class demo01 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);  //System.in 代表从键盘进行输入，万年不变

        int num = sc.nextInt();
        System.out.println("输入的int数字为" + num);

        String str = sc.next();
        System.out.println("输入的字符串为" + str);
    }
}

然后运行程序后在下方输入多少就打印出来多少
注意：其实sc.next就是一个字符串而加一个Int只是把你输入的数据转换为Int让程序识别

例题

/*
题目：键盘输入三个int数字，然后求出其中的最大值；

思路：
1. 使用Scanner 方法，三个步骤
2. 输入三个数字，所以调用三次next()Int 方法
3. 无法同时判断三个数谁最的，应该转换为两个步骤；
4. 先判断前两个当中谁最大，拿到两个最大值
   拿着前两个中的最大值，再和第三个数字比较，得到三个数字中的最大值
5. 打印最终结果

*/

import java.util.Scanner;

public class demo03ScannerMax {

    public static void main(String[] args) {
        Scanner scr = new Scanner(System.in);
        System.out.println("请输入第一个数字:");
        int a = scr.nextInt();
        System.out.println("请输入第二个数字:");
        int b = scr.nextInt();
        System.out.println("请输入第三个数字:");
        int c = scr.nextInt();

        int temp = a > b ? a:b ;
        int max = temp > c ? temp : c ;
        System.out.println("最大值为" + max);


    }
}

//键盘输入两个int数值，并且求出和值

import java.util.Scanner;

/*
1 既然需要键盘输入，那么就用Scanner
2 Scanner三个步骤：导包，创建，使用
3 两个数值，调用两次nextInt方法
4 得到两个数字，加在一起
5 将结果打印输出

*/
public class demo02ScannerSum {

    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 result = a + b ;
        System.out.println("输出结果为" + result);


    }


}

匿名对象

/*
创建对象的标准格式
类名称 对象名 = new 类名称（）;

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符
new 类名称();

注意事项：匿名对象只能使用唯一一次，下次使用不得不创建新的对象
使用建议：如果确定有一个对象只需要使用唯一的一次，就可以使用匿名对象

* */

public class Demo01Anonymous {

    public static void main(String[] args) {
        Person one = new Person();
        one.name = "高";
        one.showName();

        System.out.println("==============");

        //匿名对象
        new Person().name="s";
        new Person().showName(); //null值
    }
}

public class Person {

    String name;

    public void showName(){
        System.out.println("我叫" + name);
    }
}

//匿名对象作为方法的参数与返回值都可以


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 c = new Scanner(System.in);
        //methodParam(c);

    //使用匿名对象进行传参
     //   methodParam(new Scanner(System.in));

        Scanner sc = methodReturn();
        int num = sc.nextInt();
        System.out.println("输入的是" + num);
    }

    public static void methodParam(Scanner c){
        int num = c.nextInt();
        System.out.println("输入的是：" + num);
    }

    public static Scanner methodReturn(){
        // Scanner sc = new Scanner(System.in);
        // return sc;
        return new Scanner(System.in);


    }
}

Random类

import java.util.Random;

/*Random 类用来生成随机数字，使用起来也是三个步骤
1 导包
2 创建
 Random r = new Random();
3 使用
 获取一个随机的int数字(范围是int 范围所有)：int number = r.nextInt();

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

猜数小游戏：

题目：用代码模拟猜数小游戏

思路：
1 首先需要产生一个随机数字，并且不发生变化。使用Random的nextInt方法
2 需要键盘输入，Scanner
3 获取键盘输入的数字，用Scanner当中的nextInt方法
4 已经得到了两个数字，判断(if)一下：
如果太大了，提示太大了，并且重试
如果太小了，提示太小了，并且重试
如果猜中了，游戏结束
5 重试就是再来一次，循环的次数不确定，用while(true)。

* */

import java.util.Random;
import java.util.Scanner;

public class Demo04RandomGame {

    public static void main(String[] args) {
        Random ra = new Random();
        int num = ra.nextInt(100) + 1;  //[1~100]
        Scanner s = new Scanner(System.in);
        System.out.println("请输入一个数字");
        while (true){
            int a = s.nextInt();

            if(a>num){
                System.out.println("输入的数字太大");
            }else if (a<num){
                System.out.println("输入的数字太小");
            }else {
                System.out.println("正确");
                break;
            }
        }

    }

}

数组也可以存储数据，但是一旦运行，则不能改变，比较不方便
例：

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

public class Demo01Array {
    public static void main(String[] args) {
        // 首先创建一个长度为3的数组，里面用来存放Person类型对象

        Person [] array = new Person[3];

        Person one = new Person("w",18);
        Person two = new Person("R",19);
        Person three = new Person("Z",20);

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

        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);

        Person person = array[1];
        System.out.println(person.getName());
        //相同
        System.out.println(array[1].getName());  //R


    }
}

public class Person {

    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

ArrayList:
数组的长度不可以发生改变
但是ArrayList集合的长度可以发生改变
对于ArrayList来说，有一个尖括号代表泛型
泛型：也就是装在集合当中的所有元素，全部都是统一的什么类型
注意：泛型只能是引用类型，不能是基本类型

注意事项：
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容
如果内容是空，得到的是空的中括号:[]

public class DemoLList02 {

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

        //向集合当中添加一些数据，需要用到add方法

        list.add("w");
        System.out.println(list);

        list.add("L");
        list.add("q");
        list.add("e");
        list.add("t");
        System.out.println(list); //[w, L, q, e, t]
        
        //list.add(100); 错误写法，因为创建的时候说的是String类型，所有添加也要为String类型
    }

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<>();
        System.out.println(list);

        //向集合中添加元素：add
        boolean success = list.add("w");
        System.out.println(list);
        System.out.println("添加是否成功" + success); //true

        list.add("q");
        list.add("f");
        list.add("g");
        list.add("c");
        list.add("b");
        System.out.println(list);  //[w, q, f, g, c, b]

        // 从集合中获取元素，索引从0开始
        String name = list.get(2);
        System.out.println("第二号索引位置" + name);  //f

        //从集合中删除元素：remove
        String whoRemoved = list.remove(3);
        System.out.println("被删除的人是谁" + whoRemoved);  //g
        System.out.println(list); //[w, q, f, c, b]


        //获取集合的长度尺寸，也就是元素的个数
        int size = list.size();
        System.out.println(size);
    }
}

遍历集合

import java.util.ArrayList;

public class demo04ArrayListEach {

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

        list.add("w");
        list.add("z");
        list.add("b");

        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

ArrayList其他数据类型如何使用：

如果希望向集合ArrayList当中存储基本类型数据，必须使用基本对应的"包装类"

基本类型包装类(引用类型，包装类都位于java.lang包下)
byte Byte
short Short
int Integer 【特殊】
long Long
float Float
double Double
char Character 【特殊】
boolean Boolean

自动装箱：基本类型 ———》包装类型
自动拆箱：包装类型————》基本类型

例：

public class DemoArrayListBasic {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(100);
        list1.add(399);
        list1.add(400);
        System.out.println(list1);  //[100, 399, 400]

        int num = list1.get(2);
        System.out.println(num);  //400

    }
}

练习题1：

/*题目
* 生成6个1~33之间的随机整数，添加到集合，并遍历集合
*
* 思路：
 1 需要储存6个数字，创建一个集合，<Integer>
 2 产生随机数，用到Random
 3 生成6个随即数，for循环
 4 循环内调用r.nextInt(int n),参数是33, 整体+1 为1~33；
 5 把数字添加到集合中：add
 6 遍历集合：for,size,get
 */

import java.util.ArrayList;
import java.util.Random;

public class ArrayListRandom {
    public static void main(String[] args) {
        Random r = new Random();
        ArrayList<Integer> list = new ArrayList<>();

        for (int i = 0; i < 6; i++) {
            int num = r.nextInt(33) +1; //bound就是[0~33)
            list.add(num);
        }
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));

        }


    }
}

练习题2：

注意：要先创建一个学生类，最后输出的时候一定要getXXX,因为传递的都是地址值，如果直接输出的话都是地址。

// 题目：自定义四个学生对象，添加到集合，并遍历

/*思路：
1 自定义Student类
2 创建一个集合，用来存储学生对象。泛型：<Student>
3 根据类，创建四个学生对象
4 将4个学生对象添加到集合当中：add;
5 遍历集合：for,size,get
*/

import java.util.ArrayList;

public class Demo02ArrayListStudent {
    public static void main(String[] args) {
        ArrayList<Student>list = new ArrayList<>();

        Student one = new Student("w",18);
        Student two = new Student("R",19);
        Student three = new Student("Z",20);
        Student Four = new Student("L",21);

        list.add(one);
        list.add(two);
        list.add(three);
        list.add(Four);

        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName() + s.getAge());
        }

    }

}

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 int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

例三：集合也可以成为方法的参数

定义以指定格式打印集合的方法（ArrayList类型作为参数），使用{}扩起集合，使用@分隔每个元素
格式参照{元素@元素@元素}
System.out.println(list); [10,20,30]
printArrayList(list); {10@20@30}

import java.util.ArrayList;

public class Demo02ArrayListPrint {

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

        list.add("w");
        list.add("L");
        list.add("Z");
        System.out.println(list);
        ArrayListMethod(list);

    }

    //方法三要素
    //返回值类型：打印，不用返回结果，所有用void
    //方法名ArrayListMethod
    //参数列表：ArrayList

    public static void ArrayListMethod (ArrayList<String> list){

        System.out.print("{");


        for (int i=0; i<list.size();i++){

            String name = list.get(i);
            if(i==list.size() -1){
                System.out.println(name +"}");
            }else {
                System.out.print(name + "@");
            }

        }





    }


}

例5：

/*
* 题目：
* 用一个大集合存入20个随机数，然后筛选其中的偶数元素，放到小集合当中
* 要求使用自定义的方法来实现筛选

*分析：
* 1 需要创建集合，用来存储int 数字：<Integer>
  2 随机数字就用Random nextInt
  3 循环20次，把随机数字放入集合：for循环，add方法
  4 定义一个方法，用来进行筛选
  筛选：根据大集合，筛选符合要求的元素，得到小集合。
  * 三要素
  * 返回值类型：Integer
  * 方法名称:SmallMethod
  * 参数列表：ArrayList<Integer>
  5 判断是否为偶数
  6 如果为偶数就放到小集合当中，否则就不放
*/

import java.util.ArrayList;
import java.util.Random;

public class Demo04ArrayListReturn {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 20; i++) {
            int num = r.nextInt(100)+ 1;
            list.add(num);

        }

        //数据类型 变量名称 = 方法名称(参数);
        ArrayList<Integer> smallList = SmallMethod(list);
        for (int i = 0; i < smallList.size(); i++) {
            System.out.println(smallList.get(i));
        }

    }
    /* 三要素
   返回值类型：Integer
   方法名称:SmallMethod
   参数列表：ArrayList<Integer>
     */
public  static ArrayList<Integer> SmallMethod(ArrayList<Integer> list){
    //创建一个小集合用来装筛选出来的数
    ArrayList<Integer> smallList = new ArrayList<>();
    for (int i = 0; i < list.size(); i++) {
        int num = list.get(i);
        if(num % 2 == 0){
            smallList.add(num);

        }
    }
    return smallList;

}

}