常用实用类

1、String类

String类在java.lang包中，因为java.lang包中的类默认引入，因此可以直接使用String类。

Java把String类定义为final类，因此用户不能扩展String类，即String类不能有子类。

1、构造String对象

String对象，习惯翻译为字符串对象。

1、常量对象

String常量也是对象。

Java把String常量放入常量池。

常量池中的数据在程序运行期间再也不允许改变。

2、String对象

可以用String类声明对象并创建对象：

String s = new String(“we are students”);

（凡是new构造的对象都不在常量池中），存储在动态区（非常量池）

用户无法输出String对象的引用：

System.out.println(s);

输出的是对象的实体，即字符序列we are students

也可以用一个已创建的String对象创建另一个String对象：

String tom = new String(s);

String类有两个较常用的构造方法。

(1) String(char[] a)

char[] a = new{'J', 'a', 'v', 'a'};
String s = new String(a);

相当于

String s = new String("Java");

（2）String(char[] a, int startIndex, int count) 提取字符数组 a 中的一部分字符创建一个String对象，startIndex指起始位置，count指从该位置开始截取的字符个数。

3、引用String常量

String常量是对象，因此可以把String常量的引用赋值给一个String对象。

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

这样，s1,s2有相同的引用，s1==s2的值是true，因而具有相同的实体。

2、字符串的并置

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

String s = "你";
String h = "好";
String str = s + h;//"你好"

str 相当于new String(“你好”);

3、String类的常用方法

1、public int length() (掌握)

String类中的length()方法用来获取一个String对象的字符序列的长度。

String china = "1945年抗战胜利";
int n1, n2;
n1 = china.length(); // 9
n2 = "小鸟fly".length(); // 5

2、public boolean equals(String s) （掌握）

比较String对象的字符序列与参数的字符序列。

比较内容

public boolean equalsIgnoreCase(String s)比较字符内容，忽略大小写。

3、public boolean startsWith(String s)、public boolean endsWith(String s) （掌握）

判断某个字符串是否以某个子字符串开始。

判断当前字符串是否以某个子字符串结尾。

System.out.println("http://www.baidu.com".startsWith("http")); // true
System.out.println("http://www.baidu.com".startsWith("https")); // false

System.out.println("test.txt".endsWith(".java")); // false
System.out.println("test.txt".endsWith(".txt")); // true

4、public int compareTo(String s) （了解）

字符串之间比较大小不能直接使用 > < ，需要使用compareTo方法。

int result = "abc".compareTo("abc");
System.out.println(result); //0（等于0） 前后一致  10 - 10 = 0

int result2 = "abcd".compareTo("abce");
System.out.println(result2); //-1（小于0） 前小后大 8 - 9 = -1

int result3 = "abce".compareTo("abcd");
System.out.println(result3); // 1（大于0） 前大后小 9 - 8 = 1

// 拿着字符串第一个字母和后面字符串的第一个字母比较。能分胜负就不再比较了。
System.out.println("xyz".compareTo("yxz")); // -1

使用java.util包中的Arrays调用sort方法和自己编写SortString类中的sort方法将一个String数组按字典序排列。

SortString.java

