popo

java-doc-字符串

Posted on Edited on

String

在Java中，字符串也是一连串的字符。但是，不像其他语言作为字符数组实现字符串，Java将字符串实现为Strng类型的对象。当创建String对象时，创建的字符串不能修改。也就是说，一旦创建一个String对象，就不能改变这个字符串中包含的字符。当每次需要已存在字符串的修改版本时，会创建包含修改后内容的新String对象。原始字符串保持不变。使用这种方式的原因是：实现固定的、不能修改的字符串与实现能够修改的相比效率更高。对那些需要修改的字符串，可以选择使用StringBuffer和StringBuilder。

  • 常用方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
// 获取指定索引的字符
// @where:希望获取的字符的索引
// return:索引对应的字符
char charAt(int where)

// 提取多个字符
// @sourceStart:指定子串的开始索引
// @sourceEnd:指定子串末尾之后下一个字符索引
// @target[]:存储获取字符的数组
// @targetStart:数组用于存储字符的起始索引
void getChars(int sourceStart, int sourceEnd, char target[], int targetStart)

// 将字符串转换成字节数组并返回
// return:字节的数组
byte[] getBytes()

// 将字符串转成字符数组并返回
// return:字符数组
char[] toCharArray()

// 比较两个字符串是否相等，大小写敏感
// @str:要比较的字符串
// return:如果字符串以相同的顺序包含相同的字符，返回true；否则false。
boolean equals(Object str)

// 比较两个字符串是否相等，大小写不敏感
// @str:要比较的字符串
// return:如果字符串以相同的顺序包含相同的字符，返回true；否则false。
boolean equalsIgnoreCase(String str)

// 比较字符串的某部分与另一个字符串中的另一个特定部分
// @startIndex:比较部分开始的索引位置
// @str2:要比较的字符串
// @str2StartIndex:字符串2比较开始的索引位置
// @numChars:比较的子串长度
boolean regionMatches(int startIndex, String str2, int str2StartIndex, int numChars)
// @ignoreCase:是否忽略大小写
boolean regionMatches(boolean ignoreCase, int startIndex, String str2, int str2StartIndex, int numChars)

// 判断字符串是否以某个字符串开始
// @str:要判断字符串
// return:是返回true；否则false
boolean startsWith(String str)

// 判断字符串是否以某个字符串结束
// @str:要判断的字符串
// return:是返回true；否则false
boolean endsWith(String str)

// 字符串与另外一个字符串大小比较
// @str:要比较的字符串
// return:调用字符串大于str返回大于0，小于str返回小于0，相等返回0
int compareTo(String str)

// 查找字符或子串第一次出现时的索引
// @ch:要查找的字符
// return:找到字符返回索引，否则返回-1表示失败
int indexOf(int ch)
// @str:要查找的字符串
int indexOf(String str)
// @startIndex:指定开始查找的索引
int indexOf(int ch, int startIndex)
int indexOf(String str, int startIndex)

// 查找字符或子串最后一次出现时的索引
// @ch:要查找的字符
// return:找到字符返回索引，否则返回-1表示失败
int lastIndexOf(int ch)
// @str:要查找的字符串
int lastIndexOf(String str)
// @startIndex:指定开始查找的索引
int lastIndexOf(int ch, int startIndex)
int lastIndexOf(String str, int startIndex)

// 截取指定位置开始到末尾的字符串并返回
// @startIndex:截取开始的索引
// return:字符串副本
String substring(int startIndex)
// @endIndex:截取指定的末尾索引
String subString(int startIndex, int endIndex)

// 连接另一个字符串到尾部并返回
// @str:要连接的字符串
// return:新的字符串副本
String concat(String str)

// 将字符串指定的字符替换成新的字符
// @original:要被替换的字符
// @replacement:新替换的字符
// return:替换后的字符串副本
String replace(char original, char replacement)

// 移除开头和结尾所有空白的字符并返回
// return:新字符串的副本
String trim()

// 将字符串所有大写字符都转换成小写字符并返回
// return:新字符串的副本
String toLowerCase()

// 将字符串所有小写字符都转换成大写字符并返回
// return:新字符串的副本
String topUpperCase()

// 用分割符连接多个字符串并返回
// @delim:分隔符
// @strs:要连接的字符串序列
// return:连接后的新字符副本
static String join(CharSequence delim, CharSequence ...strs)

