Java学习——blog 5

目录

常用实用类

String类

创建字符串

字符串长度

连接字符串

String常用方法

StringTokenizer类

方法

详细解析

Scanner类

next() 与 nextLine() 区别

StringBuffer类

StringBuffer方法

Date类与Calendar类

Date类

Calendar类

Calendar对象和Date对象之间的互转

Date个Calendar对象之间的转换

日期的格式化

DateFormat 类

SimpleDateFormat 类

Math类、BigInteger类和Random类

Math类

BigInteger类

Random类

数字格式化

NumberFormat表示数字的格式化类

DecimalFormat格式化数字

ChoiceFormat格式化数字

Class类与Console类（待补充）

Class

Console类

Pattern类与Matcher类

概述

Pattern类

Matcher类

知识点小结

参考

---

常用实用类

• String类

创建字符串

final类，不能扩展

1.常量对象：放入常量池

“你好”

2.String对象：动态区，非常量池，堆

String s = new String("你好“）；//s存放引用

构造方法：

String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

char a[]={‘J’,‘A’,‘V’,‘A’};

String s = new String(a);

or

String s = new String(a,0,1);//J

3.引用常量对象

String s,s2;

s = “你好”;

s2 = “你好”;

s,s2具有相同引用s==s2为true

Tips：String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。

如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。

字符串长度

用于获取有关对象的信息的方法称为访问器方法。

String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。

public class StringDemo {
    public static void main(String args[]) {
        String site = "www.CSDN.net";
        int len = site.length();
        System.out.println( "网址长度 : " + len );//    len=12
   }
}

连接字符串

String 类提供了连接两个字符串的方法：

（1）string1.concat(string2);

返回 string2 连接 string1 的新字符串。也可以对字符串常量使用 concat() 方法，如：

"我的名字是 ".concat("CSDNxiaowang");

（2）更常用的是使用'+'操作符来连接字符串，如：

"Hello," + " CSDNxiaowang" + "!"

结果:        "Hello, CSDNxiaowang!"

String常用方法

public int length();
public bolean equals();
public boolean startsWith(String s);
public int compare(String s）
public Booleancontains(String s)
public int indexOf(String s)/lastIndexOf(String s）
public String subString（int start,int end）
public String trim()
public void getChars(int start,int end,cha ch[],int offset)//将当前String对象字符串序列一部分复制到c数据中
public char[] toCharArray()
public byte[] getBytes(String charsetName)//使用参数指定字符编码

 详情参考：String (Java SE 11 & JDK 11 ) (runoob.com)

• StringTokenizer类

StringTokenizer是一个用来分隔String的应用类。

方法

1.构造函数

• public StringTokenizer(String str)
• public StringTokenizer(String str, String delim)
• public StringTokenizer(String str, String delim, boolean returnDelims)

第一个参数就是要分隔的String，第二个是分隔字符集合，第三个参数表示分隔符号是否作为标记返回，如果不指定分隔字符，默认的是：”\t\n\r\f”

Tips:分隔标记的任意组合仍然是分隔标记
2.核心方法

• public boolean hasMoreTokens()
• public String nextToken()
• public String nextToken(String delim)
• public int countTokens()

其实就是三个方法，返回分隔字符块的时候也可以指定分割符，而且以后都是采用最后一次指定的分隔符号。
3.多余方法

• public boolean hasMoreElements()
• public boolean hasMoreElements()

这个类实现了Enumeration接口，所以多了这么两个方法，其实根本没有必要实现这个接口
它的名字就叫StringTokenizer，返回一个Object就没有什么意思了。

属于：Java.util包。

详细解析

１、构造函数。

• StringTokenizer(String str)：构造一个用来解析str的StringTokenizer对象。java默认的分隔符是“空格”、“制表符(‘\t’)”、“换行符(‘\n’)”、“回车符(‘\r’)”。
• StringTokenizer(String str, String delim)：构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符。
• StringTokenizer(String str, String delim, boolean returnDelims)：构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符，同时，指定是否返回分隔符。

２、方法。
说明：
1. 所有方法均为public；
2. 书写格式：［修饰符］　<返回类型><方法名（［参数列表］）>

一个StringTokenizer对象称为一个字符串分析器，字符串分析器使用nextToken()方法逐个获取字符串中的语言符号（单词），每当调用nextToken()时，都将在字符串中获得下一个语言符号，每当获得一个语言符号时，字符串分析器负责计数的变量的值就自动减一，该计数变量的初始值等于字符串中的单词数目

通常用while循环逐个获取语言符号，为了控制循环，可以使用StringTokenizer类中的hasMoreTokens()方法，只要字符串中还有语言符号，即计数变量的值大于0，该方法就返回true，否则就false.

如：

• static int parseInt(String s)表示：此方法（parseInt）为类方法（static），返回类型为（int），方法所需参数为String类型。
• 1. int countTokens()：返回nextToken方法被调用的次数。如果采用构造函数1和2，返回的就是分隔符数量(例2)。
• 2. boolean hasMoreTokens() ：返回是否还有分隔符。
• 3. boolean hasMoreElements() ：结果同2。
• 4. String nextToken()：返回从当前位置到下一个分隔符的字符串。
• 5. Object nextElement() ：结果同4。
• 6. String nextToken(String delim)：与4类似，以指定的分隔符返回结果。

例如：

String s = new String("The=Java=platform=is=the=ideal=platform=for=network=computing");
StringTokenizer st = new StringTokenizer(s,"=",true);
System.out.println( "Token Total: " + st.countTokens() );
while( st.hasMoreElements() ){
System.out.println( st.nextToken() );}
/*
结果为：
Token Total: 19
The
=
Java
=
platform
=
is
=
the
=
ideal
=
platform
=
for
=
network
=
computing
*/

• Scanner类

Scanner的导包

import java.util.Scanner;

将正则表达式作为分割标记

Scanner scanner = new Scanner(“你好“);
s.useDelimiter(”[^012456789.]+");

下面是创建 Scanner 对象的基本语法：

Scanner s = new Scanner(System.in);

接下来我们演示一个最简单的数据输入，并通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据：

        //    使用next方法
import java.util.Scanner; 
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
 
        // next方式接收字符串
        System.out.println("next方式接收：");
        // 判断是否还有输入
        if (scan.hasNext()) {
            String str1 = scan.next();
            System.out.println("输入的数据为：" + str1);
        }
        scan.close();
    }
}
/*
执行以上程序输出结果为：

$ javac ScannerDemo.java
$ java ScannerDemo
next方式接收：
runoob com
输入的数据为：runoob
*/

        //    使用nextLine方法
import java.util.Scanner;
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
 
        // nextLine方式接收字符串
        System.out.println("nextLine方式接收：");
        // 判断是否还有输入
        if (scan.hasNextLine()) {
            String str2 = scan.nextLine();
            System.out.println("输入的数据为：" + str2);
        }
        scan.close();
    }
}
/*
执行以上程序输出结果为：

$ javac ScannerDemo.java
$ java ScannerDemo
nextLine方式接收：
runoob com
输入的数据为：runoob com

*/

