java常用API

• Java API

  • 常用类库

    系统相关、用户输入、Object类、包装类、字符串相关、计算相关、日期相关；

  • 核心类库

    异常处理、集合、泛型、IO、多线程、网络编程、注解、反射机制

• 文档注释

  • 文档注释规范

    1./**开始，*/结束；

    2.提取以public protected修饰的内容；

    3.提取类、接口、构造方法、成员变量、成员方法、内部类之前的注释；

  • Javadoc命令

    • 规范

      javadoc 选项 java源文件/包

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wJPxGuEW-1639062110905)(https://secure1.wostatic.cn/static/23Cfcx7kHJpjWfc8hBcAgJ/81551abb737685267437dcce6138a8d.jpg)]

• 系统相关类

  • System

    1.System类代表当前Java程序的运行平台；

    2.System类不允许被实例化，它所提供的变量和方法全部都是静态的；

    3.System类提供了代表标准输入、标准输出、错误输出的静态变量；

    4.System类提供了访问环境变量、访问系统属性、加载文件、加载动态链接库等方法；

  • Runtime

    1.Runtime类代表Java程序的运行环境；

    2.Runtime符合单例模式，我们只能通过getRuntime（）获得该类型唯一的实例；

    3.Runtime类提供了访问JVM相关信息的方法，如获取CPU数量、获取空闲内存数；

• 用户输入

  • main（）的参数

    命令：java 字符串文件名 字符串1 字符串2 …

public class UserInput{
  public static void main(String[] args){
    // main()的参数
    // java UserInput “Hello world” OK
    for(String arg : args){
      System.out.println(arg);
    }
  }
}

• Scanner类

  1.hasNextXxx():判断是否还有下一个输入项，其中Xxx是代表进本类型的单词.如Int、Long、Double等；

  2.nextXxx():获取下一个输入项；

public class UserInput{
  public static void main(String[] args){
    //Scanner
    Scanner scan = new Scanner(System.in);
    while(scan.hasNextInt()){
      int score = scan.nextInt();
      if(score < 0){
        break;
      }
      System.out.println("本次输入" + score);
    }
    scan.close();
  }
}
// 修改分隔符
// scan.userDelimiter("\n");
//或者scan.hasNextLine()/scan.nextLine()获得字符串;
// 输入字符串
while(scan.hasNext()){
  String str = scan.next();
  if(str.eauqls("exit")){
    break;
  }
}

• Object类

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jlZdR9eO-1639062110906)(https://secure1.wostatic.cn/static/jK61d3xP79k3swCHAKwLhV/18b77a787e5e504477946f06e64107e.jpg)]

  • 重写Object类的equals方法

// equals方法重写
public class EqualsUse {

    public static void main(String[] args) {

        User user1 = new User("name1", "pwd1", 10, new double[10], 01);
        User user2 = new User("name1", "pwd1", 10, new double[10], 01);
        System.out.println(user1.equals(user2));
    }


}

// User也是Object类的子类
public class User {

    String name;
    String pwd;
    int score;
    double[] orderList;
    final int id;

    public User(String name, String pwd, int score, double[] orderList, int id) {
        this.name = name;
        this.pwd = pwd;
        this.score = score;
        this.orderList = orderList;
        this.id = id;
    }
  // 重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return score == user.score && id == user.id && name.equals(user.name) && pwd.equals(user.pwd) && Arrays.equals(orderList, user.orderList);
    }
  //hashcode方法为什么也会被重写，不太清楚
    @Override
    public int hashCode() {
        int result = Objects.hash(name, pwd, score, id);
        result = 31 * result + Arrays.hashCode(orderList);
        return result;
    }
}

• 包装类

  八种数据类型不具备对象的特性，为解决这个问题，Java为每个基本类型都定义了一个对应的引用类型，他们都是基本类型的包装类。

  • 基本类型与包装类型之间的转换：

    1.自动装箱：可以把一个基本类型的数据直接赋值给对应的包装类型；

    2.自动拆箱：可以把一个包装类型的对象直接赋值给对应的基本类型；

  • 包装类型的API

    • 字符串转为基本类型

public static int parInt(String s){}
public Integer(String s){}
//!Character类中没有定义上述静态方法、构造方法

- **比较两个数据的大小**

public static int compare(int x, int y){}

// 1.5以前
Integer oi = new Integer(value : 1);
Character oc = new Character(value : 'A');
int i = oi.intValue(i);
char c =oc.charValue(c);

// 1.5以后
// 自动装箱
Double od =3.14;
Boolean ob = true;

// 自动拆箱
double d = od;
boolean b = ob;

// 字符串转换成基本类型
double dd = Double.parseDouble("1.23");

//基本类型转换成字符串
String s1 = String.valueof(1);

//比较两值
Boolean.compare(false, true);

• ** 包装类是不可变类**

  该类被实例化后，它的实例变量是不可改变的；

  1.使用private和final修饰成员变量；

  2.提供带参数的构造器，用于初始化上述成员变量；

  3.仅提供获取成员变量的方法，不提供修改的方法；

  包装类都是final的，但是final只意味着类不可以被继承，并不意味着它的实例变量不可改变(成员变量final决定)；

