文章目录

（一）Object类（1）Object的概念，子类继承了Object的方法（2）getClass()方法getName()（3）equals()方法hashCode()（4）toString()方法 （二）String类（1）创建一个字符串对象（2）String类中的常用方法1.boolean equals()方法2.char charAt(int pos)//得出pos位置的字符3.int length()//得出字符串长度4.String[] split()//按照分隔符建立字符串数组5.trim()//去掉字符两端空格6.Sting substring(int begin,intend)//截取字符串7.startsWith("字符")//判断字符串是否以"字符"开头。8.endsWith("字符")//判断字符串是否以"字符"为结尾。9.compareTo()和compareTolgnoreCse()//比较字符串10.indexOf()//c查找字符或者子串第一次出现的地方11.lastindexOf()//查找字符或者子串最后一次出现的地方12.substring()/字符串截取13.concat()//连接两个字符串，方法之一14.replace()//替换，用一个字符在调用字符串中所有出现某个字符的地方进行替换15.字符串的拼接16.comepareTo()和compareTolgnoreCase()//比较字符17.indexOf()和lastindexOf18.toLowerCase(),toUpperCase(),转换为小写，转换为大写（）19.Valueof（基本数据类型）20.getBytes()//将字符存储在字节数组中21.toCharArray()//将字符串转换为char类型的数组 （三）包装类（1）包装类的概念（2）包装类与String类以及基本数据类型之间的相互转换1.字符串与基本数据类型之间的转换2.基本数据类型和封装类3.字符串和封装类

（一）Object类

（1）Object的概念，子类继承了Object的方法

1.java.lang.Object是java中所有类的直接父类或者间接父类。 例子：class A{} class B extends A{} 2.所有类的对象都可以声明成Object引用。 例子：Object o1=new A() Object o2=new B()

（2）getClass()方法getName()

getClass()方法：返回一个对象的实际类型，实质上是该对象所对应类的class文件对象