next() 与 nextLine() 区别

next():

• 1、一定要读取到有效字符后才可以结束输入。
• 2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
• 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
• next() 不能得到带有空格的字符串。

nextLine()：

• 1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
• 2、可以获得空白。

如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取.

• StringBuffer类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

StringBuffer方法

以下是 StringBuffer 类支持的主要方法：

序号	方法描述
1	public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2	public StringBuffer reverse()  将此字符序列用其反转形式取代。
3	public delete(int start, int end) 移除此序列的子字符串中的字符。
4	public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。
5	insert(int offset, String str) 将 str 参数的字符串插入此序列中。
6	replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。

以下列表列出了 StringBuffer 类的其他常用方法：

序号	方法描述
1	int capacity() 返回当前容量。
2	char charAt(int index) 返回此序列中指定索引处的 char 值。
3	void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。
4	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。
5	int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。
6	int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
7	int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。
8	int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。
9	int length()  返回长度（字符数）。
10	void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。
11	void setLength(int newLength) 设置字符序列的长度。
12	CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。
13	String substring(int start) 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
14	String substring(int start, int end) 返回一个新的 String，它包含此序列当前所包含的字符子序列。
15	String toString() 返回此序列中数据的字符串表示形式。

更多内容：

• StringBuffer 类：StringBuffer
• StringBuilder 类：StringBuilder

• Date类与Calendar类

Date类

 Date类对象的创建：

1、创建一个当前时间的Date对象

//创建一个代表系统当前日期的Date对象

  Date d = new Date();

2、创建一个我们指定的时间的Date对象：