• 包装类的父类（Number、Object）

• 包装类中的静态常量

  1.MAX_VALUE

  2.MIN_VALUE

• String

  • 不可变类

    String也是不可变类，创建String对象后，其内部的字符序列不能改变；

  • 使用String

    1.length();

    2.getBytes();

    3.equals();比较字符串的内容

String str = new String("Hello,你好");
str.length();
Arrays.toString(str.gerBytes());// utf-8
Arrays.toString(str.getBytes("GBK"));

- **注意：String的区别**

// 第一种字符串声明方式；
String str1 = new String("Hello");
String str1 = new String("Hello");
System.out.println(str1 == str2);
System.out.println(str1.equals(str2));

output:False,True;

// 第二种也就是常用的字符串声明方式;
// 字符串存储在方法区内字符串类型的常量池中
// 内容相同的直接量在常量池中只保存一份
String str1 = "Hello";
String str1 = "Hello";
System.out.println(str1 == str2);
System.out.println(str1.equals(str2));

output:True,False;

• StringBuilder

  1.StringBuilder封装可变的字符串，对象创建后可以通过方法改变其封装的字符序列；

  2.StringBuffer、StringBuilder作用与方法是一样的，去背在于前者是线程安全的;

  3.StringBuilder是非线程安全的，性能较好，所以通常优先考虑使用StringBuilder。

  • StringBuilder常用API

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B8tFFYEH-1639062110906)(https://secure1.wostatic.cn/static/uCGzg5mgQGhBugtK5qNrgL/576c0763b815d90397e72a8274b28c1.jpg)]

StringBuilder sb = new StringBuilder();
System.out.println(sb.capacity());

sb.append("Hello").append("World");
System.out.println(sb.toString());

sb.insert(12,"你好")；
// 常用格式
StringBuilder builder = 
            new StringBuilder()
                    .append("Hello")
                    .append("world");
System.out.println(builder.toString());

• 正则表达式

  1.在编写处理字符串程序的时候，经常会有查找符合某些复杂规则的字符串的需要；

  2.正则表达式就是用于描述这些规则的工具，正则表达式就是记录文本规则的代码；

  3.各类编程语言都会提供支持正则表达式的API；

  • 元字符

元字符	说明
.	匹配除换行符以外的任意字符
\d	匹配数字
\s	匹配任意的空白字符（空格、制表符、回车符、换页符、换行符等）
\w	匹配字母或数字或下划线
\b	匹配单词的开始或结束
^	匹配字符串的开始
$	匹配字符串的结束

字符转义：如果要查找元字符本身，则需要使用“\”转义，如“.”、“*”、“\”

• 重复

限定符	说明
*****	重复零次或多次
+	重复一次或多次
？	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多次
{n,m}	重复n次到m次

• 重复模式

  1.贪婪模式

  2.懒惰模式

限定符	说明
*？	重复零次或多次，尽可能少重复
+？	重复一次或多次，尽可能少重复
？？	重复零次或一次，尽可能少重复
{n,}？	重复n次或更多次，尽可能少重复
{n,m}？	重复n次到m次，尽可能少重复

• 字符类

  用[]定义一个字符集合：

  1.[aeiou]匹配任何一个元音字母;

  2.[0-9]匹配任何一位数字,与\d等价；

  3.[0-9a-zA-Z_]匹配字母、数字、下划线之中的任何一个字符,与\w等价;

• 分支条件

• 子表达式()

  用于定义子表达式(分组)，可以将其作为一个整体，指定重复次数；

• 反义

反义字符	说明
\W	匹配不是字母、数字、下划线的字符
\S	匹配不是空白字符的字符
\D	匹配不是数字的字符
\B	匹配不是单词开头或结束的位置
[^x]	匹配除x以外的任意字符
[^aeiou]	匹配除了aeiou意外的任意字符

• String与正则表达式

boolean matches(String regex)
// 判断字符串是否与指定的正则表达式（String regex）匹配;
String[] split(String regex)
// 以正则表达式(regex)匹配的内容作为分隔符,将此字符分隔成多个子串;
String replaceFirst(String regex, String replacement)
// 将此字符串中,第一个与正则表达式(regex)匹配的子串替换成目标（replacement）;
String replaceAll(String regrex, String replacement)
// 将此字符串中,每一个与正则表达式(regex)匹配的子串替换成目标(replacement);

String paragraph = "How are you\n" + "Im fine thank you\n";
String paragraphReg = "\\n";
String[] words = paragraph.split(paragraphReg);
Sout(Arrays.toString(words));

• Pattern类和Matcher类

  1.Pattern对象是正则表达式编译后在内存中的表示形式；

  2.Matcher对象是正则表达式与字符串匹配的结果与状态；

  3.Matcher对象通过Pattern对象创建而来，且多个Matcher对象可共享一个Pattern对象；

Pattern pattern = Pattern.compile(reg);
Matcher matcher = pattern.matcher(str);
boolean b = matcher.matches();
// 直接一行代码解决
Matcher matcher = Pattern.compile(reg).matcher(str);
while(matcher.find()){
  sout(matcher.group());
}