// 返回指定位置的字符
// @i:要查找的索引
// return:字符或-1
int codePointAt(int i)

// 返回指定位置前的字符
// @i:要查找的索引
// return:字符或-1
int codePointBefore(int i)

// 返回指定区间的字符数量
// @start:计算的起始索引
// @end:计算的结束索引
// return:字符数量
int codePointCount(int start, int end)

// 判断字符串是否包含指定的字符串
// @str:要检测的字符串
// return:包含返回true；否则false
boolean contains(CharSequence str)

// 判断字符串与另一个字符是否相同
// @str:要判断的字符串
// return:相同返回true；否则false
boolean contentEquals(CharSequence str)

// 返回格式化后的字符串
// @fmtstr:格式化样式
// @args:格式化参数
// return:处理后的字符串的副本
static String format(String fmtstr, Object ...args)
static String format(Locale loc, String fmtstr, Object ...args)

// 判断字符串长度是否为0
// return:为0返回true；否则false
boolean isEmpty()

// 正则表达式匹配检测
// @regExp:要匹配的正则表达式
// return:匹配返回true；否则false
boolean matches(string regExp)

// 就算指定索引偏移一定数量后的索引
// @start:起始索引
// @num:偏移数量
// return:索引
int offsetByCodePoints(int start, int num)

// 用新的字符串替换第一正则表达式匹配的字符串
// @regExp:正则表达式
// @newStr:要替换的字符串
// return:替换后的字符串的副本
String replaceFirst(String regExp, String newStr)

// 用新的字符串替换所有正则表达式匹配的字符串
// @regExp:正则表达式
// @newStr:要替换的字符串
// return:替换后的字符串的副本
String replaceAll(String regExp, String newStr)

// 用正则表达式把字符串里面的匹配的所有字符串拆分出来
// @regExp:要匹配的正则表达式
// return:拆分后的字符串集合
String[] split(Strinig regExp)
// @max:分解的块数，如果max是负数，就完全分解调用字符串。否则，如果max包含非零值，那么结果数组中的最后一个元素是调用字符串的剩余部分。如果max是0，就完全分解调用字符串，但是不会包含后跟的空白字符串。
String[] split(String regEXP, int max)

// 返回字符串指定范围的子串
// @startIndex:字符串起始索引
// @stopIndex:字符串结束索引
// return:子串
CharSequence subSequence(int startIndex, int stopIndex)

equals()方法与“==”运算符执行不同的操作，equals()比较的是内容，“==”比较的是引用。

1
2
3
4
5
6
7
8
9
10
public static void TestString() 
{
    String str1 = "String1";
    String str2 = "String2";
    String str3 = str1;

    System.out.println("TestString length:" + str1.length());
    System.out.println("TestString charAt:" + str1.charAt(3));
    System.out.println("TestString equial:" + str1.equals(str3));
}

StringBuffer

StringBuffer表示可增长，可写入的字符串序列，是可修改的字符串。允许在中间插入字符和子串，或者在末尾追加字符和子串。StringBuffer能够自动增长，从而为这类添加操作准备空间，并且通常预先分配比实际需要更多的字符空间，以运行空间增长。

StringBuffer是线程安全

  • 构造函数
方法 描述
StringBuffer() 默认
StringBuffer(int size) 指定初始缓存大小
StringBuffer(String str) 指定初始化字符串内容，并预留16个字符空间
StringBuffer(CharSequence chars) 指定初始化字符序列，并预留16字符空间
  • 常用方法
方法 描述
length() 返回字符串缓冲器内容的长度
capacity() 返回字符串缓冲区的总大小
ensureCapacity() 指定预先分配的空间
setLength() 设置字符串的长度。当增加字符串的大小时，会向末尾添加null字符。如果减少字符大小，那超出的长度的字符会丢失。
charAt() 获取指定索引的字符
setCharAt() 设置指定索引的字符为新的字符
getChars() 获取自定区间的子串
append() 追加格子形式的字符串到尾部
insert() 在指定位置插入字符串
reverse() 字符串反向
delete() 删除指定范围的内容
deleteCharAt() 删除指定位置的字符
replace() 用字符串替换指定范围的内容
substring() 截取指定范围的字符串

StringBuilder