使用带参数的构造方法Date(int year, int month, int day) ，可以构造指定日期的Date类对象，Date类中年份的参数应该是实际需要代表的年份减去1900，实际需要代表的月份减去1以后的值。

//创建一个代表2022年2月5号的Date对象

Date d1 = new Date(2022-1900, 2-1, 5); （注意参数的设置）

3、正确获得一个date对象所包含的信息

如：

    Date d2 =  new Date(2022-1900, 2-1, 5);

        //获得年份 （注意年份要加上1900，这样才是日期对象d2所代表的年份）

        int year = d2.getYear() + 1900;

        //获得月份  （注意月份要加1，这样才是日期对象d2所代表的月份）

        int month = d2.getMonth() + 1;

        //获得日期

        int date = d2.getDate();

        //获得小时

        int hour = d2.getHours();//不设置默认为0

        //获得分钟

        int minute = d2.getMinutes();

        //获得秒

        int second = d2.getSeconds();

   //获得星期 （注意：0代表星期日、1代表星期1、2代表星期2，其他的一次类推了）

int day = d2.getDay();

// 创建日期对象，把当前的时间
System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018
// 创建日期对象，把当前的毫秒值转成日期对象
System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
//把日期对象转换成对应的时间毫秒值。
public long getTime() 
//用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
public SimpleDateFormat(String pattern)
//将Date对象格式化为字符串。
public String format(Date date)
//将字符串解析为Date对象。
public Date parse(String source)



import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把Date对象转换成String
*/
public class Demo03DateFormatMethod {
    public static void main(String[] args) {
        Date date = new Date();
        // 创建日期格式化对象,在获取格式化对象时可以指定风格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2008年1月23日
    }
}

Calendar类

 Calendar类的功能要比Date类强大很多，可以方便的进行日期的计算,获取日期中的信息时考虑了时区等问题。而且在实现方式上也比Date类要复杂一些

1、Calendar类对象的创建

   Calendar类是一个抽象类，由于Calendar类是抽象类，且Calendar类的构造方法是protected的，所以无法使用Calendar类的构造方法来创建对象，API中提供了getInstance方法用来创建对象。

2、创建一个代表系统当前日期的Calendar对象

 Calendar c = Calendar.getInstance();//默认是当前日期

3、创建一个指定日期的Calendar对象

使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。

//创建一个代表2014年5月9日的Calendar对象

Calendar c1 = Calendar.getInstance();

c1.set(2022, 2 - 1, 5)；//调用：public final void set(int year,int month,int date)

4、Calendar类对象信息的设置与获得

 1）Calendar类对象信息的设置

 A、Set设置

       如：Calendar c1 = Calendar.getInstance();

       调用：public final void set(int year,int month,int date)

   c1.set(2014, 6- 1, 9);//把Calendar对象c1的年月日分别设这为：2014、6、9

  B、利用字段类型设置

  如果只设定某个字段，例如日期的值，则可以使用public void set(int field,int value)

 //把 c1对象代表的日期设置为10号，其它所有的数值会被重新计算

     c1.set(Calendar.DATE,10);

 //把c1对象代表的年份设置为2014年，其他的所有数值会被重新计算

     c1.set(Calendar.YEAR,2015);

 其他字段属性set的意义以此类推

Calendar类中用一下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想

Calendar.YEAR——年份

Calendar.MONTH——月份

Calendar.DATE——日期

Calendar.DAY_OF_MONTH——日期，和上面的字段意义相同

Calendar.HOUR——12小时制的小时

Calendar.HOUR_OF_DAY——24小时制的小时

Calendar.MINUTE——分钟

Calendar.SECOND——秒

Calendar.DAY_OF_WEEK——星期几

 C、Add设置(可用与计算时间)

  Calendar c1 = Calendar.getInstance();

 //把c1对象的日期加上10，也就是c1所表的日期的10天后的日期，其它所有的数值会被重新计算

  c1.add(Calendar.DATE, 10);

 //把c1对象的日期加上-10，也就是c1所表的日期的10天前的日期，其它所有的数值会被重新计算

 c1.add(Calendar.DATE, -10);

 其他字段属性的add的意义以此类推

2）、Calendar类对象信息的获得(使用get（）)

 Calendar c1 = Calendar.getInstance();

// 获得年份

int year = c1.get(Calendar.YEAR);

// 获得月份

int month = c1.get(Calendar.MONTH) + 1;（MONTH+1）

// 获得日期

int date = c1.get(Calendar.DATE);

