String类的常用方法

String类的常用方法

1. String类的两种实例化方式

• 1 . 直接赋值，在堆上分配空间。

String str = "hello";

• 2 . 传统方法。通过构造方法实例化String类对象

String str1 = new String("Hello");

2.采用String类提供的equals方法。

public boolean equals(String anotherString):成员方法
                str1.equals(anotherString);
eg:
public class Demo2{
    public static void main(String[] args){
        String str1 = "hello";
        String str2 = "hello";
        System.out.println(str1==str2);
    }
}
运行结果：true
eg:
public class Demo2{
    public static void main(String[] args){
        String str1 = "hello";
        String str2 = new String("hello");
        System.out.println(str1==str2);
    }
}
运行结果：false
eg:
public class Demo2{
    public static void main(String[] args){
        String str1 = "hello";
        String str2 = new String("hello");
        System.out.println(str1.equals(str2));
    }
}
运行结果：true
1234567891011121314151617181920212223242526272829

3.== he和equals方法区别

1. ”==”：进行的数值比较，比较的是两个字符串对象的内存地址数值。
2. “equals（）”：可以进行字符串内容的比较

4.字符串常量（“ “）是String的匿名对象

public class Demo2{
    public static void main(String[] args){
        String str1 = "hello";
        System.out.println("hello".equals(str1));
    }
}
如果能够运行成功，说明字符串“hello”是String的匿名对象
运行结果：true
12345678

小tips:以后开发中，如果要判断用户输入的字符串是否等同于特定字符串，一定要将特定字符串（String常量）写在前面，避免空指针异常（NullPointerException）。

System.out.println(str1.equals(“hello”)); 错误

System.out.println(“hello”.equals(str1)); 正确

5.字符串共享问题

JVM底层会自动维护一个字符串的对象池（对象数组），如果现在采用直接赋值的形式进行String的对象实例化，该对象会自动保存在这个对象池中。如果下次继续使用直接赋值的模式声明String对象，此时对象池中若有指定内容，则直接引用；如果没有，则开辟新的堆空间后将其保存在对象池中供下次使用。

public class Demo2{
    public static void main(String[] args){
        String str1 = "hello";
        String str2 = "hello";
        String str3 = "hello";

        System.out.println(str1==str2);
        System.out.println(str2==str3);
        System.out.println(str1==str3);
    }
}
运行结果：
true
true
true

public class Demo2{
    public static void main(String[] args){
        String str1 = "hello";
        String str2 = new String("hello");
        System.out.println(str1==str2);
    }
}
new新开辟了空间
运行结果：false
12345678910111213141516171819202122232425

手工入池（本地方法）：

public native String intern();
eg:
public class Demo2{
    public static void main(String[] args){
        String str1 = "hello";
        String str2 = new String("hello").intern();
        System.out.println(str1==str2);
    }
}
运行结果：true
12345678910

1. 直接赋值：只会开辟一块堆内存空间，并且该字符串对象可以自动保存在对象池中以供下次使用。
2. 构造方法：会开辟两块堆内存空间，其中一块成为垃圾空间，不会自动保存在对象池中，可以使用intern()方法手工入池。 因此，我们一般会采取第一种方式即直接赋值。

6.字符串一旦定义后不可变。

public class Demo2{
    public static void main(String[] args){
        String str1 = "hello";
        str1 += " world";
        str1 += "!!!";
        System.out.println(str1);
    }
}
运行结果：hello world!!!
其实字符串没有变化，是字符串的引用一直在改变，而且会形成大量的垃圾空间。
12345678910

原则：

1. 字符串使用就采用直接赋值。
2. 字符串比较就使用equals()实现。
3. 字符串别改变太多。（字符串”+“操作，不超过三次）。

7.字符与字符串的相互转换

a.将字符数组转为字符串 -> String

--public String(char[] value) //将数组中的全部字符转换成字符串
eg:
public class Demo2{
    public static void main(String[] args){
        char[] data = new char[]{'h','e','l','l','o'};
        String str = new String(data);
        System.out.println(str);
    }
}
运行结果：hello

--public String(char[] value,int offset,int count) //将数组中的部分字符转换成字符串
eg:
public class Demo2{
    public static void main(String[] args){
        char[] data = new char[]{'h','e','l','l','o'};
        String str = new String(data,2,3);
        System.out.println(str);
    }
}
运行结果：llo
123456789101112131415161718192021

b.将字符串转为单个字符

