Java 程序设计 4 数学函数、字符、字符串

数学函数

Math是final类，在java.lang.Math中，所有数学函数都是静态方法。

Math类中定义了常用的

数学常数

PI : 3.14159265358979323846
E : 2.7182818284590452354

方法：

三角函数：sin, cos, tan, asin, acos, atan,toRadians,toDigrees
指数：exp, log, log10，pow, sqrt
取整：ceil, floor, round
其它：min, max, abs, random（[0.0,1.0)）

Math.random方法生成[0.0,1.0)之间的double类型的随机数，可以用它写出简单的表达式来生成任意范围的随机数，如：

(int)(Math.random()*10);  //[0,10)
50+(int)(Math.random()*50);  //[50,100)
//一般地
a+(int)(Math.random( )*b)                        
//返回[a, a+b)
a+(int)(Math.random( ) *(b+1))            
//返回[a, a+b]
(char)(‘a’+（int）(Math.Random( ) * (‘z’-’a’+1)))
//随机产生从‘a’-‘z’之间的字符

字符类型

Java 对字符采用 16 位 Unicode 编码，因此 char 类型的大小为二个字节

16 位的 Unicode 用以 \u 开头的 4 位 16 进制数表示，范围从 ’\u0000’ 到 ’\ uffff ’, 不能少写位数

Unicode包括ASCII码，从’\u0000’到’\u007f’对应128个ASCII字符

JAVA 中的 ASCII 字符也可以用 Unicode 表示，例如

char letter = ‘A’；

char letter = ‘\u0041’；//等价，\u后面必须写满4位16进制数

++ 和 -- 运算符也可以用在 char 类型数据上，运算结果为该字符之后或之前的字符，例如下面的语句显示字符 b

char ch = ‘a’;

System.out.println(++ch); //显示b

转义字符

和 C++ 一样，采用反斜杠 (\) 后面加上一个字符或者一些数字位组成转义序列，一个转义序列被当做一个字符如\n \t \b \r \f \\ \' \"

//如果想打印带””的信息 
//He said “Java is fun “
System.out.println("He said \"Java is fun \"");

字符类型和其他数据类型的转换

char类型数据可以转换成任意一种数值类型，反之亦然。将整数转换成 char 类型数据时，只用到该数据的低 16 位，其余被忽略。例如：

char ch = （char）0xAB0041；
//0x0xAB0041是int字面量，要赋值给char，必须强制类型转换
System.out.println(ch);  //显示A

要将浮点数转成char时，先把浮点数转成int型，然后将整数转换成char

char ch = （char）65.25；
System.out.println(ch);  //显示A

当一个char型转换成数值型时，这个字符的Unicode码就被转换成某种特定数据类型

int i = ‘A’；//不用强制类型转换
System.out.println(i);  //显示65

如果转换结果适用于目标变量（不会有精度损失），可以采用隐式转换；否则必须强制类型转换

int i = ‘A’；
byte b = （byte）‘\uFFF4’;  //取低8位二进制数F4赋值给b

所有数值运算符都可以用在char 型操作数上，如果另一个操作数是数值，那么char型操作数就自动转换为数值；如果另外一个操作数是字符串，那么char型操作数会自动转换成字符串再和另外一个操作数字符串相连

int i = ‘2’+ ‘3’;  //0x32和0x31
System.out.println（i）；  // i为50+51=101
int j = 2 + ‘a’；         //j = 2 + 97 = 99
System.out.println(j + “ is the Unicode of ”+ (char)j);//99 is the Unicode of  c

字符的比较和测试与Character类

两个字符可以通过关系运算符进行比较，如同比较二个数值：通过字符的Unicode值进行比较

Java为每个基本数据类型提供了包装类，char的包装类是Character，包装类对象为引用类型，不是值类型。

Character类的作用：

        将char类型的数据封装成对象

        包含处理字符的方法和常量

方法：下面方法都是静态方法

        isDigit方法判断一个字符是否是数字

        isLetter方法判断一个字符是否是字母

        isLetterOrDigit方法判断一个字符是否是字母或数字

        isLowerCase方法判断一个字符是否是小写

        isUpperCase方法判断一个字符是否是大写

        toLowerCase方法将一个字符转换成小写

        toUpperCase方法将一个字符转换成大写

String类

是一个final类，不能被继承。

java.lang.String表示一个固定长度的字符序列，实例化后其内容不能改。

构造函数
长度(length)
获取字符(charAt)
连接(concat)
截取(substring)
比较(equals, equalsIngnoeCase, compareTo, startWith，endWith, regionMatch)
转换(toLowerCase, toUpperCase, trim, replace)
查找(indexOf, lastIndexOf)
字符串和数组间转换(getChars, toCharArray), getChars返回void,超出长度就异常
字符串和数字间转换(valueOf)

