16：String类

最新推荐文章于 2022-04-02 20:26:02 发布

东风不来

最新推荐文章于 2022-04-02 20:26:02 发布

阅读量155

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/u010953706/article/details/79481115

版权

java 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

/*
String类，在java.lang包中，直接继承Object
public final class String //不能被继承
extends Object
impelments Serializable,Comparable,CharSequence

String 类代表字符串。Java 程序中的所有字符串字面值（如 ” abc” ）都作为此类的实例实现。
字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。

class Demo
{
public static void main(String [] args)
{
String s=new String();
String s1= “abc”; //s1是一个类类型变量，所以字符串是一个特殊的对象；
//字符串最大特点，一但被初始化就不可以被改变；
//s1在内存中有一个对象；
String s2= new String( “abc”);
//S2在内存中有两个对象；
System. out.println(s1==s2);
System. out.println(s1.equals(s2));
//String 类复写了Object类中equal方法；
//该方法用于判断字符串是否相同；
}
}

/*
结果是
false
true
*/
class Demo {
public static void main(String [] args)
{
String s1= “abc”;
String s2= new String( “abc”);
String s3= “abc”;
System.out.println(s1==s2);
System.out.println(s1==s3);
}
}
/*
分析：首先对于字符串类型，不能被修改，认为是常量；
对于定义形式为s1的字符串，首先“ abc”首先保存到常量池中，然后让s1执行常量池中的“ abc”；
当定义s3时，“ abc”已经存在，只想和s1中一样的位置；
s2指向的位置是new出的对象的位置；
*/

/*
String 类适用于描述字符串事物。
那么它提供了多个对字符串进行的操作。

  常见操作：
        1：获取。
              1.1 返回字符串长度       int length();
              1.2根据位置返回位置上某个字符       char charAt(int index);
              1.3根据字符获取该字符在字符串中位置。
                     int indextOf(int ch):返回的是 ch在字符串第一次出现的位置； ch的类型是ascll码；
                     int indexOf(int ch,int formIndex);从fromIndex位置开始；

                     int lastIndextOf(String str):返回的是str 在字符串第一次出现的位置；
                     int lastIndexOf(int ch,String formIndex);从fromIndex位置开始；
                    以上四个没有找到会返回-1；

                     int lastIndextOf(int ch)
                     int indexOf(int ch,int formIndex);

                     int lastIndextOf(String str):
                     int lastIndexOf(int ch,String formIndex);
                    和前四个相同用法相同，从尾向前查找
        2：判断。
              2.1字符串中是否包含某一个字串
                    boolean contains( str):
                          对于indexOf( str):索引str第一次出现的位置，如果返回-1，表示 str不在字符串中存在
              2.2字符中是否有内容
                    boolean isEmpty() :原理（判断长度是否为0）
              2.3字符串是否是以指定内容开头
                    boolean startWith(String str)
              2.4字符串是否是以指定内容结尾
                    boolean endWith(String str)
              2.5判断字符串的内容是否相同，复写了Object类中的equals方法
                    Boolean equals（ str）
              2.6判断内容是否相同，忽略大小写
                    boolean equalsIgnoreCase（）；

*/
class Demo {
public static void method_is()
{
String str= “ArrayDemo.java”;
sop(str.startsWith(“Array”));
sop(str.endsWith(“.java”));
sop(str.contains(“Demo”));
}
public static void method_get()
{
String str= “abcdeac”;
sop(str.length()); //长度
sop(str.charAt(4));
sop(str.indexOf(‘j’));
sop(str.indexOf(“ae”));
sop(str.indexOf(‘k’,2));
}
public static void main(String [] args)
{
method_is();

  }

  public static void sop(Object obj)
  {
        System. out.println(obj);
  }

}

字符串是一个特殊的对象
字符串一旦初始化就不可以被改变。
String表示一个UTF-16格式的字符串。
String 类提供处理 Unicode 代码点（即字符）和 Unicode 代码单元（即 char 值）的方法。
String str=“abc”；

字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。

String类适用于描述字符串事物，它提供了多个方法对字符串进行操作。
常见操作？
1：获取
获取字符长度length();方法
根据位置获取位置上某个字符
charcharAt(int index)
返回指定索引处的 char 值。

