String时间转换【快速】以及java String类API整理

一时失言乱红尘 2022-12-10 10:24 123阅读 0赞

Date now = new Date();
    String str = String.format("%tF", now); // 2014-10-12

### java.lang 类 String ###

我们经常使用 String 类来定义一个字符串。字符串是`常量`，它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。

**1.继承的父类:**

java.lang.Object

**2.所有已实现的接口：**

Serializable, CharSequence, Comparable<String>

**3.字段:使用该字段可以对String进行排序**

1.  `static Comparator<String> CASE_INSENSITIVE_ORDER`
2.  `一个对 String 对象进行排序的 Comparator，作用与 compareToIgnoreCase 相同`

实例：

1.  `public static void main(String[] argv)`
2.  `{`
3.  `String[] rawStrings =`
4.  `{"B", "com.lan", "b", "A", "a", "c", "C"};`
5.  `System.out.println(Arrays.toString(rawStrings));`
6.  `// 使用String.CASE_INSENSITIVE_ORDER进行排序`
7.  `Arrays.sort(rawStrings, String.CASE_INSENSITIVE_ORDER);`
8.  `System.out.println(Arrays.toString(rawStrings));`
9.  `}`

运行结果：

1.  `[B, com.lan, b, A, a, c, C]`
2.  `[A, a, B, b, c, C, com.lan]`

现在只知道可以进行排序，具体后面再研究，先接着写下去。好像可以参考的博客：http://blog.51cto.com/lavasoft/68380

**4.构造方法：**

**(1)默认构造方法：**

1.  `String()`
2.  `初始化一个新创建的 String 对象，使其表示一个空字符序列。`

**(2)使用整个byte数组创建String对象且使用默认字符集：**

1.  `String(byte[] bytes)`
2.  `通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。`
3.  `String(byte[] bytes, int offset, int length)`
4.  `通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。`

**(3)使用整个byte数组创建String对象且指定字符集**

1.  `String(byte[] bytes, String charsetName)`
2.  `通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。`
3.  `String(byte[] bytes, Charset charset)`
4.  `通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。`

**(4)使用byte数组的一部分创建String对象且指定字符集，指定在byte数组中的起始下标和长度:**

1.  `String(byte[] bytes, int offset, int length, Charset charset)`
2.  `通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。`
3.  `String(byte[] bytes, int offset, int length, String charsetName)`
4.  `通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。`

**(5)使用字符数组(char\[\])创建String对象：**

1.  `String(char[] value)`
2.  `分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。`
3.  `String(char[] value, int offset, int count)`
4.  `分配一个新的 String，它包含取自字符数组参数一个子数组的字符。`

**(6)使用Unicode代码点数组创建String对象：**

1.  `String(int[] codePoints, int offset, int count)`
2.  `分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。`

**(7)使用变长字符串StringBuffer,StringBuilder做为参数创建String对象：**

1.  `String(StringBuffer buffer)`
2.  `分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。`
3.  `String(StringBuilder builder)`
4.  `分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。`

**(8)使用String对象作为参数创建String对象,相当于创建一个旧的String对象的副本**

1.  `String(String original)`
2.  `初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。`

**5. 方法**

**(1)字符串的长度，判断字符串是否为空字符串。**

1.  `boolean isEmpty()`
2.  `当且仅当 length() 为 0 时返回 true。`
3.  `int length()`
4.  `返回此字符串的长度。`

**(2)判断该字符串中是否包含指定的字符串，获取字符**

1.  `boolean contains(CharSequence s)`
2.  `当且仅当此字符串包含指定的 char 值序列时，返回 true。`

**(3)返回指定索引处的字符值：**

1.  `char charAt(int index)`
2.  `返回指定索引处的 char 值。`

**(4)字符串连接：**

1.  `String concat(String str)`
2.  `将指定字符串连接到此字符串的结尾。`

