Java基础知识笔记第八章：常用的实体类

String类

String类位于lang包下
java会默认导入lang包下的类，所以可以直接使用，注意String是final类所以不能有子类

构造String对象：
常量对象：String常量也是对象：“hello”，“34354”等等；
 
/*
*java把用户程序中的String常量放入常量池，因为String常量是对象，使用也有自己的引用和实体
*可以这样理解：常量池中的数据在运行期间再也不允许改变
*/

String对象：
String  str1=new String("we  are   strudents");
String  str2=new String("we  are   strudents");
/*凡是new出来的对象都不在常量池中   str1==str2   false*/
 
常用构造方法：
String(char a[]);
String(char a[],int startIndex,int count)

引用String常量
String s1,s2;
s1="你好"
s2="你好"
s1==s2;//true  因为s1,s2都是指向常量池同一位置

String对象可以用+号来并置运算，首尾相连成新的字符串

　　String类的常用方法

public int length();
public boolean equals(String s);
public boolean starsWith(String s);
public boolean endsWith(String s);
public boolean contains(String s);
public String substring(int startpoint);
更多参考哎批唉文档

public String trim（）；//去掉前后空格

String  str=String.valueOf(123.456);//数字转String对象

public  char[] toCharArray();//字符串转数组

　　字符串与字节数组：

String(byte[],int offset,int length);
public  byte[]  getBytes();

　   正则表达式及字符串的替换与分解

/*
*正则表达式：
*正则表达式是一个String对象的字符序列，该字符序列中含有具有特殊意义的字符串，这些字特殊的符串称作正则表达式的元字符。
*/

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。
^	匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 。? 等价于 {0,1}。
{n}	n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,}	n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。
.	匹配除换行符（\n、\r）之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用像"(.|\n)"的模式。
(pattern)	匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 '\(' 或 '\)'。
(?:pattern)	匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
(?=pattern)	正向肯定预查（look ahead positive assert），在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，"Windows(?=95|98|NT|2000)"能匹配"Windows2000"中的"Windows"，但不能匹配"Windows3.1"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	正向否定预查(negative assert)，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如"Windows(?!95|98|NT|2000)"能匹配"Windows3.1"中的"Windows"，但不能匹配"Windows2000"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?<=pattern)	反向(look behind)肯定预查，与正向肯定预查类似，只是方向相反。例如，"(?<=95|98|NT|2000)Windows"能匹配"2000Windows"中的"Windows"，但不能匹配"3.1Windows"中的"Windows"。
(?<!pattern)	反向否定预查，与正向否定预查类似，只是方向相反。例如"(?<!95|98|NT|2000)Windows"能匹配"3.1Windows"中的"Windows"，但不能匹配"2000Windows"中的"Windows"。
x|y	匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
[xyz]	字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'、'l'、'i'、'n'。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\cx	匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\f	匹配一个换页符。等价于 \x0c 和 \cL。
\n	匹配一个换行符。等价于 \x0a 和 \cJ。
\r	匹配一个回车符。等价于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于 \x09 和 \cI。
\v	匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w	匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。
\W	匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'。
\xn	匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，'\x41' 匹配 "A"。'\x041' 则等价于 '\x04' & "1"。正则表达式中可以使用 ASCII 编码。
\num	匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)\1' 匹配两个连续的相同字符。
\n	标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
\nm	标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
\nml	如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
\un	匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

/*
String对象调用public  boolean  matches(String regex);方法可以判断当前String对象字符序列是否和参数regex指定的表达式匹配
*/

package chapter_7;
/**
 * @author Mikey
 * @date 2018/10/2 12:03
 */
public class StringTest {
    public static void main(String[] args){
 
        String str1="_";
        String var="[a-zA-Z|0-9|_]";
        System.out.println(str1.matches(var));
 
    }
 
}

/*
*注意java中的正则表达式和js中的内容并无区别但是，java要双斜杠，\\
*/

/**
 * @author Mikey
 * @date 2018/10/2 12:03
 */