intindexOf(int ch)
返回指定字符在此字符串中第一次出现处的索引。<返回-1表示不存在> intindexOf(int ch, int fromIndex)
返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 intindexOf(String str)
返回指定子字符串在此字符串中第一次出现处的索引。 intindexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。

反向索引：
intlastIndexOf(int ch)
返回指定字符在此字符串中最后一次出现处的索引。<返回-1表示不存在> intlastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 intlastIndexOf(String str)
返回指定子字符串在此字符串中最右边出现处的索引。 intlastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

intcodePointAt(int index)
返回指定索引处的字符（Unicode 代码点）。《返回的是该字符的编码》
2：判断
booleanendsWith(String suffix)
测试此字符串是否以指定的后缀结束。
booleanisEmpty()
当且仅当 length() 为 0 时返回 true。
booleanstartsWith(String prefix)
测试此字符串是否以指定的前缀开始。 booleanstartsWith(String prefix, int toffset)
测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
booleancontains(CharSequence s)
当且仅当此字符串包含指定的 char 值序列<字符串>时，返回 true。

将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。
booleanequals(Object anObject)
将此字符串与指定的对象比较。

将此 String 与另一个 String 比较，不考虑大小写。如果两个字符串的长度相同，并且其中的相应字符都相等（忽略大小写），则认为这两个字符串是相等的。
booleanequalsIgnoreCase(String anotherString)
将此 String 与另一个 String 比较，不考虑大小写。

3:转换
将字符数组转换成字符串
String(char[] value)
分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。<将字符数组转换成字符串>String(char[] value, int offset, int count)
分配一个新的 String，它包含取自字符数组参数一个子数组的字符。<将字符数组的部分转换成字符串>
将字节数组转成字符串
String(byte[] bytes)
通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。String(byte[] bytes, Charset charset)
通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
将字符数组转成字符串
static StringcopyValueOf(char[] data)
返回指定数组中表示该字符序列的 String。<将字符数组转换成字符串>static StringcopyValueOf(char[] data, int offset, int count)
返回指定数组中表示该字符序列的 String。

将基本数据类型转换成String
static StringvalueOf(boolean b)
返回 boolean 参数的字符串表示形式。static StringvalueOf(char c)
返回 char 参数的字符串表示形式。static StringvalueOf(char[] data)
返回 char 数组参数的字符串表示形式。static StringvalueOf(char[] data, int offset, int count)
返回 char 数组参数的特定子数组的字符串表示形式。static StringvalueOf(double d)
返回 double 参数的字符串表示形式。static StringvalueOf(float f)
返回 float 参数的字符串表示形式。static StringvalueOf(int i)
返回 int 参数的字符串表示形式。static StringvalueOf(long l)
返回 long 参数的字符串表示形式。static StringvalueOf(Object obj)
返回 Object 参数的字符串表示形式。
将字符串转成字符数组
char[]toCharArray()
将此字符串转换为一个新的字符数组。
将字节串转成字符数组
byte[]getBytes()
使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 byte[]getBytes(Charset charset)
使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。《参数表示可以指定编码表》

4：替换
字符串在初始化之后不会被改变，这里返回的是一个新串。；如果替换的对象不存在，返回的还是原串；
Stringreplace(char oldChar, char newChar)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 Stringreplace(CharSequence target, CharSequence replacement)
使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。《可以替换字符串》

5：切割
String[]split(String regex)
根据给定正则表达式的匹配拆分此字符串。 String[]split(String regex, int limit)
根据匹配给定的正则表达式来拆分此字符串。

6：获取字串
CharSequencesubSequence(int beginIndex, int endIndex)
返回一个新的字符序列，它是此序列的一个子序列。 Stringsubstring(int beginIndex)
返回一个新的字符串，它是此字符串的一个子字符串。《从beginindex到结尾》 Stringsubstring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。《含头不含尾》

7：转换
StringtoLowerCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 StringtoLowerCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
StringtoUpperCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 StringtoUpperCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
8：将字符串两端的多个字符串去除
Stringtrim()
返回字符串的副本，忽略前导空白和尾部空白。
9：将两个字符串进行自然顺序的比较。
intcompareTo(String anotherString)
按字典顺序比较两个字符串。 intcompareToIgnoreCase(String str)
按字典顺序比较两个字符串，不考虑大小写。
如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。

