Scanner类 、Random类、ArrayList类、String类

API概述

​ API(Application Programming Interface) 应用程序编程接口。Java API对于程序员来说就是一本可以检索查找的【字典】,是JDK官方提供给程序开发者使用类的说明文档。这些类将底层的代码封装起来,我们不需要关注这些类底层是如何实现的,我们只需要知道这些类是如何使用的。平常开发使用JDK类库的时候,通过查阅API的方式进行的。

API的使用步骤

1.打开帮助文档

2.点击显示,找到索引,找到输入框

3.在输入框中输入你要查找的类,然后回车

4.看该类的所在包,对于java.lang包下面的类不需要导包

5.看该类的解释说明和类结构

6.学习该类的构造方法和成员方法

Scanner类

什么是scanner类

一个可以使用正则表达式来解析基本数据类型和字符串类型的简单文本扫描器

例如:系统扫描用户输入的int类型的值

Scanner sc = new Scanner(System.in);
int num = sc.nextInt;

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

引用类型使用步骤

导包

使用import关键字导包,在类的所有代码之前导包,引入要引入的类型,java.lang包下的所有类不需要导入。

导入的格式:

import 包名.类名

如: import java.util.Scanner;

创建对象

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

调用方法

变量名.方法名();

Scanner类的使用步骤

查看类

java.util.Scanner 需要导入java.util包

查看构造方法

public Scanner(InputStream sourse):构造一个新的Scanner对象,它生成的值是从指定的输入流中扫描的

查看成员方法

public int nextInt():将输入的信息的下一个标记扫描为一个int类型值

匿名对象【了解】

概念

匿名对象:没有变量名的对象

格式:

数据类型 变量名 = new 数据类型(参数列表);// 有名对象
new 数据类型(参数列表);

举例

public class AnonymousDemo{
    public static void main(String[] args){
        // 传统的写法
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        // 匿名对象的方式
        int num02 = new(System.in).nextInt();
        //int num03 = new(System.in).nextInt();
        System.out.println(num02);
        // 开发中 使用匿名对象进行参数的传递   
        checkInput(new Scanner(System.in));
        // 获取一个Scanner类对象
        Scanner sc02 = getScanner();
    }
    public static void checkInput(Scanner sc){
        int num = sc.nextInt();
        System.out.println(num);
    }
    public static Scanner getScanner(){
        return new Scanner(System.in);
    }
}

备注:匿名对象只能使用唯一的一次,下次再使用再次创建

使用建议:如果在程序当中你确定有一个对象只会使用唯一的一次,建议使用匿名对象。

Random类

什么是Random类

​ 此类的实例主要是用于生成伪随机数

​ 例如:使用户得到一个随机整数:

Random ran = new Random();
int i = ran.nextInt();// int的取值范围

Random类的使用步骤

查看类

java util Random 该类需要导入后才能使用

查看构造方法

public Random():创建一个新的随机数生成器

查看成员方法

public int nextInt(int n): 返回一个伪随机数,范围在[0,n-1]。

