Java—String类

一、toString()方法

1.public String toString():返回对象的字符串；

2.toString()，返回的是对象的地址值，没有实际意义，需要重写；重写规制：返回对象的属性值；

　　getClass.getName()+'@'+Integer.toHexString(hashCode));

　　getClass.getName----->返回值是完的包名加上类名；

　　'@'为连接符号，无特殊含义；

　　hashCode()------>表示hashCode值；

　　Integer.toHexString()----->表示以十六进制形式来表示；

　　如：Person@1c62a（案例2的输出）

 3.案例1：

 1 class Student02{
 2 
 3     private String name;
 4     private int age;
 5 
 6     public Student02(){}
 7 
 8     public Student02(String name, int age){
 9         this.name = name;
10         this.age = age;
11     }
12 
13     public String getName(){
14         return name;
15     }
16 
17     public int getAge(){
18         return age;
19     }
20 
21     public void setName(String name){
22         this.name = name;
23     }
24 
25     public void setAge(int age){
26         this.age = age;
27     }
28 
29     @Override
30     public String toString(){
31         return name+"\t"+age;
32     }
33 }
34 
35 //测试类
36 public class Test13 {
37     public static void main(String[] args) {
38         //实例化对象
39         Student02 stu = new Student02("lili",18);
40         System.out.println(stu.toString());
41         //自定义对象中重写toString方法，会默认调用toString
42         System.out.println(stu);
43 
44     }
45 }

 二、equals()方法

1.方法：public boolean equals(Object obj)----->表示他某个对象是否与此对象“相等”；

2.解释：

• 对于任何非空引用值x和y，当且仅当x和y引用同一个对象时，此方法才返回true；
• 两个对象的地址值是一样才返回true；

3.equals() 默认比较的是两个对象的地址值，没有实际意义，需要重写；重写规制：比较对象的属性值是否相同；

4.“==” 与 equals() 的比较

• 相同点：都可以用于来比较是否相等；
• 不同点：
  • “==”既可以比较基本数据类型，也可以比较引用数据类型，equals() 只能是比较引用数据类型；
  • “==” 比较基本数据类型，比较的是数值是否相同，比较引用数据类型时，比较的是地址值是否相等；equals() 没有重写之前，比较的对象的地址值是否相同，重写之后，比较的是对象的属性值是否相同；

5.案例2：

 1 //equals()方法
 2 
 3 import java.util.Objects;
 4 
 5 class Person{
 6 
 7     private int pid;
 8     private String name;
 9 
10     public Person(){}
11 
12     public Person(int pid,String name){
13         this.pid = pid;
14         this.name = name;
15     }
16 
17     public int getPid(){
18         return pid;
19     }
20 
21     public void setPid(int pid){
22         this.pid = pid;
23     }
24 
25     public String getName(){
26         return name;
27     }
28 
29     public void setName(String name){
30         this.name = name;
31     }
32     //重写的equals比较的是属性值，没有重写过的equals比较的是地址值
33     @Override
34     public boolean equals(Object o){
35         //若本类Person等于新类o
36         if(this == o)
37             return true;
38         //若类不同或者空
39         if(o==null || getClass()!=o.getClass())
40             return false;
41         //声明Person对象person
42         Person person = (Person)o;
43         return pid==person.pid && Objects.equals(name,person.name);
44     }
45     //重写
46     @Override
47     public int hashCode(){//重写 哈希值函数
48         return Objects.hash(pid,name);
49     }
50 }
51 //测试类
52 public class test01 {
53     public static void main(String[] args) {
54 
55         Person p1 = new Person(1001,"Tom");
56         Person p2 = new Person(1002,"Tony");
57 
58         System.out.println(p1.equals(p2));//输出false 证明p1和p2不等
59 
60         Person p3 =p1;
61         System.out.println(p1);//输出Person@1c62a
62         System.out.println(p3);//输出Person@1c62a
63         System.out.println(p1.equals(p3));//输出true 证明p1和p3相等
64 
65     }
66 }

三、String

1.概念：String类代表字符串；字符串是常量，使用final来进行修饰；不能改变地址值，但能改变对象的内容；String对象时不可变的，因此可以共享；字符串字符值是存在堆内存中，字符串的底层是使用字节数组来进行存储。

2.字符串构造方法：

3.字符常用的方法-判断性

案例3：

 1 //键盘录入一个银行卡余额123456789将字符处理结果为123,456,789
 2 
 3 import java.util.Scanner;
 4 
 5 public class test03 {
 6     public static void main(String[] args) {
 7         //实例化Scanner
 8         Scanner input = new Scanner(System.in);
 9         System.out.println("请输入一串字符");
10 
11         String s = input.next();
12         String [] arrays = new String[s.length()];
13         for (int i=0;i<arrays.length;i++){
14             arrays[i]=(s.charAt(i)+"");
15         }
16         //定义一个字符串来进行拼接
17         String str = "";
18         //循环遍历数组
19         for(int i=arrays.length-1;i>=0;i--){
20             //是3的倍数
21             if(i!=0 && i%3 ==0){
22                 str+=arrays[arrays.length-1-i]+",";
23             }else {
24                 str+=arrays[arrays.length-1-i];
25             }
26         }
27         System.out.println(str);
28     }
29 }

4.String的转换性

案例4：

 1 import java.util.Scanner;
 2 
 3 //键盘录入一串字符，将字符中大写转化成小写，将小写转化为大写，数字以*来代替
 4 public class test04 {
 5     public static void main(String[] args) {
 6         //实例化Scanner
 7         Scanner input = new Scanner(System.in);
 8         System.out.println("请输入一串字符");
 9 
10         String s = input.next();
11         //将字符串转化为字符数组
12         char [] arrays = s.toCharArray();
13         //定义一个字符串来进行拼接
14         String str = "";
15         //使用循环遍历
16         for (int i=0;i<arrays.length;i++){
17             //判断
18             if (arrays[i]>='a'&&arrays[i]<='z'){
19                 str+=(arrays[i]+"").toUpperCase();
20             }else if(arrays[i]>='A'&&arrays[i]<='Z'){
21                 str+=(arrays[i]+"").toLowerCase();
22             }else {
23                 str+="*";
24             }
25         }
26         System.out.println(str);
27     }
28 }

5. StringBuffer 

（1）.概念：StringBuffer是线程安全的可变字符序列，一个类似于String的字符串缓冲区；StringBuffer上的主要操作是append和insert方法，可以改变该序列的长度和内容；StringBuffer在多线程中线程安全但效率低；

（2）.StringBuffer与String比较：

• String是不可变字符序列，StringBuffer是可变字符序列；
• String操作字符串的效率比较低，StringBuffer操作字符串的效率比较高

（3）.StringBuffer与StringBuilder比较：

• 版本不一样，StringBuffer为1.0，StringBuilder为1.5；
• 多线程安全性不一样，StringBuffer是多线程安全的，StringBuilder是多线程不安全的；
• 操作字符串效率不一样，StringBuffer效率低，StringBuilder效率高；

（4）.StringBuffer的构造方法

（5）.常用的方法

（6）StringBuffer与String之间相互转换

　　StringBuffer---->String

　　　　public String toString()【用toString()方法】

　　　　public String(StringBuffer buffer)【构造方法】

　　String----->StringBuffer

　　　　public StringBuffer(String str)【构造方法】

　　　　new StringBuffer().append(String str);