//String类常用方法
public int length()//获取String对象的字符序列的长度
n=s.length();

public boolean equals(String s)//判断s1与指定字符序列s2是否相等  
s1==s2//判断的是对象的引用是否相等  
s1.equals(s2);//相等则为true,否则为false

public boolean startsWith(String s)//判断s1前缀是否与指定s相等  
s1.startsWith(s);//相等则为true,否则为false

public boolean endswith(String s)//判断s1后缀是否与指定s相等  
s1.endsWith(s);//相等则为true,否则为false

public int compareTo(String s)//按字典顺序比较s1与s2的序列是否相等，相同返回0，s1>s2返回正数，s1<s2返回负数  
s1.compareTo(s2);

public boolean contains(String s)//判断s1是否包含s2  
s1.contains(s2);//包含则为true,否则为false

public int indexOf(String s)//s1中首次出现s2的下标  
n=s1.indexOf(s2);

public int lastindexOf(String s)//s1中最后一次出现s2的下标  
n=s1.lastindexOf(s2);

public String substring(int startpoint)//复制s1的startpoint到最后位置的序列  
s=s1.substring(2);

public String substring(int start,int end)//复制s1的start到end-1的位置的序列  
s=s1.substring(2,5);

public String trim()//去掉s1的前后空格  
s=s1.trim();

public static int parseInt(String s)//将“数字”字符转换为int型  
n=Interger.parseInt(s);

public static byte parseByte(String s)//类似上一条

public static String valueOf(int n)//将整型转换为Sting s1  
s1=String.valueOf(n);

s=\*\*.toString();//返回该对象的字符表示

public void getChars(int Start,int end,char c\[\],int offest)//将s中从start-(end-1)位置的内容复制到c数组中（从offest位置开始）  
s.getChars(11,15,c,0);

public char\[\] toCharArray()//c数组中对应保存s中的内容  
c=s.toCharArray();

String(byte\[\])//用指定字节数组构造对象  
byte d\[\]="市场的保持".getBytes();//String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组  
String s=new String(d);

String(byte\[\],int offest,int length)//构造方法，从数组起始位置offest开始取length个字节，构造一个对象  
String s=new String(d,6,2);

nextLine()//方法字面上有扫描一整行的意思，它的结束符只能是Enter键，即nextLine()方法返回的是Enter键之前没有被读取的所有字符，它是可以得到带空格的字符串的。

//使用String类对象password的字符序列作为密码对另一个String对象sourceString的字符序列进行加密  
char \[\]p=Password.toCharArray();//将password的字符序列放入到一个字符数组中

正则表达式是一个String对象的字符序列，该字符序列中含有具有特殊意义的字符，这些特殊字符称作正则表达式中的元字符。  
例：“\\\\dcat”中的\\\\d就表示0~9的任何一个  
关于正则表达式可详见：https://www.cnblogs.com/Jansens520/p/6915384.html

java.lang包中的String类，java.util.regex包中的Pattern，Matcher类中都有matches()方法。  
都与正则表达式有关。下面我分别举例：（字符串："abc"，正则表达式： "\[a-z\]{3}"）

