《疯狂Java讲义》学习笔记（六）Java基础类库

1、与用户互动

• main函数：public static void main(String[] args){…}
  public修饰符：Java类用JVM调用，为了让JVM可以自由调用这个main方法，所以使用public修饰符把这个方法暴露出来
  static修饰符：JVM直接通过该类调用主方法，因此使用static修饰
  void返回值：返回值返回给JVM没有意义，所以没有返回值
  args参数：可以在配置文件配置
• Scanner读取键盘：

Scanner sc = new Scanner(System.in);
// 换行符
sc.useDelimiter("\n");
while(sc.hasNext()){
    System.out.println(sc.next());
}
// 读取文件流：
Scanner sc = new Scanner(new File("Scanner.java"));
while(sc.hasNextLine()){
    System.out.println(sc.next());
}

2、系统相关

• System
  System类代表当前Java程序的运行平台，程序不能创建System类的对象，System类提供了一些类变量和类方法，允许直接通过System类来调用这些变量和类方法
  System类提供了代表标准输入、标准输出和错误输出的类变量，并提供了一些静态方法用于访问环境变量、系统属性的方法，还提供了加载文件和动态链接库的方法

public static void main(String[] args) throws FileNotFoundException, IOException {
    Map<String, String> env = System.getenv();
    for (String name : env.keySet()) {
        //所有变量
        System.out.println(env.get(name));
    }
    // 指定变量
    System.out.println(System.getenv("HOME"));
    // 获取所有系统属性
    Properties props = System.getProperties();
    // 保存在props.txt
    props.store(new FileOutputStream("props.txt"), "System properties");
    // 输出特定的系统属性
    System.out.println(System.getProperty("os.name"));
}

• Runtime
  Runtime类代表Java程序的运行时环境，每个Java程序都有一个与之对应的Runtime实例，应用程序通过该对象与其运行时环境相连；应用程序不能创建自己的Runtime实例，但可以通过getRuntime()方法获取与之关联的Runtime对象
  Runtime类可以访问JVM的相关信息，如处理器数量、内存信息等

// 获取Java程序关联的运行时对象
Runtime rt = Runtime.getRuntime();
System.out.println("处理器数量："+rt.availableProcessors());
System.out.println("空闲内存数："+rt.freeMemory());
System.out.println("总内存数："+rt.totalMemory());
System.out.println("可用最大内存数："+rt.maxMemory());

3、常用类

• Object类是所有类、数组、枚举类的父类，Java允许把任何类型的对象赋给Object类型的变量；当定义一个类时没有使用extends关键字为它显式指定父类，则该类默认继承Object父类
• 所有Java类都是Object类的子类，所以任何Java对象都可以调用Object类的boolean equals(object obj)

protected void finalize()：当系统中没有引用变量引用到该对象时，垃圾回收器调用此方法来清理该对象的资源
Class<?> getClass()：返回该对象的运行时类
int hasCode()：返回该对象的hasCode值，默认情况下根据该对象的地址来计算（即与System.identityHashCode(Object x)方法的计算结果相同）
String toString():返回该对象的字符串，默认情况下Object类的toString()方法返回“运行时类名@十六进制hashCode值“格式的字符串
super.clone()：克隆方法，它只克隆该对象的所有成员变量值，不会对引用类型的成员变量值所引用的对象进行克隆，相当于new一个新对象，将旧对象的变量值赋予给新对象bjects工具类，“空指针“安全

• String、StringBuffer和StringBuilder