// 获得小时

int hour = c1.get(Calendar.HOUR_OF_DAY);

// 获得分钟

int minute = c1.get(Calendar.MINUTE);

// 获得秒

int second = c1.get(Calendar.SECOND);

// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）

int day = c1.get(Calendar.DAY_OF_WEEK);

Calendar对象和Date对象之间的互转

//1 .将Calendar对象转换为Date(c.getTime())
Calendar c = Calendar.getInstance();
Date d = c.getTime();
// 2.将Date转换为Calendar对象(s.setTime(date))
Calendar c1 = Calendar.getInstance();
Date d1 = new Date();
//通过setTime（）方法后，日历c1所表示的日期就d1的日期
c1.setTime(d1);

Date个Calendar对象之间的转换

//1.Date 转化为Calendar
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
//2.Calenda转换为Date
 Calendar calendar = Calendar.getInstance();
 Date date =calendar.getTime();

• 日期的格式化

格式化日期表示将日期/时间格式转换为预先定义的日期/时间格式。例如将日期“Fri May 18 15:46:24 CST2016” 格式转换为 “2016-5-18 15:46:24 星期五”的格式。
在 Java 中，可以使用 DateFormat 类和 SimpleDateFormat 类来格式化日期。

DateFormat 类

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期→文本）、解析（文本→日期）和标准化日期。

在创建 DateFormat 对象时不能使用 new 关键字，而应该使用 DateFormat 类中的静态方法 getDateInstance()，示例代码如下：

DateFormat df = DateFormat.getDatelnstance();

在创建了一个 DateFormat 对象后，可以调用该对象中的方法来对日期/时间进行格式化。

DateFormat类的常用方法如下：

方法	描述
String format(Date date)	将 Date 格式化日期/时间字符串
Calendar getCalendar()	获取与此日期/时间格式相关联的日历
static DateFormat getDateInstance()	获取具有默认格式化风格和默认语言环境的日期格式
static DateFormat getDateInstance(int style)	获取具有指定格式化风格和默认语言环境的日期格式
static DateFormat getDateInstance(int style, Locale locale)	获取具有指定格式化风格和指定语言环境的日期格式
static DateFormat getDateTimeInstance()	获取具有默认格式化风格和默认语言环境的日期/时间 格式
static DateFormat getDateTimeInstance(int dateStyle,int timeStyle)	获取具有指定日期/时间格式化风格和默认语言环境的 日期/时间格式
static DateFormat getDateTimeInstance(int dateStyle,int timeStyle,Locale locale)	获取具有指定日期/时间格式化风格和指定语言环境的 日期/时间格式
static DateFormat getTimeInstance()	获取具有默认格式化风格和默认语言环境的时间格式
static DateFormat getTimeInstance(int style)	获取具有指定格式化风格和默认语言环境的时间格式
static DateFormat getTimeInstance(int style, Locale locale)	获取具有指定格式化风格和指定语言环境的时间格式
void setCalendar(Calendar newCalendar)	为此格式设置日历
Date parse(String source)	将给定的字符串解析成日期/时间

格式化样式主要通过 DateFormat 常量设置。将不同的常量传入到表 1 所示的方法中，以控制结果的长度。DateFormat 类的常量如下。

• SHORT：完全为数字，如 12.5.10 或 5:30pm。
• MEDIUM：较长，如 May 10，2016。
• LONG：更长，如 May 12，2016 或 11:15:32am。
• FULL：是完全指定，如 Tuesday、May 10、2012 AD 或 11:l5:42am CST。

SimpleDateFormat 类

如果使用 DateFormat 类格式化日期/时间并不能满足要求，那么就需要使用 DateFormat 类的子类——SimpleDateFormat。

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类，它允许进行格式化（日期→文本）、解析（文本→日期）和规范化。SimpleDateFormat 使得可以选择任何用户定义的日期/时间格式的模式。

SimpleDateFormat 类主要有如下 3 种构造方法：

• SimpleDateFormat()：用默认的格式和默认的语言环境构造 SimpleDateFormat。
• SimpleDateFormat(String pattern)：用指定的格式和默认的语言环境构造 SimpleDateF ormat。
• SimpleDateFormat(String pattern,Locale locale)：用指定的格式和指定的语言环境构造 SimpleDateF ormat。

SimpleDateFormat 自定义格式中常用的字母及含义与示例如下：

