Java常用类

八大基本数据类型对应的包装类

byte      -> Byte
boolean   -> Boolean
char      -> Character
short     -> Short
int       -> Integer
long      -> Long
float     -> FLoat
double    -> Double
1
2
3
4
5
6
7
8

jdk1.5后支持自动拆包解包，这些都存于java.lang包中

String类

$String类继承关系$

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    ...
    public int hashCode() { // String的hashcode根据value[]内容被重写，所以value相同，其hashcode的值相同， 也会出现value不相同，hashcode相同的情况，例如"abc".hashcode 与 "acD".hashcode相等，这就是哈希冲突
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }
}
/*
Serializable代表序列化，可在网络上进行序列化传输，然后反序列化
Comparable 代表可比较
CharSequence 字符序列化 
final 类不允许被继承
private final char value[]; // 字符串一旦被赋值，value里的值就不能被修改，能改的是String的指向
str.intern() // 去常量池子中找，当找到与str相同的字符串时，返回其地址，否则将当前对象添加至常量池，并返回其引用
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

$String的库函数$

String a = "hello", b = "world";
String c = a + b; 
执行过程分析: new StringBuilder(16), sb.append(a), sb.append(b), sb.toString()
String常用方法：
boolean equals(String other) // 判断是否相等
boolean equalsIgnoreCase() // 忽略大小写比较
int length() // 获取长度
int indexof(char ch) // 字符串中第一次出现ch的下标
int indexof(char ch, int formIndex);
int indexof(String str);
int indexof(String str, int formIndex);
int lastindexof(char ch) // 字符串中最后一次出现ch的下标
String substr(6); // 从str[6]开始截取到末尾
String substr(beginIndex, endIndex) // 截取str的[beginIndex:endIndex)
String trim(); // 去掉前后的空格
String toLowerCase(); // 转成小写
String toUpperCase(); // 转成大写
String concat(); // 连接
String replace(char oldChar, char newChar); // 替换
String[] split(String regex); // 分割
int compareTo(String other); // 字符串比较字典序
char[] toCharArray(); // 转成char数组
String intern(); // 返回与当前equals(s)为真的对象的常量池中的地址，如果没有当前对象入池，并返回引用
String format(str, xxx); // 根据格式返回字符串
String.format("我是%s,今年%d岁，希望有一天，我能很快乐的和%s在一起，度过每一天!", name, age, lover)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

StringBuffer类

java.lang.StringBuffer 代表可变的字符序列，可以对字符进行增加删除，StringBuffer是一个容器

特性

1. $StringBuffer$ 的直接父类是 $AbstractStringBuffer$
2. $StringBuffer$ 实现了$Serializable$, 即 $StringBuffer$对象能够序列化
3. 在父类中 $AbstractStringBuffer$,有char[] value, 不是final
4. $StringBuffer$ 是一个final类，不能被继承

$StringBuffer类继承关系$

 public final class StringBuffer
    extends AbstractStringBuilder
    implements Serializable, CharSequence {
    ...
}
1
2
3
4
5

$StringBuffer的常用方法$

String与StringBuffer的比较

1. String保存的字符串常量，里面的值不能更新，String更新时是切换了地址，效率很低private final char value[]
2. String保存的是字符串变量，里面的值可以修改，每次StringBuffer的更新实际上可以更新内容，不用更新地址，效率较高，

StringBuilder类

java.lang.StringBuilder 代表可变的字符序列，可以对字符进行增加删除，类似于StringBuffer,常用于多线程，效率高，线程不安全

Array类

String Array.toString(T a[]);
int Array.BinarySearch(T a[], T val); // 查找val在有序数据a中的下标，找不到返回应该在的位置的相反数
int Array.sort(a); // 给数组从下到大排序
Arrays.sort(a, new Comparator() { // 自定义排序     
    @Override
    public int compare(Object o1, Object o2) {
        return (Integer)o2 - (Integer)o1;
    }
});
T [] Arrays.copyOf(T src[], T n); // 将src中n个元素拷贝出来
void Arrays.fill(T src[], T val); // 数组填充
void Arrays.fill(T src[], T val, int fromIndex, int toIndex); // 指定位置填充
boolean Arrays.equals(T[], T[]); // 比较连那个数组是否相同
Arrays.ArrayList Arrays.asList(); // 将一串数转换成集合
1
2
3
4
5
6
7
8
9
10
11
12
13
14

System类

常用方法

System.arraycopy(a, 0, b, 0, 3); // 拷贝数组
System.out.println(System.currentTimeMillis()); // 1970.1.1到现在经过的毫秒数
System.gc(); // 启用垃圾回收
System.exit(-1); // 退出当前程序，status退出的返回值
1
2
3
4

BigInteger类

BigInteger bg = new BigInteger("11111111111111111111111111111111");
BigInteger x = new BigInteger("234342155345");
bg.add(x);
bg.subtract(x);
bg.multiply(x);
bg.divide(x);
1
2
3
4
5
6

BigDecimal类

BigDecimal x = new BigDecimal("32424.321424312432443");
// BigDecimal.Round_CEILING 当除不尽时候保留的精度
1
2

Date类

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;

/**
 * @author Rw-chen
 * @version 0.1
 */
public class Main {
    public static void main(String[] args) {
        // 第一代日期
        Date date = new Date(); // 获取当前日期
        System.out.println("" + date.toString());
        SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
        String s = sf.format(date);
        System.out.println(s);
        try {
            System.out.println(sf.parse(s)); // 将s根据sf格式转成Date
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 第二代日期 calendar
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar);
        // 第三代 LocalDate, LocalTime, LocalDateTime
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);
        System.out.println(ldt.getYear());
        System.out.println(ldt.getMonth() + " " + ldt.getMonthValue());
        System.out.println(ldt.getHour() + ":" + ldt.getMinute() +":"+ ldt.getSecond());
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日HH时mm分ss秒");
        System.out.println(formatter.format(ldt)); // 格式化日期
        System.out.println(formatter.parse(s));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38