常用API

java.util.Scanner

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

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

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

常用的System.in代表从键盘进行输入

• 获取键盘输入的一个int数字：

int num = sc.nextInt();
复制

• 获取键盘输入的一个字符串：

String str = sc.next();
复制

例如：

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);
    }

}
复制

import java.util.Random;

Random类用来生成随机数字。

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

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

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

如何使用：

获取一个随机的int数字（范围是int所有范围，有正负两种）：

int num = r.nextInt();
复制

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

int num = r.nextInt(3);
实际上代表的含义是：[0,3)，也就是0~2
复制

使用技巧：

// 本来范围是[0,n)，整体+1之后变成了[1,n+1)，也就是我们要的[1,n]
int result = r.nextInt(n) + 1;
复制

java.util.ArrayList<E> 是大小可变的数组的实现

数组的长度不可以发生改变。但是ArrayList集合的长度是可以随意变化的。

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

//构造一个内容为空的集合。
public ArrayList() 
复制

向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。

public boolean add(E e)
备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。
但是对于其他集合（今后学习）来说，add添加动作不一定成功。
复制

从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。

public E get(int index)
复制

从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。

public E remove(int index)
复制

获取集合的尺寸长度，返回值是集合中包含的元素个数。

public int size()
复制

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

java.lang.String类代表字符串。API当中说：Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。其实就是说：程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是。）

• 类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻 译为大写或小写的所有字符的字符串的副本。

• 字符串的特点：

  1. 字符串的内容永不可变。【重点】
  2. 正是因为字符串不可改变，所以字符串是可以共享使用的。
  3. 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

创建字符串的常见3+1种方式。
三种构造方法：

public String()：创建一个空白字符串，不含有任何内容。
public String(char[] array)：根据字符数组的内容，来创建对应的字符串。
public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。
复制

一种直接创建：

String str = "Hello"; // 右边直接用双引号
注意：直接写上双引号，就是字符串对象。
复制

例如：

public class Demo01String {

    public static void main(String[] args) {
        // 使用空参构造
        String str1 = new String(); // 小括号留空，说明字符串什么内容都没有。
        System.out.println("第1个字符串：" + str1);

        // 根据字符数组创建字符串
        char[] charArray = { 'A', 'B', 'C' };
        String str2 = new String(charArray);
        System.out.println("第2个字符串：" + str2);

        // 根据字节数组创建字符串
        byte[] byteArray = { 97, 98, 99 };
        String str3 = new String(byteArray);
        System.out.println("第3个字符串：" + str3);

        // 直接创建
        String str4 = "Hello";
        System.out.println("第4个字符串：" + str4);
    }

}
/*
输出：
第1个字符串：
第2个字符串：ABC
第3个字符串：abc
第4个字符串：Hello*/
复制

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：

（1）完全比较：

public boolean equals(Object obj)
//参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。
复制

注意事项：

1. 任何对象都能用Object进行接收。
2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3. 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
   推荐："abc".equals(str) 不推荐：str.equals("abc")【反防止空指针出现】

（2）忽略大小写，进行内容比较：

public boolean equalsIgnoreCase(String str)
//忽略大小写，进行内容比较。
复制

• String当中与获取相关的常用方法有：

//获取字符串当中含有的字符个数，拿到字符串长度
public int length()
//将当前字符串和参数字符串拼接成为返回值新的字符串。
public String concat(String str)
//获取指定索引位置的单个字符。（索引从0开始。）
public char charAt(int index)
//查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。
public int indexOf(String str)
复制

• 字符串的截取方法：

//截取从参数位置一直到字符串末尾，返回新字符串。
public String substring(int index)
//截取从begin开始，一直到end结束，中间的字符串。
public String substring(int begin, int end)//[begin,end)，包含左边，不包含右边。
复制

• String当中与转换相关的常用方法有：

public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获得当前字符串底层的字节数组。
public String replace(CharSequence oldString, CharSequence newString)：
将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
备注：CharSequence意思就是说可以接受字符串类型。
复制

• 分割字符串的方法：

public String[] split(String regex)：按照参数的规则，将字符串切分成为若干部分。
复制

