Java中的String、Object、包装类的用法

1.String类

1.1 String类的两种实例化方式

a. 直接赋值

String str = "hello world!";
System.out.println(str);

b. 传统方法（通过构造方法实例化类）
String类中的其中一种构造方法：

public String(String str);

//传统方法
String str = new String("hello baby!");
System.out.println(str);

1.2 字符串相等比较

"=="本身是进行数值比较的，如果现在用于对象比较，那么所比较的就应该是两个对象所保存的内存地址数值比较，而并没有比较对象的内容。
那么要想比较内容，则必须采用String类提供的equals方法。

public boolean equals(String anotherString);//成员方法
str1.equals(anotherString);

String str1 = "hello";
String str = new Strnig("hello");
System.out.println(str1.equals(str));

注意：解释String类"=="与"equals"的区别

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

1.3 字符串常量" "是String的匿名对象

在任何的语言的底层，都不会提供有直接的字符串类型。现在所谓的字符串只是高级语言提供给用户方便开发的支持而已。在java之中，本身也没有直接提供字符串常量的概念，所有使用“”定义的内容本质上来讲都是String的匿名对象。
小tips:在日后的开发过程之中，如果要判断用户输入的字符串是否等同于特定字符串，一定要将特定字符串写在前面，避免

NullPointerException

String str = null ; // 假设由用户输入
System.out.println(Hello.equals(str1));

1.4 String类的设计使用了共享设计模式

在JVM底层实际上会自动维护一个对象池（字符串对象池），如果现在采用了直接赋值的模式进行String类的对象实例化操作，那么该实例化对象（字符串内容）将自动保存到这个对象池之中。如果下次继续使用直接赋值的模式声明String类对象，此时对象池之中如若有指定内容，将直接进行引用；如若没有，则开辟新的字符串对象而后将其保存在对象池之中以供下次使用。所谓的对象池就是一个对象数组（目的就是减少开销）

// 手工入池（本地方法）：
public native String intern();  //成语方法，通过对象调用

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

1.5 字符串常量不可变更

字符串一旦定义后不可改变

1.6 字符与字符串的相互转换

a. 将字符数组转为字符串
char[ ] -> String
public String(char[ ] value)
public String(char[ ] value,int offset,int count)
b.将字符串转为单个字符
String -> char
public char charAt(int index)    //取得指定索引的字符
c. 将字符串变为字符数组
String -> char[ ]
public char[ ] toCharArray();
取得字符串长度：public int length();

1.7 字节（byte）与字符串

a. 将字节数组转换为字符串（*******）
byte -> String
public String(String[ ] value)
public String(String[ ] value,int offset,int count)
b.将字符串转为字节数组（******）
Steing - > byte[ ]
public byte[ ]  getBytes();
c.将字符串按照指定编码转为字节数组
public byte[ ]  getBytes(String charsetName);   //传入编码形式

1.8.字符串比较

a. 不区分大小写相等比较
public boolean equalsIgnoreCase(String.anotherString);
b.比较两个字符串大小
public int compareTo(String.anotherString);
1. 相等：返回0.
2. 小于：返回内容小于0.
3. 大于：返回内容大于0。

** 1.9 字符串查找 **

public boolean contains(String str);        //判断str是否在本字符串中存在
public boolean startsWith(String str);      //判断是否以指定字符串开头
public boolean startsWith(String str，int index);  //从指定位置开始判断是否以指定字符串开头
public boolean endsWith(String str);       //判断是否以指定字符串结尾

1.10 字符串替换

public String replaceAll(String regex,String replacement);
//替换所有指定内容
public String replaceFirst(String regex,String replacement);
//替换首个内容

1.11 字符串拆分

public String[ ]  split(String regex);   //将字符串按照指定格式全部拆分
public String[ ]  split(String regex , int limit);  //将字符串部分拆分

1.12 字符串截取

public String substring(int beginIndex);                         //从指定位置街区到字符串结尾 [ ;
public String substring(int beginIndex, int endIndex);   //截取部分内容 [ );左闭右开

1.13 String类其他方法

a. 去掉左右空格
public String trim();
b. 转大小写
public String toUpperCase( );
public String toLowerCase( );
c. 判断字符串是否为空(只能判断是否为空字符串而不是null)
public boolean isEmpty( );

