Java的常用API

Scanner 获取键盘输入内容

package api.demo;
// 1.导包
import java.util.Scanner;

public class demo1 {
  public static void main(String[] args) {

    // 2.创建
    // 备注： System.in 代表从键盘进行输入
    Scanner sc = new Scanner(System.in);

    // 3.在键盘输入数字
    System.out.println("请输入数字：");
    int num = sc.nextInt();
    System.out.println("你输入的数字是:" + num);

    // 4.在键盘输入字符串
    System.out.println("请输入字符串：");
    String str = sc.next();
    System.out.println("你输入的字符串是:" + str);
    
    // 关闭
    sc.close();
  }
}

创建匿名对象

package api.demo;

// 创建一个类
class Persion {
  String name;
  int age;
}

public class object {
  public static void main(String[] args) {
    // 普通创建对象方式
    Persion one = new Persion();
    one.name = "jeery";
    System.out.println("this one name is " + one.name);

    // 匿名对象的创建, 创建匿名对象只能使用一次
    // 一般可用作其他方法的入参
    new Persion().name = "tom";
  }
}

Random 生成随机数

package api.demo;
// 导包
import java.util.Random;

public class random {
  public static void main(String[] args) {
    // 创建一个对象
    Random r = new Random();

    /**
     * 使用
     */

    // nextInt 留空，随机范围为int值的所有范围
    int num1 = r.nextInt();
    System.out.println("nextInt随机数：" + num1);

    // nextInt 入参输入数字，这个数字代表了生成随机数的范围，左闭右开区间
    int num2 = r.nextInt(100); // 范围 [0, 100) 0~99
    System.out.println("nextInt带范围的随机数：" + num2);
  }
}

对象数组

package api.array;
// ------ Person.java -------
// 创建一个类
public class Person {
  private String name;
  private int age;

  // 无参构造
  public Person() {
  }

  // 全参构造
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  // Geting 和 Seting
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
}


// --------- arr.java ----------
// 创建数组对象
package api.array;

public class arr {
  public static void main(String[] args) {
    // 创建一个长度为3的数组，用来存放Persion对象
    Person[] arr = new Person[3];

    arr[0] = new Person("jerror", 10);
    arr[1] = new Person("tom", 12);
    arr[2] = new Person("jack", 20);

    System.out.println("第一个对象：" + arr[0].getName());
    System.out.println("第二个对象：" + arr[1].getName());
    System.out.println("第三个对象：" + arr[2].getName());
  }
}

ArrayList 集合

集合与数组的区别是array的长度是固定的，而集合的长度是可以变化的。

package api.array;
import java.util.ArrayList;

public class Demo {
  public static void main(String[] args) {
    // 创建一个ArrayList集合，集合的名字是list，里面保存的是字符串类型数据
    ArrayList<String> list = new ArrayList<String>();

    // 添加数据 add(E e) // 泛型必须是引用类型数据
    list.add("tom");
    list.add("jerry");
    list.add("jack");

    System.out.println("集合：" + list);

    // 获取数据 get(int index)
    String nameOne = list.get(0);
    System.out.println("读取数据：" + nameOne);

    // 删除数据 remove(int index): current
    String currentRemove = list.remove(1);
    System.out.println("已删除数据：" + currentRemove);

    // 获取长度 size()
    int size = list.size();
    System.out.println("集合的长度" + size);

    /**
     * 包装类(应用类型)
     * 包装类位于java.lang包下，所有的字母为大写
     * 
     * 基本类型       包装类
     * byte          Byte
     * short         Short
     * int           Integer
     * long          Long
     * float         Float
     * double        Double
     * char          Character
     * boolean       Boolean
     */

    // 集合添加基本类型的数据
    // 由于泛型不能存基本类型的数据，必须使用基本类型的包装类
    ArrayList<Long> listOne = new ArrayList<Long>();

    listOne.add(1000L);
    listOne.add(2000L);
    listOne.add(3000L);

    System.out.println("listOne:" + listOne);
    System.out.println("get:" + listOne.get(2));

    // 从JDK1.5版本开始，支持自动装箱（基本类型转引用类型）、自动拆箱（引用类型转基本类型）
  }
}

String 字符串

在Java中所有的字符串都是引用类型数据。

字符串的特点：

• 字符串的内容不可变。
• 由于数据不可变，它可以共享使用。
• 字符串在形式上相当于char[]字符数组。但底层原理是byte[]字节数组。