public class StringTest {
    public static void main(String[] args){
        final String var="^[a-zA-Z0-9_.-]+@[a-zA-Z0-9-]+(\\.[a-zA-Z0-9-]+)*\\.[a-zA-Z0-9]{2,6}$";
        final String REGEX_USERNAME = "^[a-zA-Z]\\w{5,20}$";
            System.out.println("abcd100".matches(REGEX_USERNAME));//true
            System.out.println("163@qq.com".matches(var));//true
 
    }
 
}

public String replaceAll(String regex,String replacement);
该方法返回一个新的String对象，这个新的对象的字符串序列是把当前String对象中所有和参数regex匹配的子字符序列，用replacement的字符序列替换后得到的字符序列 
 
String  str="12hello567bird".repalceAll("[a-zA-Z]",“你好”）；

StringTokenizer类

当分析一个String对象的字符序列并将字符序列分解成可被独立使用的单词时，可以使用java.util包下的StringTokenizer类
 
常用两个构造方法：
StringTokenizer(String s）:为String对象s构造一个分析器，使用默认的分隔标记，即空格，换行，回车。tab符，进纸符做分隔标记！
 
StringTokenizer(String s,String delim):为String对象s构造一个分析器。参数delim的字符序列中的字符的任意排列被作为分隔标记；

StringTokenizer fenxi=new StringTokenizer("you  are   welcome");
StringTokenizer fenxi=new StringTokenizer（“you*/are*/welcome”，“*/”）

Scanner类

//   Scanner对象可以解析字符序列中的单词，例如：对于String对象NBA
String  NBA="i love   This  Game";
Scanner scanner=new Scanner(NBA);
//Scanner对象可以调用方法
useDelimiter(正则表达式）；

Scanner对象调用next（）方法依次返回被解析的字符序列中的单词。（默认以空格，制表符，回行符）如果最后一个单词已被next（）方法返回，
Scanner对象调用hasNext（）将返回false，否则返回true

对于被解析的字符序列中的数字型单词，例如：618,168.98等等，Scanner对象可以用nextInt()/nextDouble()方法来代替next（）方法

如果单词不是数字型单词，Scanner对象调用nextInt（）/nextDouble方法时会发生InputMismatchException异常，在处理异常时可以调用next()方法返回非数字化单词

/*
*StringTokenizer类和Scanner类都可以分解字符序列的单词，但是二者在思想上有所不同
*/

StringBuffer类

背景：String对象的字符序列是不可修改的，也就是说String对象的字符序列的字符不能被修改，删除，即String对象的实体不可以在发生变化

三个构造方法：
StringBuffer（）
StringBuffer（int size）
StringBuffer（String s）

//常用方法
append（）方法：
将指定的字符序列追加的当前对象的序列中
变量可以是：String，int，Object，long，boolean等等
 
public  char  charAt（int n）//获取n位置上的字符序列字符
public  char  charAt（int n，char ch）//用ch替换n位置上的字符序列字符
 
StringBuffer  insert(int  index,String  str);//将指定字符序列插入到当前对象字符序列中
 
public  StringBuffer  reverse（）//将该对象的实体类中的字符序列翻转，返回当前对象翻转的引用
 
StringBuffer  delete(int startIndex,int endIndex)
 
StringBuffer replace(int startIndex,int  endIndex,String str)

Date类和Calendar类

　　　　　　Date类：

Date  nowTime=new  Date（）；

带参：
Date   date1=new    Date（1000）；
date2=new  Date（-1000）；

　　　　　　

import java.text.SimpleDateFormat;
import java.util.Date;
 
/**
 * @author Mikey
 * @date 2018/10/2 18:48
 */
public class date {
    public static void main(String[] args){
 
        Date now=new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM月dd日HH时mm分");
 
        System.out.println("now time="+simpleDateFormat.format(now));
 
    }
}

　　　　　　Calendar类

Calendar calendar=Calendar.getInstance();//返回一个日历
 
//calendar对象调用public  int  get（int field）可以获取有关年月日小时星期的信息
 
calendar.get(Calendar.MONTH)
calendar.get(Calendar.DAY_OF_WEEK)

日期格式化

format(格式化模式，日期列表）

按照格式模式返回日期列表中所列 的各个日期所含的数据（年月日时）

格式化模式

Date  now=new  Date();
String s1=String.format("%tY年%tm月%td日",now,now,now);
String s2=String.format("%tF",now);
        System.out.println(s1+"//"+s2);

不同区域的星期格式

format（Local local，格式化模式，日期列表）

Math类

Math.Abs() 计算绝对值。  
Math.Acos() 计算反余弦值。  
Math.Asin() 计算反正弦值。  
Math.Atan() 计算反正切值。  
Math.Atan2() 计算从x 坐标轴到点的角度。  
Math.Ceil() 将数字向上舍入为最接近的整数。  
Math.Cos() 计算余弦值。  
Math.Exp() 计算指数值。  
Math.Floor() 将数字向下舍入为最接近的整数。  
Math.Log() 计算自然对数。  
Math.Log10() 计算以10为底的对数。  
Math.Max() 返回两个整数中较大的一个。  
Math.Min() 返回两个整数中较小的一个。  
Math.Pow() 计算x 的y 次方。  
Math.Random() 返回一个0.0 与1.0 之间的伪随机数。  
Math.Round() 四舍五入为最接近的整数。  
Math.Sin() 计算正弦值。  
Math.Sqrt() 计算平方根。  
Math.Tan() 计算正切值。
更多参考api

BigInteger类

 BigInteger abs()
          返回其值是此 BigInteger 的绝对值的 BigInteger。
 BigInteger add(BigInteger val)
          返回其值为 (this + val) 的 BigInteger。
 BigInteger and(BigInteger val)
          返回其值为 (this & val) 的 BigInteger。
 BigInteger andNot(BigInteger val)
          返回其值为 (this & ~val) 的 BigInteger。
 int bitCount()
          返回此 BigInteger 的二进制补码表示形式中与符号不同的位的数量。
 int bitLength()
          返回此 BigInteger 的最小的二进制补码表示形式的位数，不包括 符号位。
 BigInteger clearBit(int n)
          返回其值与清除了指定位的此 BigInteger 等效的 BigInteger。
 int compareTo(BigInteger val)
          将此 BigInteger 与指定的 BigInteger 进行比较。
 BigInteger divide(BigInteger val)
          返回其值为 (this / val) 的 BigInteger。
 BigInteger[] divideAndRemainder(BigInteger val)
          返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。
 double doubleValue()
          将此 BigInteger 转换为 double。
 boolean equals(Object x)
          比较此 BigInteger 与指定的 Object 的相等性。
 BigInteger flipBit(int n)
          返回其值与对此 BigInteger 进行指定位翻转后的值等效的 BigInteger。
 float floatValue()
          将此 BigInteger 转换为 float。
 BigInteger gcd(BigInteger val)
          返回一个 BigInteger，其值是 abs(this) 和 abs(val) 的最大公约数。
 int getLowestSetBit()
          返回此 BigInteger 最右端（最低位）1 比特的索引（即从此字节的右端开始到本字节中最右端 1 比特之间的 0 比特的位数）。
 int hashCode()
          返回此 BigInteger 的哈希码。
 int intValue()
          将此 BigInteger 转换为 int。
 boolean isProbablePrime(int certainty)
          如果此 BigInteger 可能为素数，则返回 true，如果它一定为合数，则返回 false。
 long longValue()
          将此 BigInteger 转换为 long。
 BigInteger max(BigInteger val)
          返回此 BigInteger 和 val 的最大值。
 BigInteger min(BigInteger val)
          返回此 BigInteger 和 val 的最小值。
 BigInteger mod(BigInteger m)
          返回其值为 (this mod m) 的 BigInteger。
 BigInteger modInverse(BigInteger m)
          返回其值为 (this-1 mod m) 的 BigInteger。
 BigInteger modPow(BigInteger exponent, BigInteger m)
          返回其值为 (thisexponent mod m) 的 BigInteger。
 BigInteger multiply(BigInteger val)
          返回其值为 (this * val) 的 BigInteger。
 BigInteger negate()
          返回其值是 (-this) 的 BigInteger。
 BigInteger nextProbablePrime()
          返回大于此 BigInteger 的可能为素数的第一个整数。
 BigInteger not()
          返回其值为 (~this) 的 BigInteger。
 BigInteger or(BigInteger val)
          返回其值为 (this | val) 的 BigInteger。
 BigInteger pow(int exponent)
          返回其值为 (thisexponent) 的 BigInteger。
static BigInteger probablePrime(int bitLength, Random rnd)
          返回有可能是素数的、具有指定长度的正 BigInteger。
 BigInteger remainder(BigInteger val)
          返回其值为 (this % val) 的 BigInteger。
 BigInteger setBit(int n)
          返回其值与设置了指定位的此 BigInteger 等效的 BigInteger。
 BigInteger shiftLeft(int n)
          返回其值为 (this << n) 的 BigInteger。
 BigInteger shiftRight(int n)
          返回其值为 (this >> n) 的 BigInteger。
 int signum()
          返回此 BigInteger 的正负号函数。
 BigInteger subtract(BigInteger val)
          返回其值为 (this - val) 的 BigInteger。
 boolean testBit(int n)
          当且仅当设置了指定的位时，返回 true。
 byte[] toByteArray()
          返回一个 byte 数组，该数组包含此 BigInteger 的二进制补码表示形式。
 String toString()
          返回此 BigInteger 的十进制字符串表示形式。
 String toString(int radix)
          返回此 BigInteger 的给定基数的字符串表示形式。
static BigInteger valueOf(long val)
          返回其值等于指定 long 的值的 BigInteger。
 BigInteger xor(BigInteger val)
          返回其值为 (this ^ val) 的 BigInteger。 

Random类

　　　　　　生成伪随机数

Math类调用random（）返回一个0~1之间的随机数，[0.0,3)（包括0.0不包括1.0）

(int)(Math.random()*100)+1//生成1-100随机数
 
public  Random（）；
public   Random（long  seed）；
 
Random  random=new  Random（）；
random.nextInt();
 
random.nextInt(100);
 
random.nextBoolean();
 
/*
*注意：对于具有相同种子的两个Random对象，二者依次调用nextInt（）方法获取的随机数序列是相同的
*/

数字格式

　　程序可以使用String类调用format方法对数字进行格式化

　　格式化模式：

String  s=String.format("%.2f",3.141858454);

　　值列表：

String    s=String.format("%d元%0.3f公斤%d台”，888,9991.555，100）；

　　格式化顺序：

String    s=String.format("从左到右：%d，%0.3f，%d”，888,9991.555，100）；

　　非格式化顺序：

/*
*如果不希望按照顺序格式，则在格式符前面添加索引符号：index$
*/
 
String s=String.format("不是从左到右：%2$.3f,%3$d,%1$d",x,y,100);

　格式化整数:

%d :将值格式化为十进制
%o :将值格式化为八进制
%x :将值格式化为小写的十六进制
%X :将值格式化为大写的十六进制

修饰符：
+：加号修饰符：格式化整数时，强制添加上正号；例如：%+d将123格式化为+123
, ：逗号修饰符:格式化整数时，按照千分组

数据的宽度：
%md  或者  %-md(在右边添加空格）
如果在宽度前用0，则表示不用空格而采用

格式化浮点数：

%f ：格式化浮点数
%e（%E）：科学计数法表示
%g（%G) ：
%a(%A)  :

　　　　修饰符：同上

　　　　限制宽度与位数

%.nf：n代表保留的小数位数

Class类

/*
*使用Class类得到一个和某类（参数className指定的类）相关的Class对象
*
*/
 
public  static  Class  forName(String className) throws ClassNotFoundException

public Object newInstance() throws IntsantiationException,IllegalAccessExcetion
//实例化一个className对象

Console类

Console  cons=System.console();//

char[]  password=cons.readPassword();//读取键盘输入一行文本，并将文本以一个char数组返回

（模式匹配）Pattern类和Matcher类