20175215 2018-2019-2 第七周java课程学习总结

第八章 常用实用类

8.1 String类

Java专门提供了用来处理字符序列的String类。String类在java.lang包中，由于java.lang包中的类被默认引入，因此程序可以直接使用String类。
需要注意的是Java把String类声明为final类，因此用户不能扩展String类，即String类不可以有子类。

8.1.1 构造String对象

• 1.常量对象：字符串常量对象是用双引号括起的字符序列，例如："你好"、"12.97"、"boy"等。Java把用户程序中的String常量放入常量池。因为String常量是对象，所以也有自己的引用和实体。
• 2.String对象：可以使用String类声明对象并创建对象，例如：

String  s = new String("we are students");
String  t = new String("we are students");

• 对象变量s中存放着引用，表明自己的实体的位置，即new 运算符首先分配内存空间并在内存空间中放入字符序列，然后计算出引用。
  将引用赋值给字符串对象s后，String对象s的内存模型如下图所示（凡是new运算符构造出的对象都不在常量池）。尽管s和t的实体相同，都是字符序列：we are students，但二者的引用是不同的（如图），即表达式s==t的值是false（new运算符如它名字一样。每次都要开辟新天地）。
  
• 另外，用户无法输出String对象的引用：System.out.println(s);
  输出的是对象的实体，即字符序列we are students。
  也可以用一个已创建的String对象创建另一个String对象，如： String tom = new String(s);