字母	含义	示例
y	年份。一般用 yy 表示两位年份，yyyy 表示 4 位年份	使用 yy 表示的年扮，如 11； 使用 yyyy 表示的年份，如 2011
M	月份。一般用 MM 表示月份，如果使用 MMM，则会 根据语言环境显示不同语言的月份	使用 MM 表示的月份，如 05； 使用 MMM 表示月份，在 Locale.CHINA 语言环境下，如“十月”；在 Locale.US 语言环境下，如 Oct
d	月份中的天数。一般用 dd 表示天数	使用 dd 表示的天数，如 10
D	年份中的天数。表示当天是当年的第几天， 用 D 表示	使用 D 表示的年份中的天数，如 295
E	星期几。用 E 表示，会根据语言环境的不同， 显示不 同语言的星期几	使用 E 表示星期几，在 Locale.CHINA 语 言环境下，如“星期四”；在 Locale.US 语 言环境下，如 Thu
H	一天中的小时数（0~23)。一般用 HH 表示小时数	使用 HH 表示的小时数，如 18
h	一天中的小时数（1~12)。一般使用 hh 表示小时数	使用 hh 表示的小时数，如 10 (注意 10 有 可能是 10 点，也可能是 22 点）
m	分钟数。一般使用 mm 表示分钟数	使用 mm 表示的分钟数，如 29
s	秒数。一般使用 ss 表示秒数	使用 ss 表示的秒数，如 38
S	毫秒数。一般使用 SSS 表示毫秒数	使用 SSS 表示的毫秒数，如 156

• Math类、BigInteger类和Random类

Math类

public static long abs(double s):返回a的绝对值

public static double max(double a,doublce b):返回a,b 的最大值

public static  double pow(double a,double b):返回a的b次幂

public sqrt(double a)返回a的平方根

public  log(double a）返回对数

public dobule ceil(a)

public round(a);四舍五入的值

  //Math类
      double a=10.0;
      double sum=Math.pow(a,2);
      System.out.println(sum);
      sum=Math.log(a);
      System.out.println(sum);
      sum=Math.sqrt(a);
      System.out.println(sum);

BigInteger类

程序如果需要处理特别大的整数，就可以用java.math包中的BigInteger类的对象。可以使用构造方法public BigInteger(String val)构造一个十进制的BigInteger对象。该构造方法可以发生异常。String 必须是合法字符。

常用方法：
public BigInteger add(BigInteger val):返回当前对象与val的和；

public BigInteger subtract( var)差

public  multiply 积

divide 商

remainder 余 类似%

compareTo 比较大小

abs()绝对值

toString  字符串

  //BigInteger
      BigInteger result=new BigInteger("0");
      BigInteger one=new BigInteger("123456789");
      BigInteger two=new BigInteger("2344532");
      result=one.add(two);
      System.out.println("和"+result);
      result=one.multiply(two);
      System.out.println("积"+result);
      result=one.subtract(two);
      System.out.println("差"+result);
      result=one.divide(two);
      System.out.println("商"+result);

Random类

可以返回随机数

Random=new Randow().nextInt(100)返回0-99的随机数

   //Random类
      System.out.println(new Random().nextInt(100));
      System.out.println(new Random().nextDouble()*100);

• 数字格式化

NumberFormat表示数字的格式化类

NumberFormat 是所有数值格式的抽象基类。此类提供格式化和解析数值的接口。NumberFormat 还提供了一些方法来确定哪些语言环境具有数值格式，以及它们的名称是什么。

NumberFormat 可用于格式化和解析任何语言环境的数值。使代码能够完全独立于小数点、千位分隔符甚至所用特定小数位数的语言环境约定，并与数值格式是否为偶小数无关。

• 若要格式化当前 Locale 的数值，可使用其中一个工厂类方法：NumberFormat.getInstance().format(myNumber);
• 若要格式化不同 Locale 的日期，可在对 getInstance 的调用中指定它：NumberFormat nf = NumberFormat.getInstance(Locale.FRENCH);
• 还可以使用 NumberFormat 来解析数值：myNumber = nf.parse(myString);

使用 getInstance 或 getNumberInstance 来获取常规数值格式。使用 getIntegerInstance 来获取整数数值格式。使用 getCurrencyInstance 来获取货币数值格式。使用 getPercentInstance 来获取显示百分比的格式。使用此格式，小数 0.53 将显示为 53%。

使用 setMinimumFractionDigits 之类的方法还可以控制数值的显示。如果想对格式化和解析进行更多的控制（或者给予用户更多的控制），可以尝试将从工厂方法获取的 NumberFormat 强制转换为 DecimalFormat。这适用于大多数语言环境；只是要记住将其放入一个 try 代码块中，以防遇到特殊情况。

API

• Object clone()     重写 Cloneable

• boolean equals(Object obj)     重写 equals

• int hashCode()     重写 hashCode

• String format(double number)     格式规范。

• abstract  StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition pos)     格式规范。

• String format(long number)     格式规范。

• abstract  StringBuffer format(long number, StringBuffer toAppendTo, FieldPosition pos)     格式规范。

• StringBuffer format(Object number, StringBuffer toAppendTo, FieldPosition pos)     格式化一个数并将所得文本添加到给定字符串缓冲区。

• Number parse(String source)     解析给定字符串开头的文本，生成一个数值。

• abstract  Number parse(String source, ParsePosition parsePosition)     如果可能则返回 Long （例如，在 [Long.MIN_VALUE, Long.MAX_VALUE] 范围内且没有小数），否则返回 Double。

• Object parseObject(String source, ParsePosition pos)     解析字符串中的文本，以生成一个 Number。

• int getMaximumFractionDigits()     返回数的小数部分所允许的最大位数。

• int getMaximumIntegerDigits()     返回数的整数部分所允许的最大位数。

• int getMinimumFractionDigits()     返回数的小数部分所允许的最小位数。

• int getMinimumIntegerDigits()     返回数的整数部分所允许的最小位数。

• void setMaximumFractionDigits(int newValue)     设置数的小数部分所允许的最大位数。

• void setMaximumIntegerDigits(int newValue)     设置数的整数部分所允许的最大位数。

• void setMinimumFractionDigits(int newValue)     设置数的小数部分所允许的最小位数。

• void setMinimumIntegerDigits(int newValue)     设置数的整数部分所允许的最小位数。

• static Locale[] getAvailableLocales()     返回一个数组，它包含所有此类的 get*Instance 方法可以为其返回本地化实例的语言环境。

• static NumberFormat getCurrencyInstance()     返回当前默认语言环境的【货币】格式。

• static NumberFormat getCurrencyInstance(Locale inLocale)     返回指定语言环境的【货币】格式。

• static NumberFormat getInstance()     返回当前默认语言环境的通用【数值】格式。

• static NumberFormat getInstance(Locale inLocale)     返回指定语言环境的通用【数值】格式。

• static NumberFormat getIntegerInstance()     返回当前默认语言环境的【整数】格式。

• static NumberFormat getIntegerInstance(Locale inLocale)     返回指定语言环境的【整数】格式。

• static NumberFormat getNumberInstance()     返回当前默认语言环境的【通用数值】格式。

• static NumberFormat getNumberInstance(Locale inLocale)     返回指定语言环境的【通用数值】格式。

• static NumberFormat getPercentInstance()     返回当前默认语言环境的【百分比】格式。

• static NumberFormat getPercentInstance(Locale inLocale)     返回指定语言环境的【百分比】格式。

• Currency getCurrency()     获取格式化货币值时此数值格式使用的货币。

• RoundingMode getRoundingMode()     获取在此 NumberFormat 中使用的 RoundingMode。

• boolean isGroupingUsed()     如果此格式中使用了分组，则返回 true。

• boolean isParseIntegerOnly()     如果此格式只将数作为整数解析，则返回 true。

• void setCurrency(Currency currency)     设置格式化货币值时此数值格式使用的货币。

• void setRoundingMode(RoundingMode roundingMode)     设置在此 NumberFormat 中使用的 RoundingMode。

• void setGroupingUsed(boolean newValue)     设置此格式中是否使用分组。

• void setParseIntegerOnly(boolean value)     设置数是否应该仅作为整数进行解析。

DecimalFormat格式化数字

DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。允许我们指定格式模式获取我们想要的格式化数值，数值的小数部分，默认显示3位小数该类设计有各种功能，使其能够解析和格式化任意语言环境中的数，包括对西方语言、阿拉伯语和印度语数字的支持。它还支持不同类型的数，包括整数 (123)、符点数 (123.4)、科学记数法表示的数 (1.23E4)、百分数 (12%) 和金额 ($123)。所有这些内容都可以本地化。

Double  d=Double.parseDouble(num);
            java.text.NumberFormat percentFormat =java.text.NumberFormat.getPercentInstance(); 
            percentFormat.setMaximumFractionDigits(2); //最大小数位数
            percentFormat.setMaximumIntegerDigits(3);//最大整数位数
            percentFormat.setMinimumFractionDigits(2); //最小小数位数
            percentFormat.setMinimumIntegerDigits(1);//最小整数位数
            return percentFormat.format(d);//自动转换成百分比显示

0    表示一个数字，被格式化数值不够的位数会补0
#    表示一个数字，被格式化数值不够的位数会忽略
.    小数点分隔符的占位符
,    分组分隔符的占位符
-    缺省负数前缀
%    将数值乘以100并显示为百分数
\u2030    将数值乘以1000并显示为千分数

要获取具体语言环境的 NumberFormat，可调用 NumberFormat 的某个get**Instance()工厂方法 ，通常其就是 DecimalFormat 类型。

System.out.println(NumberFormat.getInstance() instanceof DecimalFormat);//true

通常不直接调用 DecimalFormat 的构造方法，因为 NumberFormat 的工厂方法可能返回不同于 DecimalFormat 的子类。

如果需要自定义格式对象，可执行：

NumberFormat f = NumberFormat.getInstance(loc);
((DecimalFormat)f).setDecimalSeparatorAlwaysShown(true);

Tips：DecimalFormat 通常不是同步的。建议为每个线程创建独立的格式实例。如果多个线程同时访问某个格式，则必须保持外部同步。

DecimalFormat 包含一个模式 和一组符号。可直接使用 applyPattern() 或间接使用 API 方法来设置模式。符号存储在 DecimalFormatSymbols 对象中。使用 NumberFormat 工厂方法时，可从已本地化的 ResourceBundle 中读取模式和符号。

ChoiceFormat格式化数字

ChoiceFormat允许将格式化运用到某个范围的数，通常与MessageFormat一同使用。ChoiceFormat在构造方法中接收一个format数组和一个limits数组，这两个数组的长度必须相等，例如：

limits = {1,2,3,4,5,6,7}
formats = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}