StringBuilder与StringBuffer类似，只有一个重要的区别：StringBuilder不是同步的，这意味着它不是线程安全的。StringBuilder的优势在于能得到跟高的性能。但是，如果可以修改的字符串被多个线程修改，并且没有使用其他同步措施就必须使用StringBuffer，而不能使用StringBuilder。

StringTokenizer

StringTokenizer用于解析格式化的字符串。StringTokenizer类提供了解析过程中第一步，通常称为字符分析器或扫描器。StringTokenizer实现了Enumeration接口。所以，给定输入字符串，就可以使用StringTokenizer枚举字符串中包含的每个标记。

  • 构造函数
方法 描述
StringTokenizer(String str) 使用默认的界定符
StringTokenizer(String str, String delimiters) 指定界定符的字符串
StringTokenizer(String str, String delimiters, boolean delimAsToken) 指定是否要返回界定符
  • StringTokenizer类定义的方法
方法 描述
int countTokens() 该方法使用当前的一组分隔符，确定还有多少标记需要解析并返回结果
boolean hasMoreElements() 如果字符串中还有一个或多个标记，就返回true；否则返回false
boolean hasMoreTokens() 如果字符串中还有一个或多个标记，就返回true；否则返回false
Object nextElement() 作为Object对象返回下一个标记
String nextToken() 作为String对象返回下一个标记
String nextToken(String delimiters) 作为String对象返回下一个标记，并将界定符字符串设置为由delimiters指定的字符串 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.StringTokenizer;

public class LearnStringTokenizer1 
{
    static String in = "title1=TitleName1;" +
                        "title2=TitleName2;" + 
                        "title2=TitleName3";
    
    public static void main(String args[])
    {
        StringTokenizer st = new StringTokenizer(in, "=;");
        
        while(st.hasMoreTokens()) {
            String key = st.nextToken();
            String val = st.nextToken();
            System.out.println(key + "   " + val);
        }
    }
}

Formatter

Formatter用于格式化输出。

  • 构造函数
方法 描述
Formatter()
Formatter(Appendable buf) buf用于存储格式化输出的子串
Formatter(Appendable buf, Locale loc) buf用于存储格式化输出的子串,loc指定地区
Formatter(String filename) filename指定用于接收格式化输出的文件的名称
Formatter(String filename, String charset) filename指定用于接收格式化输出的文件的名称，charset指定字符集
Formatter(File outF) outF指定一个引用，指向用于接收输出的已打开文件
Formatter(outputStream outStrm) outStrm指定一个引用，指向将要接收输出的输出流
  • Formatter类定义的方法
方法 描述
void close() 关闭调用Formatter对象。这回导致Formatter对象使用的所有资源被释放。Formatter对象在关闭之后，将不能再使用。如果试图使用已关闭的Formatter对象，会导致FormatterClosedException异常
void flush() 刷新格式化缓冲区，这会导致将缓冲区中当前的所有输出都写入目标中。该方法主要用于与文件绑定的Formatter对象
Formatter format(String fmtString, Object …args) 根据fmtString中包含的格式化说明符，格式化args传递过来的参数。返回调用对象
Formatter format(Locale loc, String fmtString, Object …args) 根据fmtString中包含的格式化说明符，格式化args传递过来的参数。为格式化操作使用由loc指定的地区。返回调用对象
IOException ioException() 如果作为输出目标的底层对象抛出IOException异常，就返回该异常；否则返回null
Locale locale() 返回调用对象的地区
Appednable out() 返回指向底层对象的引用，底层对象是输出的目标
String toString() 返回包含格式化输出的String对象
  • 格式化说明符
格式说明符 适用的转换
%a %A 浮点型十六进制值
%g %G 基于被格式化的值和精度使用%e或%f
%b %B 布尔型
%o 八进制整数
%c 字符
%n 插入一个换行符
%d 十进制整数
%s %S 字符串
%h %H 参数的哈希码
%t %T 时间和日期
%e %E 科学计数法
%x %X 十六进制整数
%f 十进制整数
%% 插入一个%符号
  • 格式标志