• String类还有两个较常用的构造方法。
  • String (char a[])用一个字符数组a创建一个String对象，如：
      ```
    char a[] = {'J','a','v','a'};
    String s = new String(a);

过程相当于
  String s = new String("Java");
- String(char a[],int startIndex,int count) 提取字符数组a中的一部分字符创建一个String对象，参数startIndex和count分别指定在a中提取字符的起始位置和从该位置开始截取的字符个数，如：

char a[] = {'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'};
String s = new String(a,2,4);

相当于String s = new String("贰叁肆伍");

• 3.引用String常量:String常量是对象，因此可以把String常量的引用赋值给一个String对象，例如:

String s1,s2;   
s1 = "你好";
s2 = "你好";

s1,s2具有相同的引用（12AB），表达式s1==s2的值是true，因而具有相同的实体。s1，s2内存示意如下图所示。

8.1.2 字符串的并置

String对象可以用“+”进行并置运算，即首尾相接得到一个新的String对象。

String  you = "你";
String  hi = "好";
String  testOne;

you和hi进行并置运算you+hi得到一个新的String对象，可以将这个新的String对象的引用赋值给一个String声明的对象： testOne = you+shi;
那么testOne的实体中的字符序列是"你好"。
需要注意的是，参与并置运算的String对象，只要有一个是变量，那么Java就会在动态区存放所得到的新String对象的实体和引用，you+hi相当于new String("你好")。

8.1.3 String类的常用方法

• 1.public int length():获取一个字符串的长度
• 2.public boolean equals(String s):判断当前String对象的字符序列是否与参数s指定的String对象的字符序列相同。
• 3.public boolean startsWith(String s):判断当前String对象的字符序列前缀是否是参数指定的String对象s的字符序列，例如:
  String tom = "天气预报，阴有小雨",jerry = "比赛结果，中国队赢得胜利";
tom.startsWith(“天气”)的值是true；
  tom.endsWith("大雨")的值是false，
• public boolean endsWith(String s)则是判断一个String对象的字符序列后缀是否是String对象s的字符序列。
• 4.public int compareTo(String s):按字典序与参数s指定的字符序列比较大小。
  如果当前String对象的字符序列与s的相同，该方法返回值0，如果大于s的字符序列，该方法返回正值；
  如果小于s的字符序列，该方法返回负值。
  例如，字符a在Unicode表中的排序位置是97，字符b是98，那么对于String str = “abcde”;
str.compareTo(“boy”)小于0，str.compareTo(“aba”)大于0，str.compareTo(“abcde”)等于0。
• 5.public boolean contains(String s):String对象调用contains方法判断当前String对象的字符序列是否包含参数s的字符序列，例如，tom="student"，那么tom.contains("stu")的值就是true，而tom.contains("ok")的值是false。
• 6.public int indexOf (String str):String对象调用方法从当前String对象的字符序列的0索引位置开始检索首次出现str的字符序列的位置，并返回该位置。如果没有检索到，该方法返回的值是–1,其相关方法：
  indexOf(String s ,int startpoint)
lastIndexOf (String s)
  例如:

    String tom = "I am a good cat"；
    tom.indexOf("a");//值是2
    tom.indexOf("good",2);//值是7
    tom.indexOf("a",7);//值是13
    tom.indexOf("w",2);//值是-1

• 7.public String substring(int startpoint):字符串对象调用该方法获得一个新的String对象，新的String对象的字符序列是复制当前String对象的字符序列中的startpoint位置至最后位置上的字符所得到的字符序列。
  String对象调用substring(int start ,int end)方法获得一个新的String对象，新的String对象的字符序列是复制当前String对象的字符序列中的start位置至end–1位置上的字符所得到的字符序列。
• 8.public String trim() :得到一个新的String对象，这个新的String对象的字符序列是当前String对象的字符序列去掉前后空格后的字符序列。

8.1.4 字符串与基本数据的相互转化

Java.lang包中的Integer类调用其类方法：public static int parseInt(String s),可以将由“数字”字符组成的字符串，如“876”，转化为int型数据:

int x; 
String s = “876"; 
x = Integer.parseInt(s); 

类似地,使用java.lang包中的Byte、Short、Long、Float、Double类调相应的类方法可以将由"数字"字符组成的字符串，转化为相应的基本数据类型。如：

         public static byte parseByte(String s) throws NumberFormatException 
         public static short parseShort(String s) throws NumberFormatException
         public static long parseLong(String s) throws NumberFormatException
         public static float parseFloat(String s) throws NumberFormatException
         public static double parseDouble(String s) throws NumberFormatException 

可以使用String 类的类方法

       public static String valueOf(byte n)
       public static String valueOf(int n)
       public static String valueOf(long n)  
       public static String valueOf(float n)
       public static String valueOf(double n)

将形如123、1232.98等数值转化为字符串，如：String str = String.valueOf(12313.9876);

8.1.5 对象的字符串表示

在子类中，所有的类都默认是java.lang包中Object类的子类或间接子类。
Object类有一个public String toString()方法，一个对象通过调用该方法可以获得该对象的字符序列表示。一个对象调用toString()方法返回的String对象的字符序列的一般形式为：创建对象的类的名字@对象的引用的字符串表示

8.1.6 字符串与字符数组、字节数组

• 1.字符串与字符数组
  String 类的构造方法：String(char[])；、String(char[]，int offset，int length)分别用字符数组中的全部字符和部分字符创建String对象。
  将String对象的部分字符序列存放到数组中的方法：public void getChars(int start,int end,char c[],int offset )
  将String对象的字符序列存放到数组中的方法：public char[] toCharArray()。
• 2．字符串与字节数组
  • String(byte[])用指定的字节数组构造一个字符串对象。
  • String(byte[]，int offset，int length) 用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。
  • public byte[] getBytes()使用平台默认的字符编码，将当前String对象的字符序列存放到字节数组，并返回数组的引用。
  • public byte[] getBytes(String charsetName)使用参数指定字符编码，将当前String对象的字符序列存放到字节数组，并返回数组的引用。
• 3.字符串的加密算法
  使用一个String对象password的字符序列作为密码对另一个String对象sourceString的字符序列进行加密，操作过程如下:
  将password的字符序列存放到一个字符数组中，char [] p = password.toCharArray();
  假设数组p的长度为n，那么就将待加密的sourceString的字符序列按顺序以n个字符为一组（最后一组中的字符个数可小于n），对每一组中的字符用数组a的对应字符做加法运算。比如，某组中的n个字符是a0a1…an-1那么按如下方式得到对该组字符的加密结果：
  
  上述加密算法的解密算法是对密文做减法运算

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

• 1．正则表达式:是一个String对象的字符序列，该字符序列中含有具有特殊意义字符，这些特殊字符称做正则表达式中的元字符。比如，"dcat"中的d就是有特殊意义的元字符，代表0到9中的任何一个，"0cat"，"1cat"，"2cat"，…，"9cat"都是和正则表达式"dcat"匹配的字符序列。
  String对象调用public boolean matches(String regex)方法可以判断当前String对象的字符序列是否和参数regex指定的正则表达式匹配。

在正则表达式中可以用方括号括起若干个字符来表示一个元字符，该元字符代表方括号中的任何一个字符。例如String regex = "[159]ABC"，那么"1ABC"、"5ABC"和"9ABC"都是和正则表达式regex匹配的字符序列。例如，[abc]：代表a、b、c中的任何一个；[^abc]：代表除了a、b、c以外的任何字符；[a-zA-Z]：代表英文字母（包括大写和小写）中的任何一个

任何由英文字母，数字或下划线组成的字符序列都和正则表达式[a-zA-Z|0-9|_]+匹配

• 常用元字符及其意义
  

• 常用的限定修饰符的用法
  

• 2．字符串的替换:public String replaceAll(String regex,String replacement)
  String对象调用public String replaceAll(String regex,String replacement)方法返回一个新的String对象，
  这个新的String对象的字符序列是把当前String对象的字符序列中所有和参数regex匹配的子字符序列，用参数replacement的字符序列替换后得到字符序列，例如：String str ="12hello567bird".replaceAll("[a-zA-Z]+","你好");
  那么str的字符序列就是将"12hello567bird"中所有英文字符序列替换为"你好"后得到的字符序列，即str的字符序列是"12你好567你好"。

• 3．字符串的分解：public String[] split(String regex)使用参数指定的正则表达式regex做为分隔标记分解出其中的单词，并将分解出的单词存放在字符串数组中。
  例如，对于：String str = "1949年10月1日是中华人民共和国成立的日子";
  如果准备分解出全部由数字字符组成的单词，就必须用非数字字符串做为分隔标记，因此，可以使用正则表达式：String regex="\D+";作为分隔标记分解出str中的单词：String digitWord[]=str.split(regex);
  那么，digitWord[0]、digitWord[1]和digitWord[2]就分别是“1949”、“10”和“1”。

需要特别注意的是，split方法认为分隔标记的左面应该是单词，因此如果和当前String对象的字符序列的前缀和regex 匹配，那么split(String regex)方法分解出的第一个单词是不含任何字符的字符序列（长度为0的字符序列），即""

8.2 StringTokenizer类

StringTokenizer类在java.util包中，有两个常用的构造方法：

• StringTokenizer（String s）：为String对象s构造一个分析器。使用默认的分隔标记，即空格符、换行符、回车符、Tab符、进纸符做分隔标记。
• StringTokenizer(String s, String delim)为String对象s构造一个分析器。参数delim的字符序列中的字符的任意排列被作为分隔标记。

例如：StringTokenizer fenxi = new StringTokenizer("you#*are*##welcome", "#*"); 
如果指定字符#和字符*是分隔标记，那么字符#和字符*的任意排列，比如，###*#*就是一个分隔标记，即"You#are#*welcome"和"You***#are*#*#welcome"都有三个单词，分别是we，are和welcome。

• StringTokenizer对象称作一个字符串分析器可以使用下列方法：
  • (1)nextToken()：逐个获取字符串中的语言符号（单词），字符串分析器中的负责计数的变量的值就自动减一 。
  • (2)hasMoreTokens()：只要字符串中还有语言符号，即计数变量的值大于0，该方法就返回true，否则返回false。
  • (3)countTokens()：得到分析器中计数变量的值。

8.3 Scanner类

• 1.Scanner对象
  Scanner对象可以解析字符序列中的单词，例如，对于String对象NBA：
  String NBA = "I Love This Game";
  为了解析出NBA的字符序列中的单词，可以如下构造一个Scanner对象。
  Scanner scanner = new Scanner(NBA); 
  Scanner对象可以调用方法:useDelimiter(正则表达式);
  将正则表达式作为分隔标记，即让Scanner对象在解析操作时，把与正则表达式匹配的字符序列作为分隔标记。如果不指定分隔标记，那么Scanner对象默认地用空白字符：空格，制表符，回行符作为分隔标记来解析String对象的字符序列中的单词。
  Scanner将空格做为分隔标记来解析字符序列中的单词，具体解析操作：
  • Scanner对象调用next()方法依次返回NBA中的单词，如果NBA最后一个单词已被next()方法返回，Scanner对象调用hasNext()将返回false，否则返回true。
  • 对于被解析的字符序列中的数字型的单词，比如618，168.98等，Scanner对象可以用nextInt()或nextDouble()方法来代替next()方法，即Scanner对象可以调用nextInt()或nextDouble()方法将数字型单词转化为int或double数据返回。
  • 如果单词不是数字型单词，Scanner对象调用nextInt()或nextDouble()方法将发生InputMismatchException异常，在处理异常时可以调用next()方法返回该非数字化单词。
• 2．使用正则表达式作为分隔标记解析字符串
  Scanner对象可以调用useDelimiter(正则表达式); 方法将一个正则表达式作为分隔标记，即和正则表达式匹配的字符串都是分隔标记。

8.4 StringBuffer类

8.4.1 StringBuffer对象

• String对象的字符序列是不可修改的，也就是说，String对象的字符序列的字符不能被修改、删除，即String对象的实体是不可以再发生变化的，例如，对于
  String s = new String("我喜欢散步");
  如下图所示
  
• StringBuffer类的对象的实体的内存空间可以自动地改变大小，便于存放一个可变的字符序列。比如，对于：
  StringBuffer s = new StringBuffer("我喜欢");
  对象s可调用append方法追加一个字符序列s.append("玩篮球");，如图8.17。
  
• StringBuffer类有三个构造方法：
  • String();
  • StringBuffer(int size);
  • StringBuffer(String s)。

StringBuffer对象可以通过length()方法获取实体中存放的字符序列的长度，通过capacity()方法获取当前实体的实际容量。

8.4.2 StringBuffer类的常用方法。

• 1.append方法
  • StringBuffer append(String s):将String对象s的字符序列追加到当前StringBuffer对象的字符序列中，并返回当前StringBuffer对象的引用
  • StringBuffer append(int n)：将int型数据n转化为String对象，再把该String对象的字符序列追加到当前StringBuffer对象的字符序列中，并返回当前StringBuffer对象的引用
  • StringBuffer append(Object o)：将一个Object对象o的字符序列表示追加到当前StringBuffer对象的字符序列中，并返回当前StringBuffer对象的引用
  • 类似的方法还有：StringBuffer append(long n),StringBuffer append(boolean n),StringBuffer append(float n),StringBuffer append(double n),StringBuffer append(char n)
• 2.public char charAt(int n)和public void setCharAt(int n,char ch)
  • public chat charAt(int n ):得到参数n指定的置上的单个字符
  • public void setCharAt(int n ,char ch):将当前StringBuffer对象实体中的字符串位置n处的字符用参数ch指定的字符替换
• 3.StringBuffer insert(int index,String str)
  • StringBuffer insert(int index, String str) :将参数str指定的字符串插入到参数index指定的位置
• 4.public StringBuffer reverse()
  • public StringBuffer reverse() :将该对象实体中的字符翻转，并返回当前对象的引用。
• 5.StringBuffer delete(int startIndex, int endIndex)
  • StringBuffer delete(int startIndex, int endIndex):从当前StringBuffer对象实体中的字符串中删除一个子字符串
  • 其相关方法:deleteCharAt(int index) 删除当前StringBuffer对象实体的字符串中index位置处的一个字符。
• 6.StringBuffer replace(int startIndex,int endIndex,String str)
  • StringBuffer replace(int startIndex,int endIndex,String str):将当前StringBuffer对象实体中的字符串的一个子字符串用参数str指定的字符串替换。

8.5 Date类与Calendar类

Date类和Calendar类在java.util包中。

8.5.1 Date类

• 1.使用无参数构造方法
  使用Date类的无参数构造方法创建的对象可以获取本地当前时间。
  例： Date nowTime=new Date();
  当前nowTime对象中含有的日期、时间就是创建nowTime对象时的本地计算机的日期和时间。
  例如，假设当前时间是：2011年3月10日23:05:32（CST时区），那么System.out.println(nowTime); 输出结果是：Thu Mar 10 23:05:32 CST 2011。

Date对象表示时间的默认顺序是：星期、月、日、小时、分、秒、年。

• 2.使用带参数的构造方法
  计算机系统将其自身的时间的“公元”设置在1970年1月1日0时（格林威治时间），可以根据这个时间使用Date的带参数的构造方法：Date(long time)来创建一个Date对象，
  例如：

Date date1=new Date(1000), 
date2=new Date(-1000);

其中的参数取正数表示公元后的时间，取负数表示公元前的时间，其中1000表示1000毫秒，那么，date1含有的日期、时间就是计算机系统公元后1秒时刻的日期、时间。
如果运行Java程序的本地时区是北京时区（与格林威治时间相差8个小时），那么上述date1就是1970年01月01日08时00分01秒、date2就是1970年01月01日07时59分59秒。

System类的静态方法 public long currentTimeMillis() 获取系统当前时间。

8.5.2 Calendar类

• 使用Calendar类的static方法 getInstance()可以初始化一个日历对象，
  如：Calendar calendar= Calendar.getInstance();
• calendar对象可以调用方法：
  • public final void set(int year,int month,int date)
  • public final void set(int year,int month,int date,int hour,int minute)
  • public final void set(int year,int month, int date, int hour, int minute,int second)
    以上三个方法的作用是将日历翻到任何一个时间
  • public long getTimeInMillis() 可以将时间表示为毫秒。
  • public final void setTime(Date date)使用给定的Date设置此Calendar的时间
  • public int get(int field) ：可以获取有关年份、月份、小时、星期等信息
    • 例如：calendar.get(Calendar.MONTH); 返回一个整数，如果该整数是0表示当前日历是在一月，该整数是1表示当前日历是在二月等。
    • 例如：calendar.get(Calendar.DAY_OF_WEEK);返回一个整数，如果该整数是1表示星期日，如果是2表示是星期一，依次类推，如果是7表示是星期六

8.6 日期的格式化

可以直接使用String类调用format方法对日期进行格式化。

8.6.1 format方法

• Formatter类的format方法：
  format(格式化模式, 日期列表)
  按着“格式化模式”返回“日期列表”中所列各个日期中所含数据（年，月，日，小时等数据）的字符串表示。

Java已经将format方法做为了String类的静态方法，因此，程序可以直接使用String类调用format方法对日期进行格式化。

• 1.格式化模式
  format方法中的“格式化模式”是一个用双引号括起的字符序列（字符串）,该字符序列中的字符由时间格式符和普通字符所构成。例如："日期:%ty-%tm-%td"
String s = String.format("%tY年%tm月%td日",new Date(),new Date(),new Date()); 那么s就是"2011年02月10日"
• 2.日期列表
  • format方法中的“日期列表”可以是用逗号分隔的Calendar对象或Date对象。
  • format方法默认按从左到右的顺序使用“格式化模式”中的格式符来格式“日期列表”中对应的日期，而“格式化模式”中的普通字符保留原样。
• 3.格式化同一日期
  可以在“格式化模式”中使用“<”，比如："%ty-%<tm-%<td"中的三个格式符将格式化同一日期，即含有“<”的格式符和它前面的格式符格式同一个日期，例如：String s = String.format("%ty年%<tm月%<td日",new Date());
  那么%<tm和%<td都格式化new Date()，因此字符串s就是："11年02月10日"。

8.6.2 不同区域的星期格式

如果想用特定地区的星期格式来表示日期中的星期，可以用format的重载方法：
format (Locale locale,格式化模式,日期列表);
其中的参数locale是一个Locale类的实例，用于表示地域。
Locale类的static常量都是Locale对象，其中US是表示美国的static常量。

8.7 Math类、BigInteger类和Random类

8.7.1 Math类

Math类在java.lang包中。Math类包含许多用来进行科学计算的类方法，这些方法可以直接通过类名调用。
另外，Math类还有两个静态常量，它们分别是：
E 2.7182828284590452354和PI 3.14159265358979323846。
以下是Math类的常用类方法：

• public static long abs(double a) 返回a的绝对值。
• public static double max(double a,double b) 返回a、b的最大值。
• public static double min(double a,double b) 返回a、b的最小值。
• public static double random() 产生一个0到1之间的随机数（不包括0和1）。
• public static double pow(double a,double b) 返回a的b次幂。
• public static double sqrt(double a) 返回a的平方根。
• public static double log(double a) 返回a的对数。
• public static double sin(double a) 返回正弦值。
• public static double asin(double a) 返回反正弦值。
• public static double ceil(double a) 返回大于a的最小整数，并将该整数转化为double型数据。
• public static double floor(double a) 返回小于a的最大整数，并将该整数转化为double型数据。
• public static long round(double a) 返回值是(long)Math.floor(a+5),即所谓a的“四舍五入”后的值。

8.7.2 BigInteger类

java.math包中的BigInteger类提供任意精度的整数运算。可以使用构造方法：
public BigInteger(String val) 构造一个十进制的BigInteger对象。
以下是BigInteger类的常用类方法：

• public BigInteger add(BigInteger val) 返回当前大整数对象与参数指定的大整数对象的和。
• public BigInteger subtract(BigInteger val)返回当前大整数对象与参数指定的大整数对象的差。
• public BigInteger multiply(BigInteger val)返回当前大整数对象与参数指定的大整数对象的积。
• public BigInteger divide(BigInteger val)返回当前大整数对象与参数指定的大整数对象的商。
• public BigInteger remainder(BigInteger val)返回当前大整数对象与参数指定的大整数对象的余。
• public int compareTo(BigInteger val) 返回当前大整数对象与参数指定的大整数的比较结果，返回值是1、-1或0，分别表示当前大整数对象大于、小于或等于参数指定的大整数。
• public BigInteger pow(int a) 返回当前大整数对象的a次幂。
• public String toString() 返回当前大整数对象十进制的字符串表示。
• public String toString(int p) 返回当前大整数对象p进制的字符串表示。

8.7.3 Random类

Random类的如下构造方法：

public Random();
public Random(long seed);

第一个构造方法使用当前及其实践作为种子创建一个Random对象，第二个构造方法使用参数seed指定的种子创建一个Random对象。
随机数生成器random调用不带参数的nextInt()方法：

Random random=new Random();
random.nextInt();

返回一个0至n之间（包括0，但不包括n）的随机数
随机数生成器random调用带参数的nextInt(int m)方法（参数m必须取正整数值）

8.8 数字格式化

8.8.1 format方法

Formatter类提供了一个和C语言printf函数类似的format方法：format（格式化模式,值列表）
该方法按着“格式化模式”返回“值列表”的字符串表示。
Java已经将format方法做为了String类的静态方法，因此，程序可以直接使用String类调用format方法对数字进行格式化。

• 1.格式化模式：format方法中的“格式化模式”是一个用双引号括起的字符序列(字符串),该字符序列中的字符由格式符和普通字符所构成。
  例如："输出结果%d,%f,%d"中的%d和%f是格式符号。
  format方法返回的字符串就是“格式化模式”中的格式符被替换为它得到的格式化结果后的字符串。
  例如：String s = String.format(“%.2f”,3.141592);那么s就是“3.14”.
• 2.值列表：format方法中的“值列表”是用逗号分隔的变量、常量或表达式。 例如：
  String s=format("%d元%0.3f公斤%d台",888,999.777666,123); 那么,s就是"888元999.778公斤123台"。
• 3.格式化顺序：format方法默认按从左到右的顺序使用“格式化模式”中的格式符来格式化“值列表”中对应的值，而“格式化模式”中的普通字符保留原样。
  例如，假设int型变量x和double型变量y的值分别是888和3.1415926，
  那么对于String s = format("从左向右：%d,%.3f,%d",x,y,100);
  字符串s就是：从左向右：888,3.142,100

• 注1：改变默认的顺序（从左向右）进行格式化，在格式符前面添加索引符号index$，例如，1$表示“值列表”中的第1个,2$表示“值列表”中的第2个,
  对于：String s=String.format(“不是从左向右：%2$.3f,%3$d,%1$d”,x,y,100);
  字符串s就是:不是从左向右：3.142,100,888
• 注2：如果准备在“格式化模式”中包含普通的%，在编写代码时需要连续键入两个%，如：
  String s=String.format("%d%%",89); 输字符串s是："89%"

8.8.2 格式化整数

• 1.%d、%o、%x和%X
  格式符可格式化byte、Byte、short、Short、int、Integer、long和Long型数据。
• 2.修饰符
  • 加号修饰符"+"格式化正整数时，强制添加上正号,例如，%+d将123格式化为"+123"。
  • 逗号修饰符“,”格式化整数时,按"千"分组。
• 3.数据的宽度
  数据的宽度就是format方法返回的字符串的长度。规定数据宽度的一般格式为“%md”,其效果是在数字的左面增加空格;或"%-md“,其效果是在数字的右面增加空格,
  例如，将数字59格式化为宽度为8的字符串：String s=String.format("%8d",59);
  字符串s就是：“ 59"，其长度（s.length()）为8，即s在59左面添加了6个空格字符。
  • 对于：String s=String.format(“%-8d”,59);字符串s就是："59 ",其长度(s.length())为8。
  • 对于：String s=String.format("%5d%5d%8d",59,60,90);字符串s就是：“59 60 90”(长度为18)。

注：如果实际数字的宽度大于格式中指定的宽度，就按数字的实际宽度进行格式化。
可以在宽度的前面增加前缀0,表示用数字0（不用空格）来填充宽度左面的富裕部分，例如：String s=String.format("%08d",12);字符串s就是："00000012"，其长度（s.length()）为8，即s在12的左面添加了6个数字0。

8.8.3 格式化浮点数

• 1.float,Float,double和Double
%f,%e(%E),%g(%G)和%a(%A)格式符可格式化float、Float、double和Double:
  • %f将值格式化为十进制浮点数，小数保留6位。
  • %e（%E） 将值格式化为科学记数法的十进制的浮点数（%E在格式化时将其中的指数符号大写，例如5E10）。
• 2.修饰符
  • 加号修饰符"+"格式化正数时,强制添加上正号,例如%+f将123.78格式化为"+123.78", %+E将123.78格式化为"+1.2378E+2"。
  • 逗号修饰符“,”格式化浮点数时,将整数部分按“千”分组。
• 3.限制小数位数与数据的“宽度”
  "%.nf"可以限制小数的位数,其中的n是保留的小数位数,例如%.3f将6.1256格式化为"6.126"（保留3位小数）。
  规定宽度的一般格式为“%mf”(在数字的左面增加空格),或“%-md”(在数字的右面增加空格)。

注：如果实际数字的宽度大于格式中指定的宽度，就按数字的实际宽度进行格式化

8.9 Class类与Console类

8.9.1 Class类

• 1．使用Class的类方法得到一个和某类（参数className指定的类）相关的Class对象:
  public static Class forName(String className) throws ClassNotFoundException  
  上述方法返回一个和参数className指定的类相关的Class对象。如果类在某个包中，className必须带有包名，例如, className="java.util.Date"。
• 2．步骤1中获得的Class对象调用
  public Object newInstance() throws Exception方法就可以得到一个className类的对象。
  要特别注意的是：使用Class对象调用newInstance()实例化一个className类的对象时，className类必须有无参数的构造方法。

8.9.2 Console类

如果希望在键盘输入一行文本，但不想让该文本回显，即不在命令行显示，那么就需要使用java.io包中的Console类的对象来完成。
首先使用System类调用console()方法返回一个Console类的一个对象，比如cons：
Console cons = System.console();
然后，cons调用readPassword()方法读取用户在键盘输入的一行文本，并将文本以一个char数组返回：
char[] passwd = cons.readPassword();

8.10 Pattern类与Matcher类

Pattern类和Matcher类在java.util.regex包中。
以下结合具体问题来讲解使用Pattern类和Matcher类的步骤。假设有字符串：
String input = "hello,good morning,this is a good idea"
我们想知道input从哪个位置开始至哪个位置结束曾出现了字符串good。
使用Pattern类和Matcher类检索字符串str中的子字符串的步骤如下：

• 1．建立模式对象
  使用正则表达式regex做参数得到一个称为模式的Pattern类的实例pattern：
  例如：

String regex = "good";
Pattern pattern = Pattern.compile(regex); 

模式对象是对正则表达式的封装。Pattern类调用类方法compile(String regex)返回一个模式对象，其中的参数regex是一个正则表达式, 称为模式对象使用的模式。

• 2．得到匹配对象
  模式对象pattern调用matcher(CharSequence input)方法返回一个Matcher对象matcher，称为匹配对象
  Matcher matcher = pattern.matcher(input);
  Matcher对象matcher可以使用下列方法寻找字符串input中是否有和模式regex匹配的子序列（regex是创建模式对象pattern时使用的正则表达式）。
  • public boolean find():寻找input和regex匹配的下一子序列，如果成功该方法返回true，否则返回false。
  • public boolean matches()：matcher调用该方法判断input是否完全和regex匹配。
  • public boolean lookingAt()：matcher调用该方法判断从input的开始位置是否有和regex匹配的子序列。
  • public boolean find(int start) : matcher调用该方法判断input从参数start指定位置开始是否有和regex匹配的子序列 。
  • public String replaceAll(String replacement)： matcher调用该方法可以返回一个字符串,该字符串是通过把input中与模式regex匹配的子字符串全部替换为参数replacement指定的字符串得到的.
  • public String replaceFirst(String replacement)： matcher调用该方法可以返回一个字符串，该字符串是通过把input中第1个与模式regex匹配的子字符串替换为参数replacement指定的字符串得到的。

SP.学习过程中碰到的问题以及解决方案

1.问题：命令行中从VM options中输入数据之后，程序运行结果出现乱码

解决方案：输入位置错误，应为Program arguments。