limits数组实际上是个区间，可开可闭，并且必须按升序排列，如果不按升序排列，格式化结果将会不正确，还可以使用\u221E(表示无穷大)。

ChoiceFormat的匹配公式：

limit[j] <= X 

其中X表示使用format方法传入的值，j表示limit数组中的索引。当且仅当上述公式成立时，X匹配j，如果不能匹配，则会根据X是太小还是太大，匹配limits数组的第一个索引或最后一个索引，然后使用匹配的limits数组中的索引，去formats数组中寻找相同索引的值。

ChoiceFormat类中的几个常用方法

（1）nextDouble(double d)静态方法查找大于d的最小double值，用在limits数组中，从而使limits数组形成一个右开区间数组，例如：

limits = {0,1,ChoiceFormat.nextDouble(1)}

（2）nextDouble(double d, boolean positive)静态方法，如果positive参数为true，表示查找大于d的最小double值；如果positive参数为false，表示查找小于d的最大double值，这样就可以使limits形成一个左开区间数组。

（3）previousDouble(double d)静态方法，查找小于d的最大double值
ChoiceFormat类的构造方法也允许我们传入一个模式字符串，format方法会根据这个模式字符串执行格式化操作。一个模式元素的格式如下：

doubleNum [占位符] formatStr

Tips：模式字符串中的每个模式元素之间使用"|"分割，"|"前后可以添加空格以美化代码，而且必须按照升序进行书写，否则会出现java.lang.IllegalArgumentException的运行时异常。