public double nextDouble():返回一个伪随机小数,范围在[0.0,1.0）。

练习:使用Random类,随机生成10个10以内的随机整数

//1.导包
import java.util.Random;
public class RandomDemo{
    public static void main(String[] args){
        // 2.构建Random类对象
        Random ran = new Random();
        // 3.调用类中的方法 nextInt(int n)
        for (int i = 0; i < 10 ; i++) {
            System.out.println(random.nextInt(10));
        }
    }
}

 // 获取1-n之间的随机数,包含n
   import java.util.Random;
   public class RandomDemo{
      public static void main(String[] args){
       //构建一个n
       int n = 50;
       Random ran = new Random();
      //调用方法
       int num = ran.nextInt(n)+1;
       System.out.println(num);
   }
   }

ArrayList类

引入—对象数组

// 需求：把三个People类型的对象存入到容器当中。数组
public static void main(String[] args) {
    // 创建对象数组
    People[] arr = new People[3];
    // 创建3个people对象
    People p1 = new People("小明",20);
    People p2 = new People("小花",18);
    People p3 = new People("小刘",22);
    
    arr[0] = p1;
    arr[1] = p2;
    arr[2] = p3;
    // 使用循环
    //for (int i = 0; i < 3 ; i++) {
        //arr[i] = new People("小明",20);
    //}
    // 遍历学生数组  展示对象中的成员变量信息  name age
    for (int i = 0 ; i <= arr.length-1; i++) {
        People p = arr[i];
        System.out.println(p.getName() +","+p.getAge())
    } 
} 

备注：对象数组，长度是固定的，如果在程序中需要对象进行增加或者删除等数量操作时，非常不方便。

​ Java又提供了一个容器 java.util.ArrayList集合类。这个类可以让我们的存储和操作对象更方便。

什么ArrayList类

​ java.util.ArrayList类是一个【大小可变的数组】的实现，里面存储的数据称为元素。该类提供了一些常用的api方法来操作内部存储的元素。

ArrayList类的使用步骤

• ​ 查看类

  ​ java.util.ArrayList：该类也是需要import导入后才能使用

  ,表示一种指定的数据类型，叫做【泛型】。E，取自Element(元素)的首字母。在程序中遇到【E】的地方，我们需要使用一种【引用的数据类型】将其替换掉即可，表示我们将存储哪种数据类型的元素。

  例如：

  ArrayList<People> peoples;
  ArrayList<String> strs;
  ArrayList<int> nums; // 不正确的写法     
  

• 查看构造方法

  public ArrayList(): 构造一个初始容量为10的空列表

  public ArrayList(int initialcapacity) 构造一个指定初始容器的空列表

​ 基本格式：

   ArrayList<引用数据类型> 变量名 = new ArrayList<引用数据类型>();
   // 在JDK1.7之后，右侧的泛型尖括号里面的数据类型可以选择省略不写，但是<>要保留。

• 查看成员方法

  public boolean add(E e)：将指定的元素添加到此列表的【尾部】。

  public void add(int index, E element)：将指定的元素插入此列表中的指定位置。

  public void clear()： 移除此列表中的所有元素。

  public boolean contains(Object o)：判断此列表是否包含指定的元素，如果包含返回true，否则返回false。

  public E get(int index)： 返回指定位置的元素。

  public int indexOf(Object o)： 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。

  public boolean isEmpty()： 如果此列表中没有元素，则返回 true

  public E remove(int index)： 移除指定位置的元素，并把移除的元素返回

  public E set(int index,E e)：用指定的元素替代此列表中指定位置上的元素。

  public int size()：返回此列表中的元素个数。

     遍历  【重点】
  

​ 使用for循环，定义的循环变量就是ArrayList容器中的索引，循环的次数就是容器的元素个数size()

// 需求：往ArrayList容器当中存入5个学生对象，遍历容器查找小丽的这位同学，如果查到就把小丽的信息输出后，把小丽学生删除。
//      学生对象包含姓名、年龄、学号。

如何存储基本数据类型值

​ ArrayList类对象不能存储基本类型，只能存储引用类型的数据，类似不支持的，但是Java中提供了基本数据类型对应的包装类型，包装类型是可以在ArrayList容器中指定，所以我们如果想要存储基本数据类型值，首先需要把基本数据类型转换成包装类型。

基本类型	基本类型包装类
byte	Byte
short	Short
int	Integer [重点]
long	Long
float	Float
double	Double
char	Character 【重点】
boolean	Boolean

备注：我们需要对int和char进行特殊记忆，其他类型只需要记住首字母大写即可。

练习：存储基本数据类型值

// 需求1：存入5个人的考试成绩到ArrayList容器中，如果成绩低于60，就额外奖励你4000行代码抄写。
 ArrayList<Integer> scores = new ArrayList<>();
        scores.add(95);
        scores.add(91);
        scores.add(99);
        scores.add(94);
        scores.add(50);
        for (int i = 0; i < scores.size() ; i++) {
            if (scores.get(i) < 60){
                System.out.println(scores.get(i)+"   4000行代码");
            }
        }
// 需求2：存入5个人的身高到ArrayList容器中，如果有身高大于1.80，就踢出去。
 ArrayList<Double> heights = new ArrayList<>();
        heights.add(158.1);
        heights.add(180.2);
        heights.add(175.2);
        heights.add(165.0);
        heights.add(158.9);
        heights.add(175.5);
        for (int i = 0; i < heights.size() ; i++) {
            if (heights.get(i) > 180.0){
                heights.remove(i);
            }
        }
// 需求3：生成10个1~10之间的随机数，添加到ArrayList集合中
    ArrayList<Integer> nums = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 10 ; i++) {
            int a = (random.nextInt(10)+1);
            nums.add(a);
        }