注意事项：
split方法的参数其实是一个“正则表达式”，今后学习。
今天要注意：如果按照英文句点“.”进行切分，必须写"\."（两个反斜杠）

例如：

public class Demo05StringSplit {

    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
        System.out.println("===============");

        String str2 = "aaa bbb ccc";
        String[] array2 = str2.split(" ");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
        System.out.println("===============");

        String str3 = "XXX.YYY.ZZZ";
        String[] array3 = str3.split("\\.");
        System.out.println(array3.length); // 0
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }
    }

}
复制

• 字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。

• 对于基本类型来说，==是进行数值的比较。

  对于引用类型来说，==是进行【地址值】的比较。

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

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。

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

定义学生类：
public class Student {
    private String name;
    private int age;
    // 学生的id
    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);
        Student s4 = new Student("赵六", 26);
        s1.show(); // Student : name=张三, age=23, sid=1
        s2.show(); // Student : name=李四, age=24, sid=2
        s3.show(); // Student : name=王五, age=25, sid=3
        s4.show(); // Student : name=赵六, age=26, sid=4
    }
}
复制

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

• 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
  如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

• 无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
  静态变量：类名称.静态变量
  静态方法：类名称.静态方法()

  对于本类当中的静态方法，可以省略类名称【完全等效类名称.静态方法()】

• 注意事项：

  1. 静态不能直接访问非静态。
     原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
     “先人不知道后人，但是后人知道先人。”
  2. 静态方法当中不能用this。
     原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

类：
public class MyClass {

    int num; // 成员变量
    static int numStatic; // 静态变量

    // 成员方法
    public void method() {
        System.out.println("这是一个成员方法。");
        // 成员方法可以访问成员变量
        System.out.println(num);
        // 成员方法可以访问静态变量
        System.out.println(numStatic);
    }

    // 静态方法
    public static void methodStatic() {
        System.out.println("这是一个静态方法。");
        // 静态方法可以访问静态变量
        System.out.println(numStatic);
        // 静态不能直接访问非静态【重点】
//        System.out.println(num); // 错误写法！

        // 静态方法中不能使用this关键字。
//        System.out.println(this); // 错误写法！
    }

}

测试类：
public class Demo02StaticMethod {

    public static void main(String[] args) {
        MyClass obj = new MyClass(); // 首先创建对象
        // 然后才能使用没有static关键字的内容
        obj.method();

        // 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
        obj.methodStatic(); // 正确，不推荐，这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
        MyClass.methodStatic(); // 正确，推荐

        // 对于本类当中的静态方法，可以省略类名称
        myMethod();
        Demo02StaticMethod.myMethod(); // 完全等效
    }

    public static void myMethod() {
        System.out.println("自己的方法！");
    }

}
复制

格式：

public class 类名称 {
    static {
        // 静态代码块的内容
    }
}
复制

特点：当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途：
用来一次性地对静态成员变量进行赋值。

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

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3...]）
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。

备注：
1. 如果是数值，sort默认按照升序从小到大
2. 如果是字符串，sort默认按照字母升序
3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学习）
 */
public class Demo01Arrays {

    public static void main(String[] args) {
        int[] intArray = {10, 20, 30};
        // 将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr); // [10, 20, 30]

        int[] array1 = {2, 1, 3, 10, 6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]

        String[] array2 = {"bbb", "aaa", "ccc"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]
    }

}

复制

• 将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3...]）

public static String toString(数组)
复制

• 按照默认升序（从小到大）对数组的元素进行排序。

public static void sort(数组)
复制

备注：

1. 如果是数值，sort默认按照升序从小到大
2. 如果是字符串，sort默认按照字母升序
3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学习）

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

获取绝对值。有多种重载。

public static double abs(double num)
复制

向上取整:

public static double ceil(double num)
复制

向下取整:

public static double floor(double num)
复制

四舍五入:

public static long round(double num)
复制

Math.PI代表近似的圆周率常量（double）

java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类，那么默认则继承自Object类。

返回该对象的字符串表示。

public String toString()
    其实该字符串内容就是对象的类型+@+内存地址值。
复制

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