public char charAt(int index)：
eg:
public class Demo2{
    public static void main(String[] args){
        char c = "hello".charAt(4);
        System.out.println(c);
    }
}
运行结果：o
123456789

c.将字符串变为字符数组:String -> char[]

--public char[] tocharArray();
eg:
public class Demo2{
    public static void main(String[] args){
        char[] c = "hello".toCharArray();
        System.out.println(c);
        System.out.println("hello".length()); //字符串是方法
        System.out.println(c.length);   //数组是属性
    }
}
运行结果：
hello
5
5
1234567891011121314

8.取得字符串长度：public int length();

//判断一个字符串是否由数字组成
public class Demo2{
    public static void main(String[] args){
        System.out.println(isNumber("123"));
    }
    public static boolean isNumber(String str){
        char[] data = str.toCharArray();
        for(int i=0;i<data.length;i++){
            if(data[i]<'0' || data[i]>'9'){
                return false;
            }
        }
        return true;
    }  
}
运行结果：
true
1234567891011121314151617

9.字节（Byte)与字符串

a.将字节数组转换为字符串（重点）

byte[] ->String

public String(byte[]  value)
eg:
public class Demo2{
    public static void main(String[] args){
        byte[] data = new byte[]{1,2,3,4,5};
        String str = new String(data);
        System.out.println(str);
    }
}

public String(byte[]  value,int offset,int count)//将字节数组的指定字节转换成字符串
123456789101112131415

b.将字符串转为字节数组 (重点)

String->byte[]

public byte[] getBytes();
eg:
public class Demo2{
    public static void main(String[] args){
        String str = "hello";
        byte[] data = str.getBytes();
        for(byte b:data){
            System.out.print(b+"、");
        }
    }
}
运行结果：
104、101、108、108、111、
123456789101112131415

c.将字符串按指定编码转为字节数组

public byte[] getBytes(String charsetName);
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str = "你好世界";
        byte[] data = str.getBytes("gbk");
        for(byte b: data){
            System.out.print(b+"、");
        }
        System.out.print(new String(data));
    }
}
（根据编码的不同，结果也相应不同）
运行结果：
-60、-29、-70、-61、-54、-64、-67、-25、你好世界
123456789101112131415

10.字符串比较

a.不区分大小写相等比较

public boolean equalsIgnoreCase(String anotherString)
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str = "hello";
        System.out.println("Hello".equalsIgnoreCase(str));
    }
}
运行结果：true
123456789

b. 比较两个字符串大小

public int compareTo(String anotherString)

I.返回大于0：表示大于比较对象

II.返回等于0：两者相等

III.返回小于0：表示小于比较对象
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str1 = "Hello";
        String str2 = "hellO";
        System.out.println(str1.compareTo(str2));
    }
}
只要遇到第一个不同的进行比较。
运行结果：
-32
【支持中文】
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str1 = "张";
        String str2 = "李";
        System.out.println(str1.compareTo(str2));
    }
}
运行结果：
-2094
12345678910111213141516171819202122232425262728

11.字符串查找（重点）

1. 判断str在本字符串中是否存在

    public boolean contains(String str) :判断str在本字符串中是否存在
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "he";
            String str2 = "hello";
            System.out.println(str2.contains(str1));
        }
    }
    运行结果：true
12345678910

1. 判断是否以指定字符串开头

 public boolean startsWith(String str) : 判断是否以指定字符串开头
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "he";
            String str2 = "hello";
            System.out.println(str2.startsWith(str1));
        }
    }
    运行结果：true
12345678910

1. 从指定位置判断是否以指定字符串开头

  public boolean startsWith(String str，int index) : 从指定位置判断是否以指定字符串开头
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "ll";
            String str2 = "hello";
            System.out.println(str2.startsWith(str1,2));
        }
    }
    运行结果：true
12345678910

1. 判断是否以指定字符串结尾

 public boolean endsWith(String str) : 判断是否以指定字符串结尾
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "lo";
            String str2 = "hello";
            System.out.println(str2.endsWith(str1));
        }
    }
    运行结果：true

1234567891011

12.字符串替换

public String replaceAll(String regex,String replacement) ：替换所有指定内容
public String replaceFirst(String regex,String replacement) :替换首个内容
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str = "hello world";
        System.out.println(str.replaceAll("l","-"));//替换所有指定内容
        System.out.println(str.replaceFirst("l","-"));//替换首个内容
    }
}
运行结果：he--o wor-d
运行结果：he-lo world
123456789101112

13.字符串拆分