• Class类与Console类（待补充）

Class

可以得到类的实例

Class a=new Class("Hello"):
Hellow h=(Hellow)a.newInstace();

Console类

不让文本回显即不在命令行显示就用Console类

  //Console类
      Console cons=System.console();
      char[] chars;
      chars=cons.readPassword();
      System.out.println(chars.toString());

• Pattern类与Matcher类

概述

• Pattern类的作用在于编译正则表达式后创建一个匹配模式.
• Matcher类使用Pattern实例提供的模式信息对正则表达式进行匹配

Pattern类

常用方法及介绍

• Pattern complie(String regex)

由于Pattern的构造函数是私有的,不可以直接创建,所以通过静态方法compile(String regex)方法来创建,将给定的正则表达式编译并赋予给Pattern类

• String pattern()

返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数

• Pattern compile(String regex, int flags) 

方法功能和compile(String regex)相同,不过增加了flag参数

• int flags() 

返回当前Pattern的匹配flag参数.flag参数用来控制正则表达式的匹配行为

• Pattern.matcher(CharSequence input) 

对指定输入的字符串创建一个Matcher对象

• String[] split(CharSequence input)

String[] split(CharSequence input, int limit)

• String[] split(CharSequence input, int limit)

功能和String[] split(CharSequence input)相同,增加参数limit目的在于要指定分割的段数