// 需求4：用一个大集合存入30个随机数字[1,100]，然后筛选其中的偶数元素，放到小集合中，要求使用自定义方法进行筛选元素,最后展示小集合中偶数元素，并且打出偶数元素的个数。
public class ArrayListDemo02 {
    public static void main(String[] args) {
        // 2.构建大集合ArrayList
        ArrayList<Integer> bigList = new ArrayList<>();
        // 构建Random类对象
        Random random = new Random();
        // 3.使用循环随机30个整数 [1,100]
        for (int i = 0; i < 30; i++) {
            int num = random.nextInt(100) + 1;
            // 存入bigList集合中
            bigList.add(num);
        }
        // 获取小集合 里面存储的是偶数元素
        ArrayList<Integer> smallList = getEvenNumbers(bigList);

        // 打印输出小集合中的偶数元素和个数
        System.out.println("小集合中的偶数元素个数为：" + smallList.size());
        for (int i = 0; i < smallList.size(); i++) {
            System.out.println(smallList.get(i));
        }
    }

    // 筛选偶数方法
    public static ArrayList<Integer> getEvenNumbers(ArrayList<Integer> bigList) {
        // 创建一个小集合
        ArrayList<Integer> smallList = new ArrayList<>();
        // 筛选偶数元素  遍历集合
        for (int i = 0; i < bigList.size(); i++) { // i 代表索引
            // 取出偶数元素
            if (bigList.get(i) % 2 == 0) {
                // 偶数存入小集合中
                smallList.add(bigList.get(i));
            }
        }
        return smallList;
    }

需求：定义使用指定格式方法打印输出集合当中的元素，要求使用ArrayList作为参数，使用{}包含集合中的元素，使用–作为元素的分隔符，格式参照{元素1–元素2–元素3–…元素n}。

public class T3 {
    public static void main(String[] args) {
        ArrayList<Integer> nums = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            int a = random.nextInt(10);
            nums.add(a);
        }

        replace(nums);
    }

    public static void replace(ArrayList<Integer> nums){
        String str = "{";
        for (int i = 0; i < nums.size(); i++) {
            if (i == 0){
                System.out.print(str + nums.get(i)+"--");
            }else if (i >= 1 && i < nums.size()-1){
                System.out.print(nums.get(i)+"--");
            }else{
                System.out.print(nums.get(i)+"}");
            }
        }
    }

}

String类 【重点】

#####     String类的概述

  ###### 		概述

​ java.lang.String 类代表字符串，Java程序中的所有的字符串文字，如"abc"都可以看做是String类的实例。

​ 程序当中的所有双引号字符串，都是String类的对象。(没有new，也是对象)。

######       字符串的特点：

• ​ 字符串的内容永远不可改变。【重点】

• ​ 正是因为字符串的内容永远不可改变，所以字符串是可以共享使用的。

• ​ 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

  // 第二点
  String str1 = "abc";
  String str2 = "abc";
  // 内存当中"abc","abc"对象会被创建出来，而且"abc"对象只会被创建一次，内存当中只有一个"abc"对象被创建，
  // 此时str1和str2可以共享同一个"abc"对象
  String str3 = new String("abc");
  String str4 = new String("abc");
  

  备注：JDK1.7之后的JVM将【运行时常量池】从方法区去移除了，在Java 堆(heap)中开辟空间用来存储运行时常量池。JDK1.8开始，取消了Java方法区(method area)，取而代之的是元空间(metaspace)，JDK1.8中字符串常量池和运行时常量池逻辑上属于方法区，实际上存储在堆内存当中。