public class Student { public static void main(String[] args) { Student stu=new Student(); stu.hashCode(); Object ob=stu; //所有类的对象都可以声明成Object引用 Object ob1=new Student(); System.out.println(ob1.getClass()); //getClass()方法，返回一个对象的实际类型，实质上是该对象所对应类的Class文件对象 System.out.println(stu.getClass()); //Class对象，实质是Class文件，即该类编译之后产生的二进制字节码文件 //获取gatClass文件的方法以下两种 //1.通过对象.getClass Class c1=stu.getClass(); //2.通过类名.Class Class c2=Student.class; //getName()f返回Class对象的全类名 System.out.println(c1.getName()); //getSimpleName():返回Class对象的简类名 System.out.println(c1.getSimpleName()); } public boolean equals(Object obj) { return true; } } 输出结果： ob1.getClass：class com.soft.object.Student stu.getClass：class com.soft.object.Student c1.getName：com.soft.object.Student c1.getSimpleName：Student

（3）equals()方法hashCode()

作用：在equsals()方法对于字符串类型（String）的作用是比较两个字符串是否相等，在用到类的实例对象中（Object）的时候未重写的情况下和"=="等价，比较的是两个对象的地址值，在进行Object.equals重写后比较的是2个对象的属性内容是否相等，例：

public class Animal { String name; int age; //通过含参构造方法传参，更改方法属性。 public Animal(String name, int age) { this.name = name; this.age = age; } //重写hashCode()函数 // @Override // public int hashCode() { // final int prime = 31; // int result = 1; // result = prime * result + age; // result = prime * result + ((name == null) ? 0 : name.hashCode()); // return result; // } //重写equals()Object函数 // @Override // public boolean equals(Object obj) { // if (this == obj) // return true; // if (obj == null) // return false; // if (getClass() != obj.getClass()) // return false; // Animal other = (Animal) obj; // if (age != other.age) // return false; // if (name == null) { // if (other.name != null) // return false; // } else if (!name.equals(other.name)) // return false; // return true; // } }

这里写一个测试类来测试一下

public class AnimalTest { public static void main(String[] args) { String i="ss"; String j=new String("ss"); Animal ani1=new Animal("mark",12); Animal ani2=new Animal("mark",12); System.out.println(j.equals(i)); System.out.println(ani1.equals(ani2));//比较属性是否相等 System.out.println(ani1.hashCode()); } //手动重写Object，equals()方法此时一定会返回true // public boolean equals(Object obj) // { // return true; // } } 未重写equals()函数以及hashCode(),编译输出的结果： true false 2018699554 此时判断字符串为相等，两个实例对象的地址不相等。哈希值为2018699554。 进行重写后输出结果： true true 3345410 此时判断字符串为相等，两个实例对象的属性内容相等。哈希值为3345410更加准确。

（4）toString()方法

public static void main(String[] args) { Student stu=new Student(); stu.hashCode();//通过ctrl键可查看方法 Object ob=stu; Object ob1=new Student(); //toString():Object中方法，输出对象的全类名以及对象的hasCode的十六进制 System.out.println(ob.toString()); System.out.println(stu.toString()); System.out.println(ob1.toString()); } //重写Object，equals方法 public boolean equals(Object obj){ return true; } } 输出结果： com.soft.object.Student@7852e922 com.soft.object.Student@7852e922 com.soft.object.Student@4e25154f 由结果可知ob，ob1，stu都是指向子类的对象，且ob和stu所存地址一样。 //在类中重写toString()方法主要作用是返回该对象的所有属性值的字符串形式 @Override public String toString() { return "Animal [name=" + name + ", age=" + age + "]"; } 在测试中的输出结果： Animal [name=mark, age=12]

（二）String类

（1）创建一个字符串对象

String：在遇到双引号（" "）后会在字符串常量池中创建有序的字符序列，是一个常量不可更改。 两种创建字符串的方式

1.String str="abc"; //声明式创建。默认的创建方式。 -声明式创建字符串的方式，字符串存储的位置在字符串常量池中。 当再次以这种方式创建字符串，则会直接去字符串常量池中进项匹配，如果又就直接引用，没有就直接在字符串常量池中进行创建。 2.String str = new String(“”); //创建String的实例对象，new时会在堆和栈中开辟新的内存地址。栈中存放的是对的首地址，堆中存放的是具体值。

（2）String类中的常用方法

1.boolean equals()方法

public static void main(String[] args) { String i="ss"; String j=new String("ss"); // String j=new String("ss"); // j="ss"; System.out.println(i==j); System.out.println(j.equals(i)); } 输出结果： false true 若将j改变为程序中屏蔽掉的历程此时输出结果： true true 说明此时j声明的堆中并未存放东西，当我们再次对j进行赋值时候此时j指向字符串常量池，并未指向堆地址。

2.char charAt(int pos)//得出pos位置的字符

3.int length()//得出字符串长度

4.String[] split()//按照分隔符建立字符串数组

5.trim()//去掉字符两端空格

6.Sting substring(int begin,intend)//截取字符串

7.startsWith(“字符”)//判断字符串是否以"字符"开头。

8.endsWith(“字符”)//判断字符串是否以"字符"为结尾。

9.compareTo()和compareTolgnoreCse()//比较字符串

10.indexOf()//c查找字符或者子串第一次出现的地方

11.lastindexOf()//查找字符或者子串最后一次出现的地方

12.substring()/字符串截取

13.concat()//连接两个字符串，方法之一

14.replace()//替换，用一个字符在调用字符串中所有出现某个字符的地方进行替换

这里写一个测试代码，供参考。

public static void main(String[] args) { // TODO Auto-generated method stub String str1="abc"; String str2="abc"; String str3=new String("abc"); //charAt(int):返回指定位置的字符 char c=str1.charAt(1); System.out.println(c); // length():返回字符串 的长度 System.out.println(str1.length()); //split("分隔符"):将字符串按照分隔符分割为一个字符串类型的数组 String str4="What:are:words"; String[] arrays=str4.split(":"); for(String s:arrays) { System.out.print(s+"\t"); } String str5=" hello word "; System.out.println(str5.trim()); // startsWith("参数")，判断字符串是否以参数值作为开头。 System.out.println(str4.startsWith("What")); //endsWith("参数")，判断字符串是否以参数值作为结尾。 System.out.println(str4.endsWith("words")); //substring()对字符串进行截取，第一个从下标2到最后，第二个从2到下标4-1. String str6=str4.substring(2); String str7=str4.substring(2, 4); System.out.println(str6); System.out.println(str7); System.out.println(str4.replace("a", "b")); }

最终输出结果

b 3 What are words hello word true true at:are:words at Whbt:bre:words 这里不做解释，请自行对照

15.字符串的拼接

这里介绍String拼接的几种方式，以及StringBuffer、StringBuilder，拼接的方式以及三种类型的差异区别。 String,StringBuffer,StringBuider:

String：String是不可变长量，一点定义赋值后不能改变常量池或堆中的内容，这样会产生大量不可用字符。使用“+”或者String类中的concat()方法进行拼接。是一种引用类型，可以声明对象。StringBuffer:可变长度的字符串，在进行字符串拼接后始终是一个对象，StringBuffer中的方法都是用synchronized进行修饰的表示线程安全的。StringBuider是线程不安全对象，线程不安全但效率相对高一些。 线程安全对象：用synchronized进行修饰的方法或代码块。一次只允许一个线程进行访问。线程安全，但效率低。 线程不安全对象：没有使用synchronized进行修饰，线程不安全，效率高。 下面给出演示代码： public static void main(String[] args) { // TODO Auto-generated method stub String str9="java"; String str10="bean"; System.out.println(str9.toString()); //直接使用“+”号链接即可 String str11=str9+str10; System.out.println(str11); String str12="javabean"; //此处经过测试知道字符串通过“+”号拼接相当于new String("javabean");一个对象 System.out.println(str11==str12); //concat():拼接字符串，该方法与“+”号一样会创建一个新的字符串指向堆中,,并非字符串常量池中 String str13=str9.concat(str10); System.out.println(str12==str13); //StringBuffer:在进行字符串拼接后始终是同一个对象, StringBuffer sb = new StringBuffer("Hello"); StringBuffer sb1=sb; sb.append(" world"); //toString()函数输出字符串的内容 System.out.println(sb.toString()); System.out.println(sb); System.out.println(sb1.toString()); System.out.println(sb==sb1); //StringBuider可变长度的字符串，在进行字符串拼接后始终是一个对象， StringBuilder sbu=new StringBuilder("tomcat"); sbu.append("good"); System.out.println(sbu.toString()); System.out.println(sbu); } 输出结果： java javabean false false Hello world Hello world Hello world true tomcatgood tomcatgood

16.comepareTo()和compareTolgnoreCase()//比较字符

compareTo:按照字典顺序比较两个字符串 str.comparTo(str1) 比较规则：1.先按照字符序列进行逐位比较，只返回第一次出现的不同字符的差值。 如果差值为正整数，表示str1在前，str在后。 2.如果两个字符串长度不同，先按照第一比较规则进行，如果第一次比较规则比完仍然没有不同的字符，则直接 返回字符串的长度差值，如果差值为正数说明长的在前，短的在后。

public static void main(String[] args) { String str="helloa"; String str1="helL"; System.out.println(str.compareTo(str1)); System.out.println(str.compareToIgnoreCase(str1)); }

17.indexOf()和lastindexOf

indexOf(ch)：返回字符以及子字符串第一次出现的下标，若没有的话会返回“-1”，找第二或者第三个只需嵌套使用即可。lastindexOf(ch)：返回字符以及子字符串最后一次出现的下标，若没有的话会返回“-1”，找第二或者第三个只需嵌套使用即可。indexof(int)int指对应字符的ASCII码

18.toLowerCase(),toUpperCase(),转换为小写，转换为大写（）

public static void main(String[] args) { String str5=" Hello Word "; String str6=str.toLowerCase(); String str7=str.toUpperCase(); } 注意：汉字无法转接大小字符，会

19.Valueof（基本数据类型）

可以将基本数据类型转换为字符串

System.out.println( String.valueOf(1234));

20.getBytes()//将字符存储在字节数组中

byte[] by= str8.getBytes();//转化为对应的ASCII码值，汉子也可以转化，只不过会输出负数，表示溢出。

21.toCharArray()//将字符串转换为char类型的数组

char[] array = str8.toCharArray();

（三）包装类

（1）包装类的概念

概念：封装对应基本数据类型的属性以及相关操作方法。 作业：让java更好的面向对象。 基本数据类型包装类例子：

//获得一个基本数据类型的字节数，位数，最大值，最小值。 println(Byte.BYTES+"\t"+Byte.SIZE+"\t"+Byte.MAX_VALUE+"\t"+Byte.MIN_VALUE);

（2）包装类与String类以及基本数据类型之间的相互转换

1.字符串与基本数据类型之间的转换

基本数据类型转字符串： 1.通过字符串拼接基本数据类型：String str=" "+10086; 2.使用String类中的valueOf()方法，String str=String.valueOf(10086); 3.将基本数据类型转换为封装类对象，通过封装类对象.toString();(效率低，不推荐)

Integer inte=i; String str = inte.toString();

字符串转基本数据类型： 1.通过基本对应数据类型封装类.parseXXX();

int i= Integer.parseInte(str);

2.通过封装类，先将字符串转为封装类对象。然后通过拆箱操作或者XXXValue();

String str="123"; //Integer inte =new Integer(str)//将字符串转为封装类 // int i = inte;//这一步自动的 int i=Integer.valueOf(str);//这一步等价上面自动拆箱了 int i=Integer.valueOf(str).intValue();

2.基本数据类型和封装类

封装类转基本数据类型😭 效果一样 1.自动拆箱

Integer inte =new Integer(123); int i = inte; //自动拆箱

2.封装类对象.XXXvalue()

Integer inte =new Integer(123); int i = inte.intvalue();

基本数据类型转封装类😭 1.自动装箱

Integer inte1=100;//这一步的100是在哪里算不算装箱 //int i=100; //Integer inte1=i;

2.通过封装类.valueOf(基本数据类型)

Integer inte=Integer.valueOf(基本数据类型);

3.通过封装类的构造方法

Integer inte=new Integer(123);

3.字符串和封装类

封装类转字符串 通过封装对象.toString();

Integer inte=new Integer("123"或123)//; String str=inte.toString();

字符串转封装类😭 通过封装类.valueOf(字符串参数);

String str="123"; Integer inte = Integer.valueOf(str); //这个是字符串转封装类吗，??? String str="123"; Integer inte=new Integer(str);//构造方法

简单的小测试。

Integer inte=new Integer(123); Integer inte10=123; Integer inte1=new Integer(123); Integer inte2=123; System.out.println(inte == inte1); System.out.println(inte == inte2); System.out.println(inte10 == inte2); 输出结果： false false true 123