String类的方法：  
boolean  b  = "abc".matches("\[a-z\]{3}"  
System.out.println(b);              

Pattern类中的方法：  
boolean  b  = Pattern.matches("\[a-z\]{3}","abc");  
System.out.println(b);              

Matcher类中的方法：  
Pattern p = Pattern.compile("\[a-z\]{3}");  
Matcher m = p.matcher("acc");  
boolean  b  =m.matches()  
System.out.println(b);  
    得到的结果都为true。

public String replaceAll(String regex,String replacement)//s中所有和regex匹配的用replacement替换，返回一个新序列  
s1=s.replaceAll("\[a-aZ-Z\]+","你好");  
\\\\p{Sc}可匹配任何货币的字符串

public String\[\] split(String regex)//分解s,用regex作为分隔标记，将分解出的单词放在String数组中  
//split()方法分解的是分隔标记符左侧的单词，因此如果s的前缀和regex匹配，那么分解出的第一个单词不含任何字符序列  
String d\[\]=s.split(regex);

//StringTokenizer类(java.util包中)
两个构造方法
* StringTokenizer(String s)//默认分隔符
* StringTokenizer(String s,String delim)//以delim为分隔符

nextToken()//逐个获取fenxi中的单词  
String item=fenxi.nextToken();

hasMoreTokens()//还有单词返回true,否则false;  
fenxi.hasMoreTokens();

countTokens()//得到分析器中计数变量的值  
fenxi.countTokens();

//Scanner类  
 \* Scanner scanner =new Scanner(NBA)//为了解析NBA中的单词，可以先构造一个Scanner类对象  
 \* useDelimiter(正则表达式)//将正则表达式作为标记符  
 scanner.useDelimiter("\[^0123456789\]+")//匹配所有非数字字符序列

 //StringBuffer类  
  \* 可以自动改变内存空间的大小  
  \* 三个构造方法  
  \* StringBuffer()//16  
  \* StringBuffer(int size)//size  
  \* StringBuffer(String s)//s+16

  length()//获取实体中存放字符序列长度  
  capacity()//获取当前实体的实际容量

  StringBuffer append(String s)  
  s1.append(s);

  StringBuffer append(int n)//将n转换为String然后追加到s1中  
  s1.append(n);

  StringBuffer append(Object o)  
  s1.append(o);

  public char charAt(int n)//得到s1上位置n的字符  
  char c=s1.charAt(n);

  public void setCharAt(int n,char ch)//将s1位置n上的字符用ch替换  
  s1.setcharAt(n,ch);

  StringBuffer insert(int index,String str)//将str插入s1的指定位置index上  
  s1.insert(index,str);

  public StringBuffer reverse()//将s1的序列翻转  
  s1.reverse();

  StringBuffer delete(int startIndex,int endIndex)//删除startIndex到endIndex-1的序列  
  s1.delete(startIndex,endIndex);

  deleteCharAt(int index)//删除index位置的序列  
  s1.deleteCharAt(index);

  StringBuffer replace(int startIndex,int endIndex,String str)//将s1的位置从startIndex到endIndex-1用str替换  
  s1.replace(startIndex,endIndex,str);

  //Data类  
            两个构造构造方法  
    Data nowtime =new Data();//获取本机时间  
    Data(long time)//time表示毫秒数，正数表示公元前，负数表示公元后  
    Data data1=m=new Data(1000);  
    Data data2=m=new Data(-1000);

  //Calender类（java.util包中）  
   Calendar calendar=Calendar.getInstance();//初始化一个日历对象，getInstance()是Calendar类的一个static方法  
    public int get(int filed)//获取有关年份，月份，小时，星期等信息。filed由Calender的静态常量指定  
       calender.get(Calendar.MONTH);  
       calender.get(Calendar.DAY\_OF\_WEEK);

       pubilc long getTimeInMillis();//返回当前calender对象中时间的毫秒计时  
       calender.getTimeInMillis();

       public final void setTime(Date date);//设置日历的时间为给定的日期 Date  
       calendar.setTime(new Data());

       //可将日历翻到任何一个时间  
       public final void set(int year,int month,int data);  
       public final void set(int year,int month,int data,int hour,int minute);  
       public final void set(int year,int month,int data,int hour,int minute,int second);

//日期的格式化,数字格式化format
* format是String类的一种静态方法，可直接通过类调用
String.format(格式化模式，日期列表);//对日期进行格式化
Date nowtime=new Date();
String s1=String.format("%td<%tY",nowtime);
String s2=String.format("%tF",nowtime);

   String.format(Locale locale,格式化模式，日期列表);  
   String eed=String.format(Locale.US,"%ta(%<tF)%<tH时%<tM分", new Date());

      //Math类  
       \* java.lang包中，用类名进行调用  
       \* E=e,PI=π  
       \* 常见方法  
       \* abs(a),max(a,b) min(a,b)  random()//产生0~1的随机数包括0但不包括1  
       \* pow(a,b)//a的b次幂  
       \* sqrt(a);  
       \* log(a);  
       \* sin(a) asin(a)//反sin  
       \* ceil(a)//返回大于a的最小整数  
       \* floor(a)//返回小于a的最大整数  
       \* round(a)//四舍五入后的值  
       Math.ceil(15.2)=16

       //BigInteger类  
        \* java.math包中  
        \* public String toString()//返回s1的十进制的字符表示  
        s1.toString();  
        \* public String toString(int p)//返回s1的p进制的字符表示  
           s1.toString(p);

           //Random类  
            \* 构造方法  
            \* Random()  
            \* Random(long seed)  
            \* random.nextInt();//返回一个随机整数  
            \* random.nextInt(int m);返回一个0~m的整数，包括0但不包括m  
            \* random.nextBoolean();返回一个随机boolean值  
            \* random.nextDouble();返回一个0.0~1.0的随机数，包括0.0，但不包括1.0     

 //日期的格式化,数字格式化format  
   \* format是String类的一种静态方法，可直接通过类调用  
   String.format(格式化模式，日期列表);//对日期进行格式化  
   Date nowtime=new Date();  
   String s1=String.format("%td<%tY",nowtime);  
   String s2=String.format("%tF",nowtime);

   String.format(Locale locale,格式化模式，日期列表);  
   String eed=String.format(Locale.US,"%ta(%<tF)%<tH时%<tM分", new Date());

      //Math类  
       \* java.lang包中，用类名进行调用  
       \* E=e,PI=π  
       \* 常见方法  
       \* abs(a),max(a,b) min(a,b)  random()//产生0~1的随机数包括0但不包括1  
       \* pow(a,b)//a的b次幂  
       \* sqrt(a);  
       \* log(a);  
       \* sin(a) asin(a)//反sin  
       \* ceil(a)//返回大于a的最小整数  
       \* floor(a)//返回小于a的最大整数  
       \* round(a)//四舍五入后的值  
       Math.ceil(15.2)=16

       //BigInteger类  
        \* java.math包中  
        \* public String toString()//返回s1的十进制的字符表示  
        s1.toString();  
        \* public String toString(int p)//返回s1的p进制的字符表示  
           s1.toString(p);

           //Random类  
            \* 构造方法  
            \* Random()  
            \* Random(long seed)  
            \* random.nextInt();//返回一个随机整数  
            \* random.nextInt(int m);返回一个0~m的整数，包括0但不包括m  
            \* random.nextBoolean();返回一个随机boolean值  
            \* random.nextDouble();返回一个0.0~1.0的随机数，包括0.0，但不包括1.0     

     //Class类  
      \* java.lang包  
      \* public static Class forName(String className)throws ClassNotFoundException  
      \* public Object newInstance() throws InstantiationException,IllegalAccessException  
      例：  
      Class cs=Class.forName(java.util.Date);  
      Date date=(Date)cs.newInstance();