String类对象的构造

可以从字面值创建字符串：

String newString = new String(stringLiteral);

由于String类使用频繁，Java提供了缺省写法：

String newString = stringLiteral;
//例如：
String m1 = “Welcome”;  	//字符串的内容都是不可修改的
String m2 = “Welcome”;       //m1和m2通过内存优化引用了同一常量对象：m1==m2
String m3 = "Wel" +"come"; 		//m1==m2==m3  
String m4 = "Wel" +new String("come"); 	//m1!=m4

常量池与规范字符串

由于字符串是不可变的，为了提高效率和节省内存，Java中的字符串字面值维护在字符串常量池中）。这样的字符串称为规范字符串(canonical string)。

可以使用字符串对象（假设内容为Welcome to Java）的intern方法返回规范化字符串。

intern方法会在字符串常量池中找是否已存在”Welcome to Java”，如果有返回其地址。如果没有，在池中添加“Welcome to java”再返回地址。即intern方法一定返回一个指向常量池里的字符串对象引用。

直接用字符串字面量构造的字符串在常量池里，用new String方法构造的字符串在堆里。

只有字面量在常量池里,例如：”Wel” + “come”，而”Wel”+new String(“come”)不在常量池里，在堆里。

String s = "Welcome to Java";
String s1 = new String("Welcome to Java");
String s2 = s1.intern(); 
String s3 = "Welcome to Java";
System.out.println(s1 == s); //false
System.out.println(s2 == s); //true
System.out.println(s3 == s); //true

字符串对象创建之后，其内容是不可修改的：

String s = “java”;
s = “HTML”;
String t = s;//这一句执行之后，"java"的被引用次数为0，意味着可以被清除了。

字符串的比较

equals方法用于比较两个字符串是否包含相同的内容，比较字符串内容要区别于直接比较二个引用变量，比较二个引用变量是判断这二个引用变量是否指向同一个对象（如s1 == s2）

equalsIgnoreCase：忽略大小写比较内容是否相同

regionMatch：比较部分内容是否相同

startsWith：判断是否以某个字符串开始

endsWith：判断是否以某个字符串结束

compareTo：方法用于比较两个字符串的大小，即第一个不同字符的差值（字典序）。 s1.compareTo(s2) 的返回值 :

当两个字符串相同时，返回０

当 s1 按字典排序在 s2 之前，返回小于０的值

当 s1 按字典排序在 s2 之后，返回大于０的值

String s0 = "Java";
String s1 = "Welcome to " + s0;
String s2 = "Welcome to Java";
String s3 = "welcome to java";
String s6 = "Welcome to Java";

// equals用于比较两个字符串的内容是否相同
System.out.println("s1.equals(s2) is " + s1.equals(s2)); //true

// equalsIgnoreCase忽略大小写
System.out.println("s2.equals(s3) is " + s2.equals(s3)); //false
System.out.println("s2.equalsIgnoreCase(s3) is " + s2.equalsIgnoreCase(s3)); //true

// regionMatches比较部分字符串: 给定两个串的起始位置和长度
System.out.println("s2.regionMatches(11, s0, 0, 4) is " + s2.regionMatches(11, s0, 0, 4) ); //true
System.out.println("s3.regionMatches(11, s0, 0, 4) is " + s3.regionMatches(11, s0, 0, 4));//false
System.out.println("s3.regionMatches(true, 11, s0, 0, 4) is " + s3.regionMatches(true, 11, s0, 0, 4));//true,忽略大小写

字符串长度和获取单个字符

调用length( )方法（区别与后面数组的长度属性）可以获取字符串的长度。
- charAt(index)方法可以获取指定位置的字符。index必须在0到s.length()-1之间。

连接字符串

concat方法用于连接两个字符串。例如：String s3 = s1.concat(s2);
- 使用加号(+)连接两个字符串。例如：String s3 = s1 + s2;
  - s1 + s2 + s3 等价于s1.concat(s2).concat(s3)
    - 连接操作返回一个新的字符串：因为String类型的实例内容不可修改。

截取子串

substring用于截取字符串的一部分，返回新字符串。

public String substring(int beginIndex, int endIndex)//返回字符串的子串。子串从beginIndex开始，直到endIndex-1

public String substring(int beginIndex)//返回字符串的子串。子串从beginIndex开始，直到字符串的结尾。

toLowerCase将字符串转换成小写形式，得到新串

toUpperCase 将字符串转换成大写形式，得到新串

trim 删除两端的空格，得到新串

replace 字符替换，得到新串

查找字符串

indexOf 返回字符串中字符或字符串匹配的位置，返回 -1 表示未找到。

