Java面向对象程序设计——第 9 章 常用实用类

​专栏：《Java面向对象程序设计》学习笔记

第 9 章 常用实用类

9.1 String 类

java. lang 包中的 String 类为 final 类，因此用户不能扩展 String 类，即 String 类不可以有子类。

9.1.1 构造 String 对象

String 常量是用双引号（英文输入法输入的双引号）括起的字符序列。

（括号中没有内容也合法）

（单引号括起来的是字符，字符常量！！！）

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

s 中存放着引用， s 的实体是字符序列 we are students ，即 String 对象封装的是字符序列。

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

String tom = new String(s);

引用 String 常量

String 常量也是对象。 Java 把用户程序中的 String 常量放入常量池。 String 常量对象也有自己的引用和实体。

可以把 String 常量的引用赋值给一个 String 变量。

String s,s1,s2;
s = new String("student"); // 对实体的引用
s1 = "student"; // 对常量的引用
s2 = "student"; // 对常量的引用
// 其实这里应该输出其引用，但是String 类重写了 Object 类的 String toString() 方法，所以输出的是对象的实体
System.out.println(s); 
System.out.println(s.toString());
// new构造出的对象的引用每次都是不同的，它是动态的，所以和常量是s1，s2不同
System.out.println(s == s1); // false，不是相同的引用
System.out.println(s2 == s1); // true，都是对常量的引用

用户无法输出 String 对象的引用，输出的是对象的实体。因为 String 类重写了 Object 类的 String toString() 方法。

注：可以这样简单地理解常量池：常量池中的字符序列的“引用”在程序运行期间再也不允许改变。非常量池中的 String 对象的引用可以发生变化。

new构造出的对象的引用每次都是不同的，它是动态的，所以和常量是s1，s2不同

9.1.2 String 类的常用方法

1 public int length(String s)

使用 String 类中的 length() 方法可以获取一个 string 对象封装的字符序列的长度，即 String 对象的字符序列的长度。

String tom = "我们是学生";
int n1,n2;
n1 = tom.length(); // 5
n2 = "你好 abcd".length(); // 7

2 public boolean equals(String s)

比较当前 String 对象的字符序列是否与参数 s 指定的 String 对象的字符序列相同。

相同返回true，反之返回false。

String s1,s2;
s1=new String("we are students");
s2=new String("we are students");
System.out.println(s1.equals(s2));  //输出结果是：true
System.out.println(s1==s2);         //输出结果是：false
String s3,s4; 
s3="how are you";
s4="how are you"; 
System.out.println(s3.equals(s4));  //输出结果是：true
System.out.println(s3==s4);         //输出结果是：true    

（可以简单的理解为，s1.equals(s2)是比较值，s1s2是比较引用/所在地址空间，所以两个 String 对象的值相等不一定代表引用相等，尽量不要使用，使用equals()）

5 public int compareTo(String s)

按字典序与参数的字符序列比较大小。

当前 String 对象的字符序列与 s 的字符序列相比，相同返回值 0，大于返回正值，否则返回负值。

6 public boolean contains(String S)

判断当前 string 对象的字符序列是否含有 s 的字符序列。

7 public int indexOf(String s)

从当前 String 对象的字符序列索引位置 0 开始检索，并返回 首次出现 s 的字符序列的位置。如果没有检索到 s 的字符序列，该方法返回的值是 -1 。

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

8 public String substring(int startpoint)

返回一个新的 String 对象，返回的 String 对象的字符序列是从当前 string 对象的字苻序列索引位置 startpoint 开始（包括位置 startpoint 上的字符） 截取到最后，所得到的字符序列。

String tom2 = "ABCDEFGH";
String ss1 = tom2.substring(2); // 2到最后，即[2,]
String ss2 = tom2.substring(2,5); // 2到5（不包括5），即[2,5)
System.out.println(ss1); // CDEFGH
System.out.println(ss2); // CDE

使用场景

String path = "c:\\book\\javabook\\xml.doc"; // 引用文件要写\\，因为\是转义字符
int index = path.indexOf("\\"); // 2    首次出现\\的位置
index = path.indexOf("\\", index); // 2    首次出现\\的位置，和上面一样
String sub = path.substring(index); // \book\javabook\xml.doc    从上面位置往后截截子串，只有一个\是因为\是转义字符，转义掉了一个\
index = path.lastIndexOf("\\"); // 16    最后出现\\的位置
sub = path.substring(index + 1); // xml.doc    从上面的位置往后截截子串

---

接下来的方法了解即可，用的不是很多

3 public boolean startsWith(String s)、endsWith(String s)

判断当前 String 对象的字符序列 前/后缀 是否是参数 s 指定的 String 对象的字符序列

String = "260221", jerry = "210220"
tom.startsWith("260"); // true 
jerry.startsWith("260"); // false