**(5)从前向后扫描，返回字符或者字符串参数在该字符串中第一次出现的索引：**

1.  `int indexOf(int ch)`
2.  `返回指定字符在此字符串中第一次出现处的索引。`
3.  `int indexOf(String str)`
4.  `返回指定子字符串在此字符串中第一次出现处的索引。`
5.  `int indexOf(int ch, int fromIndex)`
6.  `返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。`
7.  `int indexOf(String str, int fromIndex)`
8.  `返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。`

**(6)从后向前扫描，返回字符或字符串参数在该字符串中第一次出现的索引：**

1.  `int lastIndexOf(int ch)`
2.  `返回指定字符在此字符串中最后一次出现处的索引。`
3.  `int lastIndexOf(String str)`
4.  `返回指定子字符串在此字符串中最右边出现处的索引。`
5.  `int lastIndexOf(int ch, int fromIndex)`
6.  `返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。`
7.  `int lastIndexOf(String str, int fromIndex)`
8.  `返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。`

**(7)获取该字符串的一部分子字符串：**

1.  `tring substring(int beginIndex)`
2.  `返回一个新的字符串，它是此字符串的一个子字符串。`
3.  `String substring(int beginIndex, int endIndex)`
4.  `返回一个新字符串，它是此字符串的一个子字符串。`

**这个方法经常与上面两个方法String.lastIndexOf()和String.indexOf()方法一起使用，使用这两个方法查找分割的位置，然后再使用String.subString()方法进行分割。**

**(8)获取该字符串的一部分，以字符序列返回：**

1.  `CharSequence subSequence(int beginIndex, int endIndex)`
2.  `返回一个新的字符序列，它是此序列的一个子序列。`

**(9)重写Object的方法：**

1.  `boolean equals(Object anObject)`
2.  `将此字符串与指定的对象比较。`
3.  `int hashCode()`
4.  `返回此字符串的哈希码。`
5.  `String toString()`
6.  `返回此对象本身（它已经是一个字符串！）。`

**(10)实现comparable接口的比较方法：**

1.  `int compareTo(String anotherString)`
2.  `按字典顺序比较两个字符串。`

**(11)不按大小写的比较方法**

1.  `int compareToIgnoreCase(String str)`
2.  `按字典顺序比较两个字符串，不考虑大小写。`
3.  `boolean equalsIgnoreCase(String anotherString)`
4.  `将此 String 与另一个 String 比较，不考虑大小写。`

**(12)基本类型：int,long,float,double,char,char数组，Object(对象)转换成String的方法:String.valueOf(xxx)**

1.  `static String valueOf(int i)`
2.  `返回 int 参数的字符串表示形式。`
3.  `static String valueOf(long l)`
4.  `返回 long 参数的字符串表示形式。`
5.  `static String valueOf(float f)`
6.  `返回 float 参数的字符串表示形式。`
7.  `static String valueOf(double d)`
8.  `返回 double 参数的字符串表示形式。`
9.  `static String valueOf(boolean b)`
10. `返回 boolean 参数的字符串表示形式。`
11. `static String valueOf(char c)`
12. `返回 char 参数的字符串表示形式。`
13. `static String valueOf(char[] data)`
14. `返回 char 数组参数的字符串表示形式。`
15. `static String valueOf(char[] data, int offset, int count)`
16. `返回 char 数组参数的特定子数组的字符串表示形式。`
17. `static String valueOf(Object obj)`
18. `返回 Object 参数的字符串表示形式。`

**(13)把String字符串转换为字节数组：**

1.  `byte[] getBytes()`
2.  `使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。`
3.  `byte[] getBytes(Charset charset)`
4.  `使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。`
5.  `byte[] getBytes(String charsetName)`
6.  `使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。`

**(14)对String中所有的字符都进行大小写转换：**