"Welcome to Java".indexOf('W') returns 0.
"Welcome to Java".indexOf('x') returns -1.
"Welcome to Java".indexOf('o‘,5) returns 9.
"Welcome to Java".indexOf("come") returns 3.
"Welcome to Java".indexOf("Java", 5) returns 11.
"Welcome to Java".indexOf("java", 5) returns -1.
"Welcome to Java".lastIndexOf('a') returns 14.

lastIndexOf方法：查找指定字符或子字符串的最后一次出现的位置（索引）的方法。它是String类的成员方法，可以通过字符串对象调用。

方法签名如下：

public int lastIndexOf(int ch)
public int lastIndexOf(int ch, int fromIndex)
public int lastIndexOf(String str)
public int lastIndexOf(String str, int fromIndex)

其中，ch表示要查找的字符，而str表示要查找的子字符串。fromIndex参数是可选的，表示要从哪个索引开始向前搜索。

字符串的转化

toCharArray将字符串转换成字符数组：

String s = “Java”;
char[] charArray = s.toCharArray();// charArray.length=4

将字符数组转换成字符串，使用String的构造函数，可同时初始化

 new String(new char[] {‘J’,‘a’,‘v’,‘a’} );

使用valueOf 方法(静态方法)

String.valueOf( new char[] {'J','a','v','a'} );
String.valueOf(2.34);  //2.34转"2.34"

valueOf方法将基本数据类型转换为字符串：

String s1 = String.valueOf(1.0);  //“１.0”
String s2 = String.valueOf(true); //“true”

字符串转换为基本类型：利用包装类

Double.parseDouble(str)
Integer.parseInt(str)
Boolean.parseBoolean(str)

StringBuilder 与 StringBuffer

String 类一旦初始化完成，字符串就是不可修改的。

StringBuilder与StringBuffer(final类）初始化后还可以修改字符串。

StringBuffer修改缓冲区的方法是同步（synchronized）的，更适合多线程环境。
StringBuilder线程不安全，与StringBuffer工作机制类似。

由于可修改字符串， StringBuilder 与 StringBuffer 增加了 String 类没有的一些函数，例如： append 、 insert 、 delete 、 replace 、 reverse 、 setCharAt 等。
以 StringBuilder 为例：
StringBuilder  stringMy = new StringBuilder( );
StringMy.append(“Welcome to”);
StringMy.append(“ Java”);

StringBuffer用于处理可变内容的字符串。

append方法在字符串的结尾追加数据
insert方法在指定位置上插入数据
reverse方法翻转字符串
replace方法替换字符
toString方法返回String对象
capacity方法返回缓冲区的容量
length方法返回缓冲区中字符的个数
setLength方法设置缓冲区中字符的长度
charAt方法返回指定位置的字符
setCharAt方法设置指定位置的字符
toString (): 从缓冲区返回字符
capacity() ：返回缓冲区容量。 length <= capacity，当字符串长度超过缓冲区容量，capacity 会自动增加。
length()：返回缓冲区中字符数量
setLength( newLength ) ：设置缓冲区中字符长度
charAt(index) ：返回下标为 index 的字符

所有对StringBuffer对象内容进行修改的方法，都返回指向相同StringBuffer对象的引用

StringBuffer bf = new StringBuffer();
StringBuffer bf1 = bf.append("Welcome "); 
StringBuffer bf2 = bf.append("to ");
StringBuffer bf3 = bf.append("Java");
assert bf==bf1 && bf==bf2 && bf == bf3;
//以上语句可以直接写成：
bf.append("Welcome ").append("to ").append("Java");

格式化控制台输出

JDK1.5开始提供了格式化控制台输出方法

System.out.printf(format, item1, item2, …); //格式化字符串，后面跟要打印的变量列表

格式化字符串

String.format(format, item1, item2, …); //返回一个格式化好了的String

格式描述符：%[argument_index$][flags][width][.precision]conversion，其中

可选的 argument_index 是一个十进制整数，用于表明参数在参数列表中的位置。第一个参数由 "1$" 引用，第二个参数由 "2$" 引用

conversion：应该如何格式化参数的字符

%b 布尔值 %c 字符 %d 十进制整数

%f 浮点数 %e 科学计数法 %s 字符串

String s = String.format(“格式$：%1$d,%2$s”, 99,“abc”); //结果”格式$：99，abc“

package javacourse3.ch4;
public class TestStringFormat {
    public static void main(String[] argv){
        int t=10;
        double f=20.12345678;
       String str=String.format("t=%4d,%-5d,%06d,f=%f,%-10.4f,%10.9f",t,t,t,f,f,f);
       System.out.println(str);
      System.out.printf("t=%2$4d,%2$-5d,%2$06d,f=%1$f,%1$-10.4f,%1$10.9f",f,t);
    }
}
//t=  10,10   ,000010,f=20.123457,20.1235   ,20.123456780
//t=  10,10   ,000010,f=20.123457,20.1235   ,20.123456780