标志 效果
- 左对齐
# 可选的转换格式
0 使用0而不是空格填充输出
空格 在输出的正数前面加一个空格
+ 在输出的正数前面加一个+号
, 在数值中包含组分割符
( 将负值放在括号内

最小字段宽度

%符号和格式化代转换代码之间的整数被作为最小字段宽度说明符，这回使用空格填充输出，以确保输出达到特定的最小长度。几遍字符串或数字长于最小宽度，也仍然会完整的输出。默认使用空格进行填充。如果希望使用0进行填充，可以在自动宽度说明符之前放置一个0。字段宽度说明符可以用于除%n以外的所有格式说明符。

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.*;

public class LearnFormatter2 
{
    public static void main(String args[])
    {
        Formatter fmt = new Formatter();
        fmt.format("|%f|%n|%12f|%n|%012f|", 10.12345, 10.123445, 10.123456);
        System.out.println(fmt);
        fmt.close();
    }
}

指定精度

精度说明符可以应用于%f、%e、%g以及%s格式说明符。精度说明符位于最小字段宽度说明符之后，由一个小数点以及紧跟其后的整数构成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.*;

public class LearnFormatter3 
{
    public static void main(String args[])
    {
        Formatter fmt = new Formatter();
        
        fmt.format("%.4f", 123.1234567);
        System.out.println(fmt);
        fmt.close();
        
        fmt = new Formatter();
        fmt.format("%16.2e", 123.1234567);
        System.out.println(fmt);
        fmt.close();
        
        fmt = new Formatter();
        fmt.format("%.15s", "Froatting with java is now easy");
        System.out.println(fmt);
        fmt.close();
    }
}

日期格式化

  • 时间和日期格式后缀
后缀 替换内容
a 星期名简称
A 星期名全称
b 月份名简称
B 月份名全称
c 标准日期和时间字符串，格式为：天 月份 日期 小时:分钟:秒数 时区 年
C 年份的前两个数字
d 每月日期的十进制格式(01-31)
D 月/日/年
e 每月日期的十进制格式(1-31)
F 年-月-日
h 月份名简称
H 小时(00-23)
I 小时(01-12)
j 每年日期的十进制格式(001-366)
k 小时(0-23)
l 小时(1-12)
L 毫秒(000-999)
m 月份的十进制格式(01-13)
M 分钟的十进制格式(00-59)
N 纳秒(000000000-99999999)
p 以小写形式表达本地时间的AM和PM
Q 自1970年1月1日以来经历的毫秒数
r 小时:分钟:秒数(12小时格式)
R 小时:分钟:描述(24小时格式)
S 秒(00-60)
s 自1970年1月1日(UTC)以来经历的毫秒数
T 小时:分钟:秒数(24小时格式)
y 以十进制表示的年份(00-99)，不含世纪部分(即年份的前两位)
Y 以十进制表示的年份(0001-9999)，包含世纪部分
z 相对于UTC的时差
Z 时区名 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util.*;

public class LearnFormatter1 
{
    public static void main(String args[])
    {
        Formatter fmt = new Formatter();
        Calendar cal = Calendar.getInstance();
        
        fmt.format("%tr", cal);
        System.out.println(fmt);
        fmt.close();
        
        fmt = new Formatter();
        fmt.format("tc", cal);
        System.out.println(fmt);
        fmt.close();
        
        fmt = new Formatter();
        fmt.format("%tl:%tM", cal, cal);
        System.out.println(fmt);
        fmt.close();
        
        fmt = new Formatter();
        fmt.format("%tB %tb %tm", cal, cal, cal);
        System.out.println(fmt);
        fmt.close();
    }
}

使用参数索引

正常情况下，格式说明符和参数按顺序从左向右进行匹配。但是，使用参数索引，可以显示地控制哪个参数与哪个格式说明符相匹配。

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.Formatter;

public class LearnFormatter5 
{
    public static void main(String args[])
    {
        Formatter fmt = new Formatter();
        fmt.format("%3$d %1$d %2$d %2$d", 1, 2, 3);
        System.out.println(fmt);
        fmt.close();
    }
}

Scanner

Scanner类用于格式化输入，并将输入转换成相应的二进制形式。Scanner可以用于从控制台、文件、字符串或任何实现了Readable或ReadableByteChanner接口的源读取内容。

构造函数

方法 描述
Scanner(File from) 创建的Scanner对象使用from指定的文件作为输入源
Scanner(File from, String charset) 创建的Scanner对象使用from指定的文件作为输入源，并且文件的编码方式由charset指定
Scanner(InputStream from) 创建的Scanner对象使用from指定的流作为输入源
Scanner(InputStream from, String charset) 创建的Scanner对象使用from指定的流作为输入源，并且流的编码方式由charset指定
Scanner(Path from) 创建的Scanner对象使用from指定的文件作为输入源
Scanner(Path from, String charset) 创建的Scanner对象使用from指定的文件作为输入源，并且文件的编码方式由charSet指定
Scanner(Readable from) 创建的Scanner对象使用from指定的Readable对象作为输入源
Scanner(ReadableByteChannel from) 创建的Scanner对象使用from指定的ReadableByteChannel作为输入源
Scanner(ReadableByteChannel from, String charset) 创建的Scanner对象使用from指定的ReadableByteChannel作为输入源，编码方式由charset指定
Scanner(String from) 创建的Scanner对象使用from指定的字符串作为输入源 
1
2
3
4
5
6
// 读取文件
FileReader fin = new FileReader("Test.txt");
Scanner src = new Scanner(fin);

// 标准输入读取
Scanner conin = new Scanner(System.in);
  • Scanner类的方法
方法 描述
boolean hasNext() … 如果有可以读取的任意类型的标记，就返回true；否则返回false
String next() … 从输入源返回下一个任意类型的标记
Scanner useDelimiter(String pattern) … 指定界定符组的正则表达式
String findInLine(String pattern) … 搜索指定的模式
String findWithHorizon(Pattern pattern, int count) … 视图在后续count个字符中查找指定的模式。如果找到返回匹配的模式；否则返回null，如果count是0，就在全文搜索
Scanner skip(Pattern pattern) … 跳过某个模式 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.util.Scanner;

public class LearnScanner1 
{
    public static void main(String args[])
    {
        Scanner conin = new Scanner(System.in);
        
        int count = 0;
        double sum = 0.0;
        
        System.out.println("Enter numbers to average.");
        
        while(conin.hasNext()) {
            if(conin.hasNextDouble()) {
                sum += conin.nextDouble();
                count ++;
            } else {
                String str = conin.next();
                if(str.equals("done")) {
                    break;
                } else {
                    System.out.println("Data format error.");
                    return;
                }
            }
        }
        
        conin.close();
        System.out.println("Average is " + sum / count);
    }
}

正则表达式

正则表达式是描述字符序列的一串字符。这种通用描述被称为模式，可以用于在其他字符序列中查找匹配，正则表达式可以指定通配符、一组字符和各种量词。因此，可以指定一种通用形式的正则表达式，以匹配多种不同的特定字符系列。

Pattern

  • Pattern声明的方法
方法 描述
static Pattern compile(String pattern) pattern是希望使用的正则表达式。comple()方法将pattern中的字符串转换成一种模式，Matcher可以使用这种模式进行匹配。返回包含模式的Pattern对象
Matcher mathcer(CharSequence str) str是将要用于匹配模式的字符串
String[] split(CharSequence str) 使用匹配的字符将str拆分成多个字符串
static boolean matches(String pattern, CharSequence str) 如果patter与str匹配，就返回true；否则返回false

量词

量词决定表达式将被匹配的次数

量词 描述
+ 匹配一次或多次
* 匹配零次或多次
? 匹配零次或一次 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class LearnReg1 
{
    public static void main(String args[])
    {
        Pattern pat = Pattern.compile("W+");
        Matcher mat = pat.matcher("W WW WWW");
        
        while(mat.find()) {
            System.out.println("Match:" + mat.group());
        }
    }
}

Matcher

  • Matcher声明的方法
方法 描述
boolean matches() 如果字符串序列与模式匹配，就返回true；否则返回false
boolean find() 如果存在匹配的子序列，就返回true；否则返回false，可以重复调用这个方法，以查找所有匹配的子序列，find()每次调用都是从上一次离开的位置开始
String group() 获得包含最后一个匹配序列的字符串，如果存在匹配的字符串就返回；如果没有就抛出IllegalStateException异常
int start() 获得输入序列中当前匹配的索引，如果不存在匹配的，就抛出IllegalStateException异常
int end() 获得当前匹配序列末尾之后下一个字符的索引，如果不存在匹配的，就抛出IllegalStateException异常
String replaceAll(String newStr) 使用newStr替换所有匹配的序列，并返回新字符串的副本