1.  `String toLowerCase()`
2.  `使用默认语言环境的规则将此 String 中的所有字符都转换为小写。`
3.  `String toLowerCase(Locale locale)`
4.  `使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。`
5.  `String toUpperCase()`
6.  `使用默认语言环境的规则将此 String 中的所有字符都转换为大写。`
7.  `String toUpperCase(Locale locale)`
8.  `使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。`

**(15)判断该字出发是否匹配给定的正则表达式**

1.  `boolean matches(String regex)`
2.  `告知此字符串是否匹配给定的正则表达式。`

**(16)使用正则表达式分割该字符串为字符串数组：**

1.  `String[] split(String regex)`
2.  `根据给定正则表达式的匹配拆分此字符串。`
3.  `String[] split(String regex, int limit)`
4.  `根据匹配给定的正则表达式来拆分此字符串。`

**注意，获取的数组中不包含作为分割符的字符(或字符串)**

**(17)判断字符串的前缀后缀：**

1.  `boolean startsWith(String prefix)`
2.  `测试此字符串是否以指定的前缀开始。`
3.  `boolean startsWith(String prefix, int toffset)`
4.  `测试此字符串从指定索引开始的子字符串是否以指定前缀开始。`
5.  `boolean endsWith(String suffix)`
6.  `测试此字符串是否以指定的后缀结束。`

**(18)该字符串与指定的字符序列或者StringBuffer比较**

1.  `boolean contentEquals(CharSequence cs)`
2.  `将此字符串与指定的 CharSequence 比较。`
3.  `boolean contentEquals(StringBuffer sb)`
4.  `将此字符串与指定的 StringBuffer 比较。`

**(19)把字符数组转换成String**

1.  `static String copyValueOf(char[] data)`
2.  `返回指定数组中表示该字符序列的 String。`
3.  `static String copyValueOf(char[] data, int offset, int count)`
4.  `返回指定数组中表示该字符序列的 String。`

**(20)把该字符串中的字符拷贝到指定的字符数组中去：**

1.  `void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)`
2.  `将字符从此字符串复制到目标字符数组。`

**(21)把该字符串转换成字符数组：**

1.  `char[] toCharArray()`
2.  `将此字符串转换为一个新的字符数组。`

**(22)使用新字符替换字符串中的旧字符：**

1.  `String replace(char oldChar, char newChar)`
2.  `返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。`
3.  `String replace(CharSequence target, CharSequence replacement)`
4.  `使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。`

**(23)使用新子字符串替换该字符串中匹配正则表达式的那些旧子字符串：一个全部替换，一个只替换第一个：**

1.  `String replaceAll(String regex, String replacement)`
2.  `使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。`
3.  `String replaceFirst(String regex, String replacement)`
4.  `使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。`

**(24)把该字符串规范化表示，去掉该字符串的前后空白符： **

1.  `String intern()`
2.  `返回字符串对象的规范化表示形式。`
3.  `String trim()`
4.  `返回字符串的副本，忽略前导空白和尾部空白。`

** (25)Unicode代码点相关：**

1.  `int codePointAt(int index)`
2.  `返回指定索引处的字符（Unicode 代码点）。`
3.  `int codePointBefore(int index)`
4.  `返回指定索引之前的字符（Unicode 代码点）。`
5.  `int codePointCount(int beginIndex, int endIndex)`
6.  `返回此 String 的指定文本范围中的 Unicode 代码点数。`
7.  `int offsetByCodePoints(int index, int codePointOffset)`
8.  `返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。`

**(26)格式化字符串：**

1.  `static String format(Locale l, String format, Object... args)`
2.  `使用指定的语言环境、格式字符串和参数返回一个格式化字符串。`
3.  `static String format(String format, Object... args)`
4.  `使用指定的格式字符串和参数返回一个格式化字符串。`

**(27)判断该字符串的子字符串是否相等：**

1.  `boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)`
2.  `测试两个字符串区域是否相等。`
3.  `boolean regionMatches(int toffset, String other, int ooffset, int len)`
4.