String 类是不可变类，即一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁
StringBuffer对象是一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过append()、insert()、reverse()、setCharAt()、setlength()等方法可以改变这个字符串对象的字符序列
StringBuilder和StringBuffer基本像是，但StringBuilder没有实现线程安全，所以性能略高，因此创建可变字符串对象，应优先考虑使用StringBuilder类
String、StringBuilder、StringBuffer都实现了CharSequence接口，因此CharSequence可认为是一个字符串的协议接口
String常用API：
String()：创建一个包含0个字符串序列的String对象
String(byte[] bytes,Charset charset)：使用指定的字符集将指定的byte[]数组解码成一个新的String对象
String(byte[] bytes,int offset,int length)：使用平台的默认字符集将指定的byte[]数组从offet开始、长度为length的子数组解码成为一个新的String对象
String(byte[] bytes,int offset,int length,String charsetName)：使用指定的字符集将指定的byte[]数组从offset开始、长度为length的子数组解码成一个新的String对象
String(byte[] bytes,String charsetName)：使用指定的字符集将指定的byte[]数组解码成一个新的String对象
String(char[] value,int offset,int count)：将指定的字符数组从offset开始、长度为count的字符元素连缀成字符串
String(String original)：根据字符串直接量来创建一个String对象
String(StringBuffer buffer)：根据StringBuffer对象来创建对应的String对象
String(StringBuilder builder)：根据StringBuilder对象来创建对应的String对象
char charAt(int index)：获取字符串中指定位置的字符，index从0开始到length()-1
int compareTo(String anotherString())：比较两个字符串的大小；如果两个字符串的字符序列相等，则返回0；不相等时，从第0个字符开始比较，返回第一个不相等的index；如果一个字符串的前面刚好是另一个字符串（abc和abcde），则返回它们的长度差
String concat(String str)：将该String对象与str连接在一起，相当于“＋“
boolean contentEquals(StringBuffer sb)：将String与StringBuffer进行比较，当它们包含的字符序列相同时返回true
static String copyValuesOf(char[] data)：将字符数组连缀成字符串，与String(char[] content)类似
static String copyValuesOf(char[] data,int offset,int count)
boolean endsWith(String suffix)：返回该String对象是否以suffix结尾
boolean equals(Object obj)：将该字符串与指定对象比较，如果两者包含的字符序列相等，则返回true
boolean equalsIgnoreCase(String str):同上，忽略大小写
byte[] getBytes()：将该String对象转换成byte数组
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)：将字符串中从srcBegin开始，到srcEnd结束的字符赋值（将其替换）到dst字符数组中，其中dstBegin为目标字符数组的起始复制位置
int indexOf(int ch)：找出ch字符在该字符串中第一次出现的位置
int indexOf(int ch,int fromIndex)：找出ch字符在该字符串中从fromIndex开始后第一次出现的位置
int indexOf(String str)：找出str字符串在该字符串中第一次出现的位置
int indexOf(String str,int fromIndex)：找出str字符串在该字符串中从fromIndex开始后第一次出现的位置
int lastIndexOf(int ch)
int lastIndexOf(int ch,int fromIndex)
int lastIndexOf(String str)
int lastIndexOf(String str,int fromIndex)
int length()
String replace(char oldChar,char newChar)
String replace(CharSequence target,CharSequence replacement)
boolean startsWith(String prefix)
boolean startsWith(String prefix,int toffset)：该String对象从toffet位置算起，是否以prefix开始
String substring(int beginIndex)：获取从beginIndex位置开始到结束的子字符串
String substring(int beginIndex,int endIndex)：获取从beginIndex位置开始到endIndex位置的子字符串
char[] toCharArray()
String toLowerCase()
String toUpperCase()
static String valueOf(X x)：一系列用于将基本类型值转换为String对象

• 因为String是不可变类，使用String相加的形式会产生很多临时变量，使用StringBuffer或StringBuilder可以避免这个问题
• StringBuffer和StringBuilder可以通过length()和setLength(int len)方法来访问和修改字符序列的长度，capacity属性表示它的容量，通常比length大，一般不需要关心

StringBuilder append(String str)
StringBuilder insert(int offset,String str)
StringBuilder replace(int start,int end,String str)
StringBuilder reverse()
StringBuilder delete(int start,int end)

4、Math

• Java提供了Math工具类完成像三角函数、对运算、指数运算等复杂运算，Math是工具类，所有方法都是类方法，还提供了两个类变量：PI和E
• ThreadLocalRondom是Random的增强版，在并发访问的环境下，使用ThreadLocalRandom可以减少线程资源竞争，保证系统具有更好的线程安全。
• Random

