常用API_1

API

API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的 字典 ，是JDK中提供给 我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学 习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。

Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。 例如，以下代码使用户能够从 System.in 中读取一个数：

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

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

Scanner使用步骤：

查看类

• java.util.Scanner ：该类需要import导入后使用。

查看构造方法

• public Scanner(InputStream source) : 构造一个新的Scanner，它生成的值是从指定的输入流扫描的。

查看成员方法

• public int nextInt() ：将输入信息的下一个标记扫描为一个int值。

匿名对象

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

匿名对象 ：没有变量名的对象。

格式：

new 类名(参数列表);

举例：

new Scanner(System.in);

应用场景

1. 创建匿名对象直接调用方法，没有变量名。

    new Scanner(System.in).nextInt();  

2. 一旦调用两次方法，就是创建了两个对象，造成浪费，请看如下代码。

    new Scanner(System.in).nextInt(); 
    new Scanner(System.in).nextInt(); 

   小贴士：一个匿名对象只能使用一次

3. 匿名对象可以作为方法的参数和返回值

• 作为参数：

    class Test{
        public static void main(String[] args) {
            //普通方式
            Scanner sc = new Scanner(System.in);
            input(sc);
  
            //匿名对象作为方法接受的参数
            input(new Scanner(System.in));
        }
  
        public static void input(Scanner sc) {
            System.out.println(sc);
        }
    }

• 作为返回值

    class Test2 {
        public static void main(String[] args) {
            //普通方式
            Scanner sc = getScanner();
        }
  
        public static Scanner getScanner() {
            //普通方式
            //Scanner sc = new Scanner(System.in);
            //return sc;
  
            //匿名对象作为方法返回值
            return new Scanner(System.in);
        }
  
    }

Random类

此类的实例用于生成伪随机数。
例如，以下代码使用户能够得到一个随机数：

Random r = new Random();
int i = r.nextInt();

Random使用步骤

查看类

• java.util.Random ：该类需要import导入后使用。

查看构造方法

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

查看成员方法

• public int nextInt(int n) ：返回一个伪随机数，范围在 0 （包括）和 指定值 n （不包括）之间的 int 值。

ArrayList类

java.util.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。 ArrayList中可不断添加元素，其大小也自动增长。

ArrayList使用步骤

查看类

• java.util.ArrayList  ：该类需要 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) 方法中，只能添加什么数据类型的对象。

常用方法和遍历

对于元素的操作,基本体现在——增、删、查。常用的方法有：

• public boolean add(E e) ：将指定的元素添加到此集合的尾部。
• public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
  
• public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
• public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

这些都是最基本的方法，操作非常简单，代码如下：

public static void main(String[] args) {
    //创建集合对象
    ArrayList<String> list = new ArrayList<>();

    //添加元素
    list.add("hello");
    list.add("world");
    list.add("java");

    //遍历输出 public E get(int index):返回指定索引处的元素
    for(int i = 0; i < list.size(); i++){
        System.out.println(list.get(i));
    }

    //public int size():返回集合中的元素的个数
    System.out.println("size:"+list.size());

    //public E remove(int index):删除指定索引处的元素，返回被删除的元素
    System.out.println("remove:"+list.remove(0));
}

如何存储基本数据类型

ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似 <int> 不能写，但是存储基本数据类型对应的 包装类型是可以的。所以，想要存储基本类型数据， <> 中的数据类型，必须转换后才能编写，转换写法如下：

基本类型	基本类型包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

String类

概述

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 "abc" ）都可以被看作是实现此类的实 例。
类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。

特点

1. 字符串不变：字符串的值在创建后不能被更改。

    String s1 = "abc";
    s1 += "d";
    System.out.println(s1); //"abcd"
    // 内存中有"abc", "abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

2. 因为String对象是不可变的，所以它们可以被共享。

    String s1 = "abc";
    String s2 = "abc";
    // 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

3. "abc" 等效于 char[] data={ 'a' , 'b' , 'c' } 。

    例如：
    String str = "abc";
   
    相当于：
    char data[] = {'a', 'b', 'c'};
    String str = new String(data);
    // String底层是靠字符数组实现的。