4 public boolean regionMatches(int first.Start , String other , int orthcrStart , int length)

从当前 String 对象的字符序列 firststart 位置开始，取长度为 length 的一个字符序列，并将这个字符序列和参数 other 的字符序列的一个子字符序列进行比较。

其中， other 的子字符序列是从参数 othertstart 指定的位置开始，取长度为 length 的一个子字符序列。如果两个子字符序列相同，该方法就返回 true ，否则返回 false。

该方法的重载方法（当 b 取 true 时，忽略大小写）：

public regionMatches(boolean b , int first.Start , String other , int orthcrStart , int length)

9 public String trim()

一返回一个 String 对象，返回的 String 对象的字符序列 s 的字符序列去掉前后空格后所得到的字符序列。

9.1.3 String 对象与基本数据的相互转化

String 对象的字符序列转化为数字

public static int parselnt(String s)

该方法返回 int 型数据

如果参数 s 的字符序列中的字符有非“数字"字符，如" 1ab56 "，那么该方法在执行过程中会抛出 NumberFormatException 异常

货币值样式的字符序列转化为数字

String currency = "124,019,578.8768¥";
String str  = "###,###¥"; // 按千分组
DecimalFormat df = new DecimalFormat(str); // 格式化
Number num = df.parse(currency); // 赋值给number类型
double d = num.doubleValue();

数字转化为 String 对象

任何数字和 String 常量 “” 做并运算 “+” 都将得到一个 String 对象

String str = 3.14 + "";

String 类的类方法 public static String valueOf()

实际上应用程序中的 main 方法中的参数 args 能接受用户从键盘输入的字符序列（String[] args）。

int number=8642;
String binaryString=Long.toBinaryString(number); // 转换成二进制形式的字符串
System.out.println(number+"的二进制表示:"+binaryString);
System.out.println(number+"的十六进制表示:"+Long.toString(number,16));

把数字转换成 String对象，就可调用很多的方法。

比如截取小数点后几位、输出浮点数有几位小数。

double pi = 3.1415926;
String numberStr = ""+pi;
int index1 = numberStr.indexOf("."); // 1    . 出现在字符串的位置
String zs = numberStr.substring(0,index1); // 3    截取 . 之前的字符串
String xs = numberStr.substring(index1+1); // 1415926    截取 . 之后的字符串
System.out.println(pi+"有"+zs.length()+"位整数,"+xs.length()+"位小数.");

9.1.4 对象的 String 表示

所有的类都默认是 java.lang 包中 0bject 类的子类或间接子类。

Object 类有一个 public String toString() 方法，一个对象通过调用该方法可以返回一个 String 对象，称这个 string 对象是当前对象的 String 表示。

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

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

0bject 类的子类或间接子类也可以重写 toString() 方法。例如， java. util 包中的 Date 类就重写了 toString 方法，重写的方法返回时间的字符序列表示。

9.1.5 字符序列与字符、字节数组

字符数组

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

将当前 String 对象的字符序列中的一部分字符复制到参数 c 指定的数组中，将 String 对象的字符序列中从索引位置 start 到 end- 1 位置上的字符复制到数组中，并从数组的 offset 处开始存放这些字符。

需要注意的是，必须保证数组 c 能容纳下要被复制的字符。

char[] a, b, c;
String sss = "巴西足球队击败德国足球队";
a = new char[2];
sss.getChars(5, 7, a, 0); // 击败    字符串的 [5,7) 传给字符数组a（从0开始放）
System.out.println(a);

public char[] toCharArray()

String 对象调用该方法，将它的字符序列依次存放在一个字符数组的单元中，并返回该数组的引用。

c ="大家好，很高兴认识大家".toCharArray();
for(char ch:c)
    System.out.print(ch); // 大家好，很高兴认识大家

字节数组

String 类的构造方法 String(byte[]) 用指定的字节数组构造一个 String 对象。

String(byte[] , int offset , int length ）

构造方法用指定的字节数组的一部分，即从数组起始位置 offset 开始取 length 个字节构造一个 String 对象。

public byte() getBytes()

String 对象调用该方法，将它的字符序列转换为平台的默认编码，将编码依次存放在 byte 数组的单元中，并返回 byte 数组的引用。

byte d1[] = "abc你我他".getBytes();
System.out.println("数组d的长度是(gb2312编码,一个汉字占2个字节):" + d1.length);
String s11 = new String(d1, 3, 2); // 你    [3,3+2)
try {
	d1 = "abc你我他".getBytes("utf-8"); // 如果使用utf-8编码，一个汉字占3个字节
	System.out.println("数组d的长度是(utf-8编码,一个汉字占3个字节):" + d1.length);
} catch (Exception exp) {
}

9.2 正则表达式

to be continued~