Random random = new Random();
random.nextBytes(new byte[16]);
random.nextInt(10);
random.nextDouble();
...

• ThreadLocalRandom

ThreadLocalRandom tlr = ThreadLocalRandom.current();
tlr.nextInt(4,20);
tlr.nextDouble(2.0,10.0);

5、BigDecimal

• 为了精确表示、计算浮点数，Java提供了BigDecimal类，该类提供了大量构造器用于创建BigDecimal对象
• BigDecimal(double val)会带来精度损失，应当优先使用BigDecimal(String str),如果必须使用double浮点数作为构造器参数，应该使用BigDecimal.valueOf(double value)静态方法来创建
• BigDecimal提供了add()、subtract()、multiply()、divide()、pow()次方等方法惊醒常规运算

6、java.util.Date类处理日期、时间，但Date的大部分构造器、方法都已经过时，不再推荐使用

• Date提供了6个构造器，其中四个已经Deprecated，剩下两个构造器如下：
  Date()：生成一个代表当前时间的Date对象，底层调用System.currentTimeMillis()获取long整数作为日期参数
  Date(long date)
• Date对象大部分方法也Deprecated，剩下为数不多的几个方法：
  boolean after(Date when)：测试该日期是否在指定日期when之后
  boolean before(Date when)：测试该日期是否在指定日期when之前
  long getTime()：返回该时间对应的long型整数，即从GMT 1970-01-01 00:00:00 到该Date对象之间的时间差，以毫秒作为计时单位
  void setTime(long time)：设置该Date对象的时间

7、Calender

• Calender类是一个抽象类，它提供了几个静态方法getInstance()来获取Calendar对象，这些方法根据TimeZone、locale来创建Calendar，如果不指定则使用系统默认的TimeZone、locale来创建
• Calendar常用API