public class SortString{
    public static void sort(String[] a){
        int count = 0;
        for(int i = 0; i < a.length; i++){
            for(int j = i + 1; j < a.length; j++){    
                if(a[j].compareTo(a[i]) < 0){
					String temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
    }
}

import java.util.Arrays;

public class Example8_3 {
    public static void main(String[] args) {
        String[] a = {"melon","apple","pear","banana"};
        String[] b = {"西瓜","苹果","梨","香蕉"};
        System.out.println("使用 SortString 类的方法按字典序排列数组 a:");
        SortString.sort(a);
        for (int i = 0; i < a.length; i++) {
            System.out.print(" "+a[i]);
        }
        System.out.println("");
        System.out.println("使用类库中的 Arrays 类，按字典序排列数组b：");
        Arrays.sort(b);
        for (int i = 0; i < b.length; i++) {
            System.out.print(" "+b[i]);
        }
    }
}

5、public boolean contains(String s) （掌握）

判断前面的字符串中是否包含后面的子字符串。

System.out.println("HelloWorld.java".contains(".java")); // true
System.out.println("http://www.baidu.com".contains("https://")); // false

6、public int indexOf(String s)和public int lastIndexOf(String s) （掌握）

indexOf：判断某个子字符串在当前字符串中第一次出现处的索引（下标）。

如果没有检索到，返回-1

lastIndexOf ：最后一次出现的索引

System.out.println("oraclejavacpythonjava".indexOf("java")); // 6

String 对象的字符序列中的转义字符是一个字符，例如 \n 代表回行，特别注意， String 对象的字符序列中如果使用目录符，那么 Windows 目录符必须转义写成 \\ 。Unix 目录符 / 直接使用即可。

7、public String substring(int startpoint) （掌握）

String tom = "我喜欢java";
String str = tom.substring(1,3); // 喜欢

8、public String trim() （掌握）

去掉字符串前后空格

System.out.println(" hello world ".trim());

4、字符串与基本数据类型转换

java.lang包中的Integer类调用其类方法public static int parseInt(String s) 可以将由“数字”字符组成的字符序列，如“879”，转换成int型数据。

String s = "879";
int 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

---

valueOf方法 （掌握）

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)

String中只有一个方法是静态的，不需要new对象

作用：将“非字符串”转换成“字符串”

//String s1 = String.valueOf(true);
//String s1 = String.valueOf(100);
//String s1 = String.valueOf(3.14);

// 这个静态的valueOf()方法，参数是一个对象的时候，会自动调用该对象的toString()方法吗？
String s1 = String.valueOf(new Customer());
//System.out.println(s1); // 没有重写toString()方法之前是对象内存地址		   	   com.bjpowernode.javase.string.Customer@10f87f48

System.out.println(s1); //我是一个VIP客户！！！！

5、对象的字符串表示

Object类有一个public String toString()方法，一个对象通过调用该方法可以获得该对象的字符串表示。

一个对象调用toString()方法返回的String对象的字符序列的一般形式为：

创建对象的类的名字@对象的引用的字符串表示

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

1、字符串与字符串数组

我们知道String类的构造方法String(char[] a)和String(char[] a, int offset, int length)分别用数组a中的全部字符和部分字符创建String对象。

String类也提供了将String对象的字符序列存放到数组中的方法：

public void getChars(int start, int end, char[] c, int offset)

public char[] toCharArray()将此字符串转换为新的字符数组。

char[] a,c;
String s = "1945年8月15日是抗战胜利日";
a = new char[4];
s.getChars(11,15,a,0); //数组a的单元依次存放的是 抗 战 胜 利

c = "sdfaksjdf".toCharArray();

2、字符串与字节数组

String类的构造方法String(byte[]) 用指定的字节数组构造一个String对象。String(byte[], int offset, int length)，从offset开始取length个字节，构造一个String对象。

---

public byte[] getBytes()

• public byte[] getBytes() 方法使用平台默认的字符编码，将当前String对象的字符序列存放到字节数组中，并返回数组的引用。

public byte[] getBytes(String charsetName)

• public byte[] getBytes(String charsetName) 方法使用参数指定字符编码，将当前String对象的字符序列存放到字节数组中，并返回数组的引用。

如果平台默认的字符编码是GB_2312(国标，简体中文)，那么调用getBytes()方法等同与调用getBytes(“GB2312”)，但需注意，带参数的getBytes(String charsetName)抛出UnsupportedEncodingException异常，因此，必须在try-catch语句中调用getBytes(String charsetName)。

GB2312编码中，一个汉字占两个字节

byte[] b = "Java你好".getBytes();
System.out.println("数组b的长度是：" + b.length);
String s = new String(b,6,2);//输出：好
System.out.println(s);
s = new String(b,0,6);
System.out.println(s);//输出：Java你

3、字符串的加密算法

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

1、正则表达式

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

String对象调用public boolean matches(String regex)可以判断当前String对象的字符序列是否与 regex指定的正则表达式匹配

. 代表任何一个字符

\\d 代表0~9中的任意一个

\\D 代表任意一个非数字字符

\\s 代表空格类字符

\\S 代表非空格类字符

\\w 代表可用于标识符的字符

\\W 代表不可用于标识符的字符

\\p{Lower}：小写字母
\\p{Upper}：大写字母
\\p{ASCII}：ASCII字符
\\p{Alpha}：字母
\\p{Dight}：数字字符
\\p{Alnum}：字母或数字
\\p{Punct}：标点符号
\\p{Graph}：可视符号：\p{Alnum}\p{Punct}
\\p{Print}：可打印字符：\p{Print}
\\p{Blank}：空格或制表符[\t]
\\p{Cntrl}：控制字符：[\x00-\x1F\x7F]

[abc]:代表a、b、c中的任何一个
[^abc]:代表除了a、b、c以外的任何字符
[a-zA-Z]:代表英文字母（包括大小写）中的任何一个
[a-d]: 代表a~d中的任何一个
另外，中括号允许嵌套中括号，可以进行并、交、差运算，例如:
[a-d[m-p]]:代表a~d，或m~p中的任何字符（并）
[a-z&&[def]]:代表d、e或f中的任何一个（交）
[a-f&&[^bc]]:代表a、d、e、f（差）    

注：由于“ . ” 代表任何一个字符，所以在正则表达式中如果想使用普通意义的点字符，必须使用[.]或\56表示普通意义的点字符。

在正则表达式中可以使用限定修饰符。例如，对于限定修饰符 ? ，如果X代表正则表达式中的一个元字符或普通字符，那么 X? 就表示X出现0次或1次，例如：

String regex = "hello[2468]?";

那么"hello" “hello2” “hello4” “hello6” “hello8” 都与regex匹配

​ 限定符

带限定修饰符的模式	意义
X?	X出现0次或1次
X*	X出现0次或多次
X+	X出现1次或多次
X{n}	X恰好出现n次
X{n,}	X至少出现n次
X{n,m}	X出现n次至m次
XY	X的后缀是Y
X|Y	X或Y

例如：regex = "@\\w{4}",那么"@abcd" "@天道酬勤" "@Java" "@bird" 都与正则表达式regex匹配

有关正则表达式的细节可查阅java.util.regex包中的Pattern类。

2、字符串的替换

String对象调用public String replaceAll(String regex, String replacement)方法返回一个新的String对象，这个新的String对象的字符序列是把当前String对象的字符序列中所有和参数regex匹配的子字符序列，用参数replacekejt的字符序列替换后得到字符序列，例如：

String str = "12hello567bird".replaceAll("[a-zA-Z]+","你好");

即为把所有英文字符替换为”你好“，“12你好567你好”

String对象调用replaceAll()方法返回一个新的String对象，但不改变当前String对象的字符序列。

3、字符序列的分解

public String[] split(String regex)

拆分字符串

如果准备分解出全部由数字字符组成的单词，就可以用非数字字符作为分隔：

String str = "1949-10-1".split("-"); //"1949-10-1"以"-"分隔符进行拆分。

使用regex = "\\D+"(匹配任何非数字字符)

String digitWord[] = str.split(regex);

那么digitWord[0] digitWord[1] digitWord[2] 就是1949 10 1

split()方法认为分隔标记的左侧是单词，所以如果String对象的前缀和regex匹配，那么split(String regex) 分解出的第一个单词是不含任何字符的字符序列（长度为0的字符序列），即""。

2、StringTokenizer 类

使用StringTokenizer对象分解String对象的字符序列，和split()方法不同，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", "#*");

称一个StringTokenizer对象为一个字符串分析器。一个分析器可以使用**nextToken()**方法逐个获取String对象的单词，每当获取到一个语言符号，字符串分析器中负责计数的变量的值就自动减，该计数变量的初始值等于字符串中的单词数目。

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

还可以随时让分析器调用**countTokenes()**方法得到分析器中计数变量的值。例如：

String s = "you are welcome(thank you),nice to meet you";
StringTokenizer fenxi = new StringTokenizer(s,"() ,");

那么fenxi首次调用countTokens()方法返回的值是9，首次调用nextToken()方法返回的值是"you"。

3、Scanner类

1、Scanner对象

Scanner对象可以解析字符序列中的单词，例如，

String NBA = I Love This Game;

为了解析出NBA的字符序列中的单词，可以如下构造一个Scanner对象：

Scanner sc = new Scanner(NBA);

Scanner对象可以调用方法

useDelimiter(正则表达式);

将正则表达式作为分隔标记，即让Scanner对象在解析操作时，把与正则表达式匹配的字符序列作为分隔标记。如果不指定分隔标记，那么Scanner对象默认用空白字符（空格、制表符、回行符）作为分隔标记来解析String对象的字符序列中的单词。

• Scanner对象调用next()方法一次返回被解析的字符序列中的单词，如果最后一个单词已被返回next()方法返回，Scanner对象调用hasNext()将返回false
• 对于被解析被解析的字符序列中的数字型单词，例如618，198.2，Scanner对象可以用nextInt()或nextDouble()方法来代替next()方法，即可以调用nextInt()或nextDouble()方法将数字型单词转化为int或double数据返回。
• 如果单词不是数字型单词，Scanner对象调用nextInt()或nextDouble()方法将发生InputMismatchException异常，在处理异常时可以调用next()方法返回非数字单词

2、StringTokenizer和Scanner的区别

StringTokenizer类和Scanner类都可用于分解字符序列中的单词，但二者在思想上有区别。

StringTokenizer类把分解出的全部单词都存放到StringTokenizer对象的实体中，因此StringTokenizer对象能较快速的获得单词，即StringTokenizer对象的实体占用较多的内存（用空间换速度）。

Scanner类不把单词存放到Scanner对象的实体中，而是仅仅存放怎样获得单词的分隔标记，因此Scanner对象获得单词的速度较慢，但Scanner对象节省内存（用速度换空间）。如果字符序列存放在磁盘空间的文件中，并且形成的文件比较大，那么用Scanner对象分解字符序列中的单词就可以节省内存。

StringTokenizer对象一旦诞生就立刻知道单词的数目，即可以用countTokens()方法返回单词的数目，而Scanner类不能提供这样的方法因为Scanner类不把单词存放到Scanner对象的实体中，如果想知道单词的数目，就必须去一个一个地获取，记录单词地数目。

4、StringBuffer类

1、StringBuffer对象

String对象地字符序列地字符不能被修改、删除，即Stirng对象的值是不可以再发生变化的。

与String类不同，StringBuffer类的对象的实体的内存空间可以自动地改变大小，存放一个可变地字符序列。

StringBuffer S = new StringBuffer("我喜欢");
s.append("玩游戏");//用append()方法追加以一个字符序列

StringBuffer类有三个构造方法：

• StringBuffer()
• StringBuffer(int size)
• StringBuffer(String s)

第一个无参的构造方法创建一个StringBuffer对象，那么分配给该对象的实体的初始容量可以容纳16个字符，当该对象的实体存放的字符序列的长度大于16时，实体的容量自动增加。StringBuffer对象可以通过length()方法获取实体中存放字符序列的长度，通过capacity()方法获取当前实体的实际容量。

第二个构造方法可以指定分配初始容量为size的字符个数，当该对象实体存放的字符序列长度大于size个字符时，容量自动增加。

第三个构造方法指定分配给该对象的实体的初始容量为s的字符序列的长度再加16。

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对象的引用。

2、public char charAt(int n)和public void setCharAt(int n, char ch)

char charAt(int n) 得到StringBuffer对象的字符序列位置n上的字符。setCharAt(int n, char ch)将当前StringBuffer对象的字符序列位置n处的字符用参数ch指定的字符替换（n）的值必须时非负的，并且小于当前对象实体中字符序列的长度，StringBuffer对象的字符序列的第一个位置是0，第二个位置是1。

3、StringBuffer inset(int index, String str)

StringBuffer对象使用inset方法将参数str指定的字符序列插入到参数index指定的位置，并返回当前对象的引用。

4、public StringBuffer reverse()

将该对象实体中的字符序列翻转，并返回当前对象的引用。

5、StringBuffer delete(int starIndex, int endIndex)

从当前StringBuffer对象的字符序列中删除一个子序列，并返回当前引用。从starIndex位置到endIndex-1位置处的字符序列被删除。

deleteCharAt(int index)方法删除当前StringBuffer对象实体的字符序列中index位置处的一个字符。

6、StringBuffer replace(int starIndex, int endIndex, String str)

将当前StringBuffer对象的字符序列的子序列用参数str指定的字符序列替换。从starIndex到endIndex-1的子符序列被替换。返回当前StringBuffer对象的引用。

5、Date类和Calendar类

1、Date类

1、无参构造

使用Date类的无参构造创建的对象可以获取本机的当前日期和时间。

Date nowTime = new Date();

System.out.println(nowTime);

Date类重写了Object类的toString方法，使得System.out.println(nowTime)不输出nowTime变量中存放的对象的引用，而输出对象实体中的时间。

2、有参构造

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

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

其中的参数取正值表示公元后的时间，取负值表示公元前的时间，例如1000表示1000毫秒，

可以用System类的静态方法public long currentTimeMillis()获取系统当前时间，如果运行Java程序的本地时区是北京失去，这个时间是从1970.1.1.8点到目前的毫秒数

2、Calendar类

Calendar在java.util中，使用Calendar类的static的方法getInstance()可以初始化一个日历对象。

是抽象类，不能new，月份从0开始

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)

当日历翻到任何一个时间，当参数year取负数时表示公元前（实际世界中的公元前）。

calendar对象调用public int get(int field)可以获取有关年份，月份、小时、星期，参数field的有效值由Calendar的静态常量指定：

calendar.get(Calendar.MONTH);

返回一个整数，如果该整数时0表示当前日历在一月，整数1表示二月。

calendar.get(Calendar.DAY_OF_WEEK);

返回一个整数，1表示星期日，2表示星期一，7表示星期六。

calendar对象调用public long getTimeInMillis()可以返回当前calendar对象中时间的毫秒计时。

6、日期的格式化

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

1、format方法

format(格式化模式,日期列表)

按照"格式化模式"返回"日期列表"中所列各个日期中所含数据（年、月、日、时等）的字符串表示

1、格式化模式

Date nowTime = new Date();
String s1 = String.format("%tY年%tm月%td日",nowTime,nowTime,nowTime);//2021年04月09日
String s2 = String.format("%tF",nowTime);//2021-04-09

2、日期列表

format方法中的’‘日期列表’'可以是用逗号分隔的Calendar对象或Date对象。

3、格式化同一日期

可使用“<”

String str1 = String.format("%tY年%tm月%<td日",nowTime);
String str2 = String.format("%tY-%<tm-%<td",nowTime);

日期格式符	作用
%tY	将"年"化为4位数字
%ty	将"年"化为2位数字
%tm	将"月"化为2位数字，"01"是第一个月
%tj
%tB
%tb
%tA
%ta
%tH
%tI
%tM
%tS
%tL
%tN
%tz
%tZ

2、不同区域的星期格式

想用特定区域的星期格式表示日期中的星期，可以用format的重载方法：

format(Locale locale, 格式化模式，日期列表);

其中参数locale是一个Locale类的实例，用来表示地域。

Locale类的static常量都是Locale对象,其中US是表示美国的static常量。

String s = String.format(Locale.US, "%ta(%<tF)", new Date()); // Fri(2021-04-09)

如果format方法不适用locale参数格式化日期，当前应用程序所在系统的地区设置是中国，那么相当于locale参数取Locale。CHINA。

7、Math类、BigInteger类、Random类

1、Math类

java.lang包中的Math类包含许多用来进行计算的static方法，这些方法可以直接通过类名调用。Math类还有两个static常量：E和PI，值为2.1782828284590452354和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(duoble 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)：a的正弦值

• public static double asin(double a)：a的反正弦值

• public static double ceil(double a)：大于a的最小整数，并将该整数转化为double型数据（ceil是天花板的意思）

• public static double floor(double a)：小于a的最大整数，并将该整数转化为double型数据

• public static long round(double a)：返回值是(long)Math.floor(a+0.5)，即所谓a的”四舍五入“后的值，注意Math.round(-15.501)的值为-16，Math.round(-15.50)的值是-15

2、BigInteger类

程序处理特别大的整数，可以用java.math包中的BigInteger类的对象。

使用构造方法public BigInteger(String val)构造一个十进制的BigInteger对象。该构造方法可以放生NumberFormatException异常，就是说，字符串参数val中如果含有非数字字符就会发生NumberFormatException异常。

BigInteger类的常用方法：

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

3、Random类

尽管可以用Math类调用static方法random()返回一个0~1之间的随机数（包括0.0但不包括1.0）

(int)(Math.random()*100)+1;

但Java提供了更灵活的获取随机数的Random类（在java.util包中）

Random类的构造方法：

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

创建Random对象，其中第一个构造方法使用当前机器事件作为种子创建一个Random对象，第二个构造方法使用参数seed指定的种子创建一个Random对象。人们习惯将Random对象称为随机数生成器。

Random random = new Random();
random.nextInt(); // 返回一个随机整数

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

random调用public double nextDouble()返回一个0.0~1.0之间的随机数，包括0.0但不包括1.0

random.nextBoolean(); 随机真假

注：对于具有相同种子的两个Random对象，二者依次调用nextInt()方法获取的随机数序列是相同的，即伪随机

8、数字格式化

所谓数字格式化，就是按照指定格式得到一个字符序列

1、format方法

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

1、格式化模式

format(格式化模式,日期列表)

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

那么String对象s的字符序列就是"3.14"

2、值列表

format方法中的"值列表"是用逗号分隔的变量、常量或表达式。要保证format方法”格式化模式“中的格式符的个数与”值列表“中列出的值的个数相同

String s = String.format("%d元%0.3f公斤%d台",888,999,777888,123);

那么s就是888元999.777公斤123台

3、格式化顺序

String s = String.format("从左向右：%d,%.3f,%d", 888, 3.1415, 100);

s为 从左向右：888，3.142，100

如果不希望使用默认的顺序（从左向右）进行格式化，可以在格式符前面添加索引符号index$，例如，1$表示”值列表“中的第一个，2$表示”值列表“中的第二个

String s = String.format("不是从左向右: %2$.3f, %3$d, %1$d", 888, 3.1415926, 100);

s为 不是从左向右：3.142， 100， 888

注：如果在“格式化模式”中包含普通%,要连续输入两个%

String s = String.format("%d%%",89); // s 是"89%"

​

2、格式化整数

1、%d %o %x %X

%d %o %x %X格式符可格式化byte, Byte, short, Short, int, Integer, long, Long型数据

%d：将值格式化为十进制整数

%o：将值格式化为八进制整数

%x：将值格式化为小写的十六进制整数

%X：将值格式化为大写的十六进制整数

例如：

String s = String.format("%d,%o,%x,%X",703576,703576,703576,703576); // 703576,2536130,abc598,ABC58

2、修饰符

加号修饰符 “ + ” , 格式化正数时，强制添加上正号，例如，%+f 将 123.78 格式化为 “+123.78”，%+E 将 123.78 格式化为 “+1.2378E+2”。

逗号修饰符" , " ,格式化浮点数时，将整数部分按 “ 千 ” 分组，例如，

String s = String.format("整数部分按千分组： %+,f", 1235678.9876);

字符串 s 就是

整数部分按千分组： +1,235,678.987600

3、限制小数位数与数据的“宽度”

9、Class类与Console类

1、Class类

Class是java.lang包中的类，该类的实例可以帮助程序创建其他类的实例。创建对象最常用的方式是使用new 和构造方法，也可以用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 InstantiatioinException,IllegalAccessException

方法可以得到一个className类的对象

2、Console类

java,io包中的Console 类，使用System类调用console()方法返回Console类的一个对象

Console cons = System.console();

然后，cons调用readPassword()方法读取用户再键盘输入的一行文本，并将文本以一个char数组返回。

char[] passwd = cons.readPassword();

10、Pattern类与Matcher类

模式匹配就是检索和指定模式匹配的字符序列。Java提供了专门用来进行模式匹配的 Pattern 类和 Matcher 类，这些类再java.util.regex包中。

假设有字符串：

String input = "hello,good morning, this is a good idea";

我们想知道input的字符序列从哪个位置开始至哪个位置结束曾出现了字符序列good，使用Pattern类和Matcher类的步骤如下

1、建立Pattern 对象

使用正则表达式regex作参数得到一个称为模式的Pattern类的实例pattern

Pattern pattern = Pattern.compile(regex);

例如：

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

Pattern类可以调用类方法compile(String regex, int flags)返回一个Pattern对象，参数flags可以取下列有效值：

Pattern.CASE_INSENSITIVE

Pattern.MULTILINE

Pattern.DOTALL

Pattern.UNICODE_CASE

Pattern.CANON_EQ

例如，flags取值Pattern.CASE_INSENSITIVE，模式匹配时将忽略大小写。

2、得到Matcher对象

得到可以检索String对象input的Matcher类的实例matcher(称为匹配对象)。

Matcher mathcer = puttern.matcher(input);

模式对象pattern调用matcher(CharSequence input)方法返回一个Matcher对象matcher，称为匹配对象，参数input用于给出matcher要检索的String对象。

然后，matcher就可以调用方法检索input。

• public boolean find()：寻找input和regex匹配的下一个序列，成功返回true，否则返回false。matcher可以调用start()和end()方法得到该匹配模式子序列再input中的开始位置和结束位置。当find()返回true时，matcher调用group()可以返回find()方法本次找到的匹配模式的子序符序列。
• public boolean matchers()：判断input是否完全和regex匹配。
• public boolean lookingAt()：判断从input开始位置是否有和regex匹配的子序列。matcher调用start()和end()方法可以得到lookingAt()方法找到的匹配模式的子序列再input中的开始位置和结束位置。若lookingAt()方法返回true，matcher调用group()可以返回lookingAt()方法找到的匹配模式的子序列。
• public boolean find(int start)：判断input从参数start指定位置开始是否有和regex匹配的子序列，参数start取0时，该方法和lookingAt()的功能相同
• public String replaceAll(String replacement)：matcher调用该方法可以返回一个String对象，该String对象的字符序列是通过把input的字符序列中与模式regex匹配的子字符序列全部替换为参数replacement指定的字符序列得到的（input本身没有发生变化）
• public String replaceFirst(String replacement)：把input的字符序列中第一个与模式regex匹配的子字符序列替换为参数replacement指定的字符序列得到的（input本身没有发生变化）