• Pattern.quote(String s)

返回给定的字符串的字面量

• matches()方法

编译给定的正则表达式并且对输入的字串以该正则表达式为模开展匹配,该方法适合于该正则表达式只会使用一次的情况,也就是只进行一次匹配工作,因为这种情况下并不需要生成一个Matcher实例.

Matcher类

常用方法及介绍

• boolean matches()

最常用方法:尝试对整个目标字符展开匹配检测,也就是只有整个目标字符串完全匹配时才返回真值.

• boolean lookingAt()

对前面的字符串进行匹配,只有匹配到的字符串在最前面才会返回true

• boolean find()

对字符串进行匹配,匹配到的字符串可以在任何位置

• int start()

返回当前匹配到的字符串在原目标字符串中的位置

• int end()

返回当前匹配的字符串的最后一个字符在原目标字符串中的索引位置.

• String group()

返回匹配到的子字符串

• Pattern.start(),Pattern.end(),Pattern.group()代码示例

• Pattern p = Pattern.compile("\\d+");
  Matcher m = p.matcher("aa22bb23");
  m.find();
  int start = m.start();//2
  String group = m.group();//22
  int end = m.end();//4
  System.out.println(start);
  System.out.println(group);
  System.out.println(end);
  

知识点小结

• String类是final 类，不可以有子类
• “\hello"是错误的字符串常量，”\hello"是正确的字符串常量
• 表达式"\t\nABC".length()的值是5【\t、\n算分别算一个字符】
• 表达式"A".compareTo(“B”)的值是负数
• 【.compareTo(),比较大小，前者>后者→正数，前者＜后者→负数，前者=后者→0】
• 表达式"I love this game".contains(“love”)的值是true
• 【.contains(),判断是否包含某字符串】
• 表达式"RedBird".indexOf(“Bird”)的值是3
• 【.indexOf(),返回目标字符串下标索引，若不存在则返回-1】
• Integer.parseInt(“12.9”);会触发NumberFormatException异常
• 【Integer.parseInt()字符串→整数，12.9为浮点数】
• 表达式"D:/java/book/E.java".lastIndexOf("/")的值是12
• 【.lastIndexOf()，返回目标字符出现的最后索引位置】
• 表达式"89762.34".matches("[0-9.]+")的值是true
• 表达式"3.14".matches("[0-9]+[.]{1}[0-9]+")的值是true
• 【matches() ，返回是否匹配指定的字符串】
• 表达式"89762.34".startsWith(“89”)的值是true
• 表达式"89762.34".endsWith(“34”)的值是true
• 表达式"java".equals(“java”)的值是true
• 【.equals()，判断值是否相等，区别于= =（判断地址），表达式 new String(“abc”)== "abc"的值是false（地址不同）】
• 表达式"bird".contentEquals(“bird”)的值是true
• 【equals()和contentEquals()方法】
• 表达式"Bird".equalsIgnoreCase(“bird”)的值是true
• 【.equalsIgnoreCase()，忽略大小写判断是否等值】
• 表达式new String(“abc”).contentEquals (“abc”)的值是true
• 表达式new String(“abc”).equals (“abc”)的值是true
• 表达式"abc" == "abc"的值是true
• 表达式new String(“abc”) == new String(“abc”)的值是false
• StringTokenizer对象的nextToken()方法返回一个String对象
• StringTokenizer对象的countTokens()方法返回一个int型数据
• String对象的字符序列是不可修改的
• StringBuffer对象的字符序列是可修改的
• Random对象的nextInt(int n)方法随机返回[0，n)之间的一个整数

参考

《Java 2 实用教程（第5版）》

https://blog.csdn.net/weixin_38235865/article/details/104588841

https://blog.csdn.net/m0_50609545/article/details/118017091

https://blog.csdn.net/weixin_42717928/article/details/97536281

Java日期格式化（DateFormat类和SimpleDateFormat类） (biancheng.net)