StrinngBuffer是一个字符串缓冲区，被final修饰，不能被继承
是一个容器
1：长度是可变化的
2：可以字节操作多个数据类型
3：可以通过toString方法变成字符串。

线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
C create U update R read D delete是一个容器
1：存储
StringBufferappend(boolean b)
将 boolean 参数的字符串表示形式追加到序列。 StringBufferappend(char c)
将 char 参数的字符串表示形式追加到此序列。 StringBufferappend(char[] str)
将 char 数组参数的字符串表示形式追加到此序列。 StringBufferappend(char[] str, int offset, int len)
将 char 数组参数的子数组的字符串表示形式追加到此序列。 StringBufferappend(CharSequence s)
将指定的 CharSequence 追加到该序列。 StringBufferappend(CharSequence s, int start, int end)
将指定 CharSequence 的子序列追加到此序列。 StringBufferappend(double d)
将 double 参数的字符串表示形式追加到此序列。 StringBufferappend(float f)
将 float 参数的字符串表示形式追加到此序列。 StringBufferappend(int i)
将 int 参数的字符串表示形式追加到此序列。 StringBufferappend(long lng)
将 long 参数的字符串表示形式追加到此序列。 StringBufferappend(Object obj)
追加 Object 参数的字符串表示形式。 StringBufferappend(String str)
将指定的字符串追加到此字符序列。 StringBufferappend(StringBuffer sb)
将指定的 StringBuffer 追加到此序列中。

StringBufferinsert(int offset, boolean b)
将 boolean 参数的字符串表示形式插入此序列中。 StringBufferinsert(int offset, char c)
将 char 参数的字符串表示形式插入此序列中。 StringBufferinsert(int offset, char[] str)
将 char 数组参数的字符串表示形式插入此序列中。 StringBufferinsert(int index, char[] str, int offset, int len)
将数组参数 str 的子数组的字符串表示形式插入此序列中。 StringBufferinsert(int dstOffset, CharSequence s)
将指定 CharSequence 插入此序列中。 StringBufferinsert(int dstOffset, CharSequence s, int start, int end)
将指定 CharSequence 的子序列插入此序列中。 StringBufferinsert(int offset, double d)
将 double 参数的字符串表示形式插入此序列中。 StringBufferinsert(int offset, float f)
将 float 参数的字符串表示形式插入此序列中。 StringBufferinsert(int offset, int i)
将 int 参数的字符串表示形式插入此序列中。 StringBufferinsert(int offset, long l)
将 long 参数的字符串表示形式插入此序列中。 StringBufferinsert(int offset, Object obj)
将 Object 参数的字符串表示形式插入此字符序列中。 StringBufferinsert(int offset, String str)
将字符串插入此字符序列中。

2：删除
StringBufferdelete(int start, int end)
移除此序列的子字符串中的字符。 StringBufferdeleteCharAt(int index)
移除此序列指定位置的 char。
3：获取
charcharAt(int index)
返回此序列中指定索引处的 char 值。 intindexOf(String str)
返回第一次出现的指定子字符串在该字符串中的索引。 intindexOf(String str, int fromIndex)
从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
intlength()
返回长度（字符数）。
Stringsubstring(int start)
返回一个新的 String，它包含此字符序列当前所包含的字符子序列。 Stringsubstring(int start, int end)
返回一个新的 String，它包含此序列当前所包含的字符子序列。 StringtoString()
返回此序列中数据的字符串表示形式。

4：修改
StringBufferreplace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符。 StringBufferreverse()
将此字符序列用其反转形式取代。
voidsetCharAt(int index, char ch)
将给定索引处的字符设置为 ch。 voidsetLength(int newLength)
设置字符序列的长度。
voidgetChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此序列复制到目标字符数组 dst。

StrinngBuilder是一个字符串缓冲区，被final修饰，不能被继承
一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
StringBuffer是线程同步的。
StringBuilder是线程不同步的，单线程；
开发建议使用StringBuffer；
升级因素：
1：提高效率
2：简化书写
3：提高安全性

东风不来

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
16：String类

/* String类，在java.lang包中，直接继承Object public final class String //不能被继承 extends Object impelments Serializable,Comparable,CharSequenceString 类代表字符串。Java 程序中的所有字符串字面值（如 ” abc” ）都作为此类的实例实现。...
复制链接

扫一扫