使用步骤

• 查看类
  • java.lang.String ： 此类不需要导入。
• 查看构造方法
  • public String() ：初始化新创建的 String对象，以使其表示空字符序列。
  • public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
  • public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。

构造举例，代码如下：

// 无参构造
String str = new String();

// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);

// 通过字节数组构造
byte bytes[] = {97, 98, 99};
String str3 = new String(bytes);

常用方法

判断功能的方法

• public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
• public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。

方法演示，代码如下：

public static void main(String[] args) {
    //创建字符串对象
    String s1 = "hello";
    String s2 = "hello";
    String s3 = "Hello";
    
    // boolean equals(Object obj):比较字符串的内容是否相同
    System.out.println(s1.equals(s2)); // true
    System.out.println(s1.equals(s3)); // false

    System.out.println(s1.equalsIgnoreCase(s2)); // true
    System.out.println(s1.equalsIgnoreCase(s3)); // true
}

Object 是” 对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中。

获取功能的方法

• public int length () ：返回此字符串的长度。
• public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
• public char charAt (int index) ：返回指定索引处的 char值。
• public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
• public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
• public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到 endIndex截取字符串。含beginIndex，不含endIndex。

方法演示代码如下：

public static void main(String[] args) {
    //创建字符串对象
    String s = "hello world";

    // int length(): 获取字符串的长度，也就是字符个数
    System.out.println(s.length()); // 11

    // String concat(String str): 将指定的字符串连接到该字符串的末尾
    String s1 = s.concat(", hello java");
    System.out.println(s1); // hello world, hello java

    // char charAt(int index): 获取指定索引处的字符
    System.out.println(s.charAt(0)); // h

    // int indexOf(String str): 获取str在字符串对象中第一次出现的索引，没有返回-1
    System.out.println(s.indexOf("l")); // 2
    System.out.println(s.indexOf("world")); // 6
    System.out.println(s.indexOf("??")); // -1

    // String substring(int start): 从start开始截取字符串到字符串结尾
    System.out.println(s.substring(0)); // hello world
    System.out.println(s.substring(5)); //  world

    // String substring(int start, int end): 从start到end截取字符串，含start，不含end。
    System.out.println(s.substring(0, s.length())); // hello world
    System.out.println(s.substring(3,8)); //lo wo
}

转换功能的方法

• public char[] toCharArray () ：将此字符串转换为新的字符数组。
• public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
• public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使 用replacement字符串替换。

方法演示代码如下：

public static void main(String[] args) {
    //创建字符串对象
    String s = "abcde";

    // char[] toCharArray(): 把字符串转换为字符数组
    char[] chs = s.toCharArray();
    for (int i = 0; i < chs.length; i++){
        System.out.println(chs[i]); // a b c d e
    }

    // byte[] getBytes(): 把字符串转换为字节数组
    byte[] bytes = s.getBytes();
    for (int i = 0;i < bytes.length; i++){
        System.out.println(bytes[i]); // 97 98 99 100 101
    }

    // 替换字母Hello为Hi
    String str = "Hello World";
    String replace = str.replace("Hello","Hi");
    System.out.println(replace); // Hi World
}

CharSequence 是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

分割功能的方法

• public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

方法演示代码如下：

public static void main(String[] args) {
    //创建字符串对象
    String s = "aa|bb|cc";
    String[] strArray = s.split("|"); // ["aa","bb","cc"]
    for (int i = 0;i < strArray.length; i++){
        System.out.println(strArray[i]); // aa bb cc
    }
}

static关键字

概述

关于 static 关键字的使用，它可以用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

定义和使用格式

类变量

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改 该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

• 类变量: 使用 static关键字修饰的成员变量。

定义格式：

static 数据类型 变量名;

举例：

static int numberID;

比如说，一个班级开班，学生报道，现在想为每一位新来报到的同学编学号（sid），从第一名同学开始，sid为 1，以此类推。学号必须是唯一的，连续的，并且与班级的人数相符，这样以便知道，要分配给下一名新同学的学号是多少。这样我们就需要一个变量，与单独的每一个学生对象无关，而是与整个班级同学数量有关。