练习：首字母大写代码

public class Test4{
public static void main(String[] args){
System.out.println(firstCase("helloworld!"));
}
public static String firstCase(String str){
return str.substring(0,1).toUpperCase()+str.substring(1);
}
}

1.14 两只sb类（面试）- 方便进行字符串的修改 - java.long 包，基础包自动导入

StringBuffer
StringBuilder
a. 字符串修改
public StringBuffer  append(各种数据类型)；
b. StringBuffer <-> String
1. String -> StringBuffer
调用StringBuffer的构造方法
2. StringBuffer -> String
StringBuffer.toString( );
c. 字符串反转
public StringBuffer reverse( );
d. 删除指定范围的数据
public StringBuffer delete(int start, int end);
e. 插入数据
public StringBuffer insert(int offset, 各种数据类型)；

两只 sb 类的比较

1. String 的内容不可修改，而两只sb可以改内容（append）
2. StringBuffer采用同步处理，线程安全，效率较低。
   StringBuilder采用异步处理，线程不安全，效率较高，Strng"+"底层会将String -> StringBuilder

2. Object类（RealFather）

Object 是Java 默认提供的类

1. Java除了Object 类，所有的类都存在继承关系，默认会继承Object父类，所有类对象都可以通过Object类进行接收

2.1 取得对象信息

直接使用对象输出，默认输出一个地址编码，如果现在输出的是

String

对象，此时输出字符串内容而非地址，原因就在于

String

类覆写了

Object

的

toString（）

方法。

System.out.println( )

，系统输出默认会调用对象的

toString( )

。如果默认给出的

toString（）

功能不足（不想输出地址而是输出本类信息 ），需要在子类中覆写

toString

方法。

2.2 对象比较 - equals

class Person{
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public boolean equals(Object obj){
//判断obj是否是Person类实例
if(!(obj instanceof Person)){
return false;
}
//判断当前对象是否是自己
if(obj == this){
return true;
}
//向下转型
Person per = (Person) obj;
return per.name.equals(this.name) && (this.age == per.age);
}
}
public class Test4{
public static void main(String[] args){
Person per1 = new Person("蛋哥",40);
Person per2 = new Person("蛋哥",40);
System.out.println(per1.equals(per2));
}
}

2.3 接收引用数据类型

Object 可以接收所有引用数据类型，包括：类、数组、接口

3. 包装类

包装类就是将基本数据类型封装到类中

3.1 分类

a. 对象性包装类（Object 的直接子类）：Boolean(boolean)、Character(char)
b. 数值型包装类（Number的直接子类），存在数值转换异常：Byte(byte)、Short(short)、
Long(long)、Double(double)、Float(float)、Integer(int)

3.2 装箱与拆箱 - 基本数据类型与相应包装类的数据处理

装箱：将基本数据类型变为包装类对象，利用每个包装类提供的构造方法实现装箱。
拆箱：将包装类中包装的基本数据类型值取出，利用Number类提供的xxValue实现拆箱处理

阿里编码规范：所有相同类型的包装类对象之间的值比较，全部使用equals方法比较。
说明:
对于 Integer var = ? 在-128 至 127 范围内的赋值，Integer 对象是在Integer常量池中产生，会复用已有对象，这个区间内的 Integer 值可以直接使用==进行判断，但是这个区间之外的所有数据，都会在堆上产生，并不会复用已有对象，这是一个大坑，推荐使用 equals 方法进行判断。

使用 int 还是 Integer ？
a. 【强制】所有的 POJO 类(简单Java类，Bean)属性必须使用包装数据类型。
简单Java类：只有基本属性、构造方法、getter、setter
b. 【强制】RPC 方法(远程方法调用)的返回值和参数必须使用包装数据类型。
c. 【推荐】所有的局部变量使用基本数据类型。

3.3 字符串与基本类型的转换

1. 将字符串转为基本类型
   调用各个

   包装类.parseXX(String str)

   
   

   Integer.parseInt(String str)

2. 基本数据类型变为字符串
   a. “ ”+基本类型
   b. 使用String类的valueof(基本数据类型，静态方法)，此方法不产生垃圾空间（推荐）

阅读更多