public class demo {
  public static void main(String[] args) {
    // 创建字符串的方法
    String str1 = "hello"; // 直接赋值
    String str2 = new String(); // 空字符串
    char[] charArray = {'h', 'e', 'l', 'l', 'o' };
    String str3 = new String(charArray); // 通过char[] 创建
    byte[] byteArray = {'a', 'b', 'c' };
    String str4 = new String(byteArray); // 通过byte[] 创建

    // 字符串比较
    // 由于字符串的特性，导致了直接用 == 作比较是不精确的
    // 可以通过 xxx.equals(xxx) 的方式来比较两个字符串是否相等 
    // a.quuals(b) 和 b.equals(a) 效果是一样的，但是优先把常量放前面比较
    String s1 = "abc";
    String s2 = "abc";
    char[] charArr = {'a', 'b', 'c'};
    String s3 = new String(charArr);
    System.out.println(s1 == s2); // true
    System.out.println(s1 == s3); // false

    // 获取字符串长度 xxx.length()
    System.out.println("字符串长度：" + s1.length());

    // 拼接字符串 xxx.concat(String str)
    System.out.println("拼接字符串" + s1.concat(s2));
    // 获取指定位置单个字符  xxx.charAt(int index) 如果没有返回 -1

    System.out.println("获取第3个字符" + s1.charAt(2));

    // 查找首次出现的字符 片段索引位置 xxx.indexOf(String str)
    System.out.println("获取字符片段位置" + s1.indexOf("b"));

    // 截取字符串 xxx.substring(int index) 从指定位置一直截取到结尾
    System.out.println("截取方法substring: " + str1.substring(1));

    // 截取字符串 xxx.substring(int start, int end) 截取从start到end之间的字符片段
    System.out.println("截取方法substring: " + str1.substring(1, 3));

    // 获取字符串的字符数组 xxx.toCharArray()
    char[] c = str1.toCharArray();
    System.out.println("字符数组：" + c[0]+ c[1]);

    // 获取字符串的字节数组 xxx.getBytes()
    byte[] b = str1.getBytes();
    System.out.println("获取字节数组" + b[0]);

    // 字符替换并返回新字符串 xxx.replace(old, new)
    System.out.println("字符串替换" + "helloword".replace("ow", "aaa"));

    // 根据指定内容分割字符串为数组 xxx.split(String regex)
    System.out.println("分割字符串" + "aaa,bbb,ccc".split(","));
  }
}

static 静态(关键字)

使用static关键词之后，所有被修饰的对象不在属于实例，而是属于类(class)的，多个对象实例共享同一份class类上的数据。
用statci关键词修饰的属性或方法，不需要创建对象实例就可以直接使用.

public class Person {
  // 普通属性
  private String name;
  private int age;

  // static 修饰的静态属性
  static String country;

  // 普通成员方法
  public void foo() {
    // some code
  }

  /**
   * static 修饰的静态方法
   * 对于静态方法，既可以在对象实例上调用也可以使用class类调用。
   * 推荐的做法是从class上面调用静态方法
   */
  public static void someMethod() {
    // some code
  }

  /**
   * 静态代码块
   * 在clas类中，使用static修饰的静态代码块，在第一次使用这个clas类时执行唯一的一次
   */
  static {
    System.out.println("这个类被使用了，这个静态代码块中的内容只执行唯一一次。");
  }

  public int getAge() {
    return age;
  }

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

  public String getName() {
    return name;
  }

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

Arrays 数组工具

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

import java.util.Arrays;

public class arrays {
  public static void main(String[] args) {
    int[] intArr = { 1, 55, 22, 29 ,66 };

    // Arrays.toString(arr) 将数组转为字符串
    System.out.println("toString:" + Arrays.toString(intArr));

    // Arrays.sort(arr) 排序 安装默认升序排列
    // 如果是数组 默认安装数值的升序排序
    // 如果是字母 默认安装字母的顺序升序排序
    Arrays.sort(intArr);
    System.out.println("sort排序后的数组：" + Arrays.toString(intArr));
  }
}

Math 数学

public class math {
  public static void main(String[] args) {
    double num1 = -123913.281979;
    double num2 = 1231.182;
    /**
     * Math 方法不需要导包可以直接用
     */
    // Math.abs(xxx) 获取绝对值
    System.out.println("abs:" + Math.abs(num1));

    // Math.ceil 向上取整
    System.out.println("ceil:" + Math.ceil(num2));

    // Math.floor 向下取整
    System.out.println("floor:" + Math.floor(num2));

    // Math.round 四舍五入
    System.out.println("round:" + Math.round(num2));

    // Math.PI 圆周率的近似值
    System.out.println("PI:" + Math.PI);

  }
}