——public String[] split(String regex) :将字符串按照指定格式全部拆分
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str1 = "hello world hello java";
        String[] result = str1.split(" ");
        for(String str:result){
            System.out.println(str);
        }
    }
}
运行结果：
hello
world
hello
java

——public String[] split(String regex，int limit) : 将字符串部分拆分，数组长度为limit
eg：
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str1 = "hello world hello java";
        String[] result = str1.split(" ",2);
        for(String str:result){
            System.out.println(str);
        }
    }
}
运行结果：
hello
world hello java

//拆分地址
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str1 = "196.168.1.1";
        String[] result = str1.split("\\."); //注意这里有转义字符
        for(String str:result){
            System.out.println(str);
        }
    }
}
运行结果：
196
168
1
1
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647

15.字符串截取

public String substring(int beginIndex):[ 从指定位置截取到字符串的结尾
public String substring(int beginIndex,int endIndex):[) 截取部分内容

eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str1 = "helloworld";
        String result1 = str1.substring(3);//从指定位置截取到字符串的结尾
        String result2 = str1.substring(3,6);//截取部分内容
        System.out.println(result1);
        System.out.println(result2);
    }
}
运行结果：
loworld
low
12345678910111213141516

16.String 类其他方法

a.去掉左右空格

public String trim();
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str1 = " hello world ";
        String result = str1.trim();
        System.out.print(result);
    }
}
运行结果：
 hello world
1234567891011

b.转大小写

public String toUpperCase(); //小写转大写
public String toLowerCase(); //大写转小写
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str1 = "hello world";
        String str2 = "HELLO WORLD";
        String result1 = str1.toUpperCase();
        System.out.println(result1);
        System.out.println(str2.toLowerCase());
    }
}
运行结果：
HELLO WORLD
hello world
123456789101112131415

String类并没有提供首字母大写操作，需要自己实现。

public class Demo2{
    public static void main(String[] args) throws Exception{
        String str = "hello";
        System.out.print(firstCase(str));
    }
    public static String firstCase(String str){
        return str.substring(0,1).toUpperCase() + str.substring(1);
    }
}
运行结果：
Hello
1234567891011

c.判断字符串是否为空(只能判断是否为空字符串，而不是null;

public boolean isEmpty();
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
        String str1 = "";
        String str2 = "haha";
        System.out.println(str1.isEmpty());
        System.out.println(str2.isEmpty());
    }
}
运行结果：
true
false

if(str == null || str.isEmpty())  //完整的空字符串的方法
123456789101112131415

StringBuffer

StringBuilder

a.字符串修改

public StringBuffer append(各种数据类型)
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
       StringBuffer sb = new StringBuffer();
       sb.append("hello").append("world").append(10);
       System.out.println(sb);
    }
}
运行结果：
helloworld10
1234567891011

b.StringBuffer <->String

I.String -> StringBuffer
调用StringBuffer的构造方法或append()

II.StringBuffer.toString();
 StringBuffer.toString();
 
 eg:
 public class Demo2{
    public static void main(String[] args) throws Exception{
       StringBuffer sb = new StringBuffer("hello");
       String result = sb.toString();
       System.out.println(result.isEmpty());
    }
}
运行结果：
false
12345678910111213141516

c.字符串反转

public StringBuffer reverse();
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
       StringBuffer sb = new StringBuffer("helloworld");
       sb.reverse();
       System.out.println(sb);
    }
}
运行结果：
dlrowolleh

【支持中文】
public class Demo2{
    public static void main(String[] args) throws Exception{
       StringBuffer sb = new StringBuffer("你好");
       sb.reverse();
       System.out.println(sb);
    }
}
运行结果：
好你
12345678910111213141516171819202122

d.删除指定范围的数据

public StringBuffer delete(int start,int end);
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
       StringBuffer sb = new StringBuffer("hello world");
       sb.delete(0,4);
       System.out.println(sb);
    }
}
运行结果：
o world
1234567891011

e.插入数据

public StringBuffer insert(int offset,各种数据类型)
eg:
public class Demo2{
    public static void main(String[] args) throws Exception{
       StringBuffer sb = new StringBuffer("hello world");;
       System.out.println(sb.insert(5,"（你好）"));
    }
}
运行结果：
hello（你好） world
12345678910

I.string的内容不可修改，而两只sb可以修改内容（append）
II.StringBuffer 采用同步处理，线程安全，效率较低。

StringBuilder采用异步处理，线程不安全，效率较高，String"+"底层会将String -> StringBulider