void add(int field,int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量，如：calendar.getInstance().add(YEAR,-1)
int get(int field)：返回指定日历字段的值
int getActualMaximum(int field)：返回指定日历字段可能拥有的最大值，如：月的最大值为11
int getActualMinimum(int field)：返回指定日历字段可能拥有的最小值，如：月的最小值为0
void roll(int field,int amount)：与add()类似，区别在于加上amount后超过了该字段所能表示的最大范围时，也不会向上一个字段进位
void set(int field,int value)：将给定的日历字段设置为给定值
void set(int year,int month,int date)：设置Calendar对象的年、月、日三个字段的值
void set(int year,int month,int date,int hourOfDay,int minute,int second)：设置Calendar对象的年、月、日、时、分、秒6个字段的值
field是Calendar的类变量，如：Calendar.MONTH

• add()与roll()的区别
  roll当被修改字段超出它允许的范围时，上级字段不会增大，而add则会

Calendar cal = Calendar.getInstance();
cal.set(2003,7,31,0,0,0);//2003-8-31
->cal.roll(MONTH,6);// 2003-2-28
->cal.add(MONTH,6);// 2004-2-29

• Calendar的容错性
  设置大于最大值的参数会向上一个字段进位，如果不希望自动进位，可以设置为cal.setLenient(false);
• Calendar转化为Date

Date date = Calendar.getInstance().getTime();

• set()方法延迟修改
  set(f,value)方法将日历字段f更改为value，该Calendar所代表的时间却不会立即修改，直到下次调用get()、getTime()、getTimeInMillis()、add()或roll()时才会重新计算日历时间，这被称为set()方法的延迟修改
• add和set方法的微妙区别

Calendar cal = Calendar.getInstance();
cal.set(2017,7,31);//2017-08-31
->cal.add(Calendar.MONTH, 1);//2017-09-30
->cal.set(Calendar.MONTH, 8);//2017-09-30

8、Java8新增java.time

• Clock：获取指定时区的当前日期、时间

Clock clock = Clock.systemUTC();
clock.instant();//当前时刻
clock.millis();
clock.currentTimeMillis();

• Duration：该类代表持续时间，可以获取一段时间

Duration d = Duration.ofSeconds(6000);
d.toMinutes();
d.toHours();
d.toDays();
Clock clock = Clock.offset(clock,d);
clock.instant();//当前时刻+6000秒

• Instant：代表一个具体的时刻，可以精确到纳秒

Instant instant = Instant.now();//获取当前时间
instant.plusSeconds(6000);//获取当前时间+6000秒
Instant.parse("2014-02-23T10:12:35.342Z");//根据字符串解析Instant对象，只能用此格式，用“2017-01-01”报错

• LocalDate：该类代表不带时区的日期

LocalDate.now();//获取当前日期
LocalDate.ofYearDay(2014,146);//获取2014年的第146天
LocalDate.of(2014,Month.MAY,21);

• LocalTime：代表不带时区的时间

LocalTime.now();//获取当前时间
LocalTime.of(22,23);//22:33
LocalTime.ofSecondOfDay(5503);

• LocalDateTime：代表不带时区的日期、时间
• MonthDay：代表月日，如：–04-12
• Year：代表年，如：2014

Year year = Year.now();//当前年份
year.plusYears(5);//当前年份再加5年

• YearMonth：代表年月

YearMonth ym = year.atMonth(10);
ym = ym.plusYears(5).minusMonths(3);//当前年月再加年、减3个月
MonthDay md = MonthDay.now();//当前年月
md = md.with(Month.MAY).withDayOfMonth(23);//输出--05-23

• ZonedDateTime：代表一个时区化的日期、时间
• ZoneId：代表一个时区
• DayOfWeed：枚举类，定义了周日到周六的枚举值
• Month：枚举类，定义了一月到十二月的枚举类

9、正则表达式

• 正则表达式是一个强大的字符串处理工具，可以对字符串进行查找、提取、分割、替换等操作

boolean mathches(String regex)：判断该字符串是否匹配指定的正则表达式
String replaceAll(String regex,String replacement)：将该字符串中所有匹配regex的子串替换成replacement
String replaceFirst(String regex,String replacement)：将该字符串中第一个匹配regex的子串替换成replacement
String split(String regex)：以regex作为分隔符，把该字符串分割成多个子串

• 正则表达式就是一个用于匹配字符串的模板，可以匹配一批字符串，所以创建正则表达式就是创建一个特殊的字符串
  x：代表任何合法的字符
  \t：制表符’\u0009’
  \n：新行（换行）符(‘\u000A’)
  \r：回车符
  \f：换页符
  \a：报警符
  \e：escape符
  \cx：x对应的控制符，如：\cM匹配Ctrl-M，x必须为A~Z或a~z之一
• 特殊字符需要在前面添加一个反斜杠（\）

$：匹配一行的结尾
^：匹配一行的开头
()：标记子表达式的开始和结束位置
[]：用于确定中括号表达式的开始和结束位置
{}：用于标记前面字表达式的出现频度
*：指定前面子表达式可以出现零次或多次
+：指定前面字表达式可以出现一次或多次
?：指定前面子表达式可以出现零次或一次
.：匹配除换行符\n之外的任何单字符
\：用于转义下一个字符
|：指定两项之间任选一项

• 预定义字符（通配符）

.：可以匹配任何字符
\d：匹配0~9的所有数字
\D：匹配非数字
\s：匹配所有的空白字符，包括空格、制表符、回车符、换页符、换行符等
\S：匹配所有非空白字符
\w：匹配所有的单词字符，包括0~9所有数字、26个英文字母和下画线
\W：匹配所有非单词字符
s代表space，d代表digit，w代表word

• 方括号表达式

表示枚举：[abc]，表示a、b、c其中任意一个字符
表示范围：[a-f]表示a~f范围内的任意字符，[a-cx-z]表示a~c、x~z范围内的任意字符
表示求否：abc表示非a、b、c的任意字符，a-f表示不是a~f范围内的任意字符
表示“与”运算：[a-z&&[def]]，求a~z和[def]的交集，表示d、e或f
表示“并”运算：[a-d[m-p]]表示[a-dm-p]
- 边界匹配符
^：行的开头
$：行的结尾
\b：单词的边界
\B：非单词的边界
\A：输入的开头
\G：前一个匹配的结尾

• Pattern和Matcher

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaab");
boolean b = m.mathches();//返回true
// 上面的Pattern可以多次使用，如果某个正则表达式仅需使用一次，可以：
boolean b = Pattern.mathches("a*b","aaaab");//返回true
// 但这样的方式每次都要重新编译新的Pattern对象，效率不高
Pattern是不可变类，可供多个并发线程安全使用

• Matcher常用API

find()：返回目标字符串中是否包含于Pattern匹配的子串
group()：返回上一次与Pattern匹配的子串
start()：返回上一次与Pattern匹配的子串在目标字符串中的开始位置
end()：返回上一次与Pattern匹配的子串在目标字符串中结束位置+1
lookingAt()：返回目标字符串前面部分与Pattern是否匹配
mathches()：返回整个目标字符串与Pattern是否匹配
reset()：将现有的Matcher对象应用于一个新的字符序列

• 用法

String regStr = "Java is very easy!";
Matcher m = Pattern.compile("\w+").matcher(regStr);
while (m.find()) {
    System.out.println(m.group() + "起始位置：" + m.start() + "结束位置：" + m.end());
}
// Java起始位置：0结束位置：4
// is起始位置：5结束位置：7
// very起始位置：8结束位置：12
// easy起始位置：13结束位置：17

• matches()和lookingAt()方法有点相似，区别在于前者要求整个字符串匹配时才返回true，而lookingAt()只要字符串以Pattern开头就返回true

10、格式化

• 使用NumberFormat格式化数字

NumberFormat是一个抽象基类，提供以下API
getCurrencyInstance()：返回默认Locale的货币格式器
getIntegerInstance():返回默认Locale的整数格式器
getPercentInstance()：返回默认Locale的百分数格式器
// 123,456.7
NumberFormat.getNumberInstance(Locale.CHINA).format(123456.70);
// 123,457
NumberFormat.getIntegerInstance(Locale.CHINA).format(123456.70);
// 12,345,670%
NumberFormat.getPercentInstance(Locale.CHINA).format(123456.70);
// $123,456.70
NumberFormat.getCurrencyInstance(Locale.US).format(123456.70);

• DateFormat格式化日期、时间

getDataInstance()：返回一个日期格式器
getTimeInstance()：返回一个时间格式器
getDateTimeInstance()：返回一个日期、时间格式器
// 18-3-13
DateFormat.getDateInstance(DateFormat.SHORT).format(new Date());
// 2018-3-13
DateFormat.getDateInstance(DateFormat.MEDIUM).format(new Date());
// 2018年3月13日
DateFormat.getDateInstance(DateFormat.LONG).format(new Date());
// 2018年3月13日 星期二
DateFormat.getDateInstance(DateFormat.FULL).format(new Date());
// 下午4:41
DateFormat.getTimeInstance(DateFormat.SHORT).format(new Date());
// 16:41:45
DateFormat.getTimeInstance(DateFormat.MEDIUM).format(new Date());
// 下午04时41分45秒
DateFormat.getTimeInstance(DateFormat.LONG).format(new Date());
// 下午04时43分17秒 CST
DateFormat.getTimeInstance(DateFormat.FULL).format(new Date());
// 2018-3-13 16:41:45
DateFormat.getDateTimeInstance().format(new Date());
DateFormat的parse()方法可以把一个字符串解析成Date对象
// Fri Dec 12 00:00:00 CST 2014
DateFormat.getDateInstance().parse("2014-12-12");
// Wed Dec 10 00:00:00 CST 2014，因为2014年12月10日是一个Long样式的日期字符串，所以必须用LONG解析
DateFormat.getDateInstance(DateFormat.LONG).parse("2014年12月10日")
- SimpleDateFormat格式化日期
SimpleDateFormat可以非常灵活地格式化Date，也可以用于解析各种格式的日期字符串
// 公元2018年中第72天
new SimpleDateFormat("Gyyyy年中第D天").format(new Date());
// 2018-03-13 16:55:02
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
// Tue Mar 13 16:54:14 CST 2018
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2018-03-13 16:54:14");