覆盖重写

如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：

public class Person {  
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

    // 省略构造器与GetterSetter
}
复制

小贴士： 在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。

指示其他某个对象是否与此对象“相等”。

public boolean equals(Object obj)
复制

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

• 默认地址比较

如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。

• 对象内容比较

如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。例如：

import java.util.Objects;

public class Person {	
	private String name;
	private int age;
	
    @Override
    public boolean equals(Object o) {
        // 如果对象地址一样，则认为相同
        if (this == o)
            return true;
        // 如果参数为空，或者类型信息不一样，则认为不同
        if (o == null || getClass() != o.getClass())
            return false;
        // 转换为当前类型
        Person person = (Person) o;
        // 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
        return age == person.age && Objects.equals(name, person.name);
    }
}
复制

这段代码充分考虑了对象为空、类型一致等问题，但方法内容并不唯一。大多数IDE都可以自动生成equals方法的代码内容。在IntelliJ IDEA中，可以使用Code菜单中的Generate…选项，也可以使用快捷键alt+insert，并选择equals() and hashCode()进行自动代码生成。如下图所示：

tips：Object类当中的hashCode等其他方法，今后学习。

在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

public static boolean equals(Object a, Object b):判断两个对象是否相等。
复制

我们可以查看一下源码，学习一下：

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}
复制

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

• 格式化：按照指定的格式，从Date对象转换为String对象。
• 解析：按照指定的格式，从String对象转换为Date对象。

实际上，currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

import java.util.Date;

public class SystemDemo {
    public static void main(String[] args) {
       	//获取当前时间毫秒值
        System.out.println(System.currentTimeMillis()); // 1516090531144
    }
}
复制

验证for循环打印数字1-9999所需要使用的时间（毫秒）

public class SystemTest1 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时毫秒：" + (end - start));
    }
}
复制

• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：

将src数组中前3个元素，复制到dest数组的前3个位置上
复制元素前：
src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]
复制元素后：
src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]

import java.util.Arrays;

public class Demo11SystemArrayCopy {
    public static void main(String[] args) {
        int[] src = new int[]{1,2,3,4,5};
        int[] dest = new int[]{6,7,8,9,10};
        System.arraycopy( src, 0, dest, 0, 3);
        /*代码运行后：两个数组中的元素发生了变化
         src数组元素[1,2,3,4,5]
         dest数组元素[1,2,3,9,10]
        */
    }
}
复制

java.lang.StringBuilder类:字符串缓冲区,可以提高字符串的效率

StringBuilder() 构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。   StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
复制

StringBuilder常用的方法有2个：

• public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
• public String toString()：将当前StringBuilder对象转换为String对象。

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

• 装箱：从基本类型转换为对应的包装类对象。

• 拆箱：从包装类对象转换为对应的基本类型。

用Integer与 int为例：（看懂代码即可）

基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法
复制

包装对象---->基本数值

int num = i.intValue();
复制

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。
复制

完全可以把包装类当作对应的基本数据类型来使用

• 基本类型->字符串(String)
  1.基本类型的值+"" 最简单的方法(工作中常用)
  2.包装类的静态方法toString(参数),不是Object类的toString() 重载：static String toString(int i) 返回一个表示指定整数的 String 对象。
  3.String类的静态方法valueOf(参数)：static String valueOf(int i) 返回 int 参数的字符串表示形式。
• 字符串(String)->基本类型
  使用包装类的静态方法parseXXX("字符串");
  Integer类: static int parseInt(String s)
  Double类: static double parseDouble(String s)

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

• public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
• public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
• public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
• public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
• public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
• public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
• public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

例如：

public class Demo03Integer {
    public static void main(String[] args) {
        //基本类型->字符串(String)
        int i1 = 100;
        String s1 = i1+"";
        System.out.println(s1+200);//100200

        String s2 = Integer.toString(100);
        System.out.println(s2+200);//100200

        String s3 = String.valueOf(100);
        System.out.println(s3+200);//100200

        //字符串(String)->基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i-10);

        int a = Integer.parseInt("a");//NumberFormatException
        System.out.println(a);
    }
}
复制