所以我们可以定义一个静态变量numberOfStudent，代码如下：

public class Student {
    private String name;
    private int age;
    // 学生的学号
    private int sid;
    // 类变量，记录学生数量，分配学号
    public static int numberOfStudent = 0;

    public Student(String name, int age){
        this.name = name;
        this.age = age;
        // 通过numberOfStudent给学生分配学号
        this.sid = ++numberOfStudent;
    }

    public void show(){
        System.out.println("Student : name = "+name+", age = "+age+", sid = "+sid);
    }
}

public class StuDemo {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);
        s1.show();  //Student : name = 张三, age = 23, sid = 1
        s2.show();  //Student : name = 李四, age = 24, sid = 2
        s3.show();  //Student : name = 王五, age = 25, sid = 3
    }
}

静态方法

当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要 创建类的对象。调用方式非常简单。

• 类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

定义格式：

修饰符 static 返回值类型 方法名 (参数列表){
    // 执行语句
}

举例：在Student类中定义静态方法

public static void showNum(){
    System.out.println("num: "+ numberOfStudent);
}

• 静态方法调用的注意事项：
  • 静态方法可以直接访问类变量和静态方法。
  • 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
  • 静态方法中，不能使用this关键字。

小贴士：静态方法只能访问静态成员。

调用格式

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

格式：

//访问类变量
类名.类变量名;
//调用静态方法
类名.静态方法名(参数);

静态原理图解

static修饰的内容：

• 是随着类的加载而加载的，且只加载一次。
• 存储于一块固定的内存区域（静态区），所以可以直接被类名调用。
• 它优先于对象存在，所以可以被所有对象共享。

静态代码块

• 静态代码：：定义在成员位置，使用static修饰的代码块{ }。
  • 位置：类中方法外。
  • 执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

格式：

public class ClassName{
    static {
        // 执行语句
    }
}

作用：给类变量进行初始化赋值。用法演示代码如下：

public class Person {
    public static int number;
    public static ArrayList<String> list;

    static {
        // 给类变量赋值
        number = 2;
        list = new ArrayList<String>();
        // 添加元素到集合中         
        list.add("张三");
        list.add("李四");
    }
}

小贴士：
static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况下，去调用方法。下面将介绍两个工具类，来体现static方法的便利。

Arrays类

概述

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

操作数组的方法

• public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。

    public static void main(String[] args) {
        int[] arr = {2,3,4,55};
        //打印数组，输出地址值
        System.out.println(arr); // [I@50cbc42f
        //数组内容转为字符串
        String s = Arrays.toString(arr);
        //打印字符串，输出内容
        System.out.println(s); //[2, 3, 4, 55]
    }

• public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。

    public static void main(String[] args) {
        int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
        System.out.println("排序前："+ Arrays.toString(arr)); //排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6,  2]
        //升序排序
        Arrays.sort(arr);
        System.out.println("排序后："+ Arrays.toString(arr)); //排序后：[2, 4, 5, 6, 7, 11, 24, 35, 46, 48]
    }

练习

将一个随机字符串中的所有字符升序排序，并倒序打印

public static void main(String[] args) {
    // 定义随机的字符串
    String line = "ysKUreaytWTRHsgFdSAoidq";
    // 转换为字符数组
    char[] chars = line.toCharArray();
    // 升序排序
    Arrays.sort(chars);
    // 反向遍历打印
    for (int i = chars.length-1; i >= 0; i--) {
        System.out.print(chars[i] + " "); // y y t s s r q o i g e d d a W U T S R K H F A 
    }
}

Math类

概述

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

基本运算的方法

• public static double abs(double a) ：返回 double 值的绝对值。
• public static double ceil(double a) ：返回大于等于参数的小的整数。
• public static double floor(double a) ：返回小于等于参数大的整数。
• public static long round(double a) ：返回接近参数的 long。(相当于四舍五入方法)