1. Object类

Java语言的根类，即所有类的父类。

1.1 clone()

返回一个Object对象的复制。这个复制返回的是一个新对象。

clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写clone()，其它类就不能直接去调用该类实例的 clone() 方法。

1.1.1 浅拷贝

拷贝对象和原始对象的引用类型引用同一个对象。

使用步骤：

实现clone的类首先需要继承Cloneable接口（若未实现，就抛出异常：CloneNotSupportedException）。Cloneable接口实际上是一个标识接口，没有任何接口方法。
在类中重写Object类的clone()方法；
在clone()中调用super.clone()。无论clone类的继承结构是什么，super.clone()会直接或间接调用java.lang.Object类的clone()；
把浅复制的引用指向原型对象新的克隆体。

class Obj implements Cloneable{private int aInt=0;public int getAInt() {return aInt;}public void setAInt(int int1) {aInt=int1;}public void changeInt() {this.aInt=1;}public Object clone() {Object o=null;try {o=(Object)super.clone();}catch(CloneNotSupportedException e) {e.printStackTrace();}return o;}
}public class DBTest{public static void main(String[] args) {Obj a=new Obj();Obj b=(Obj)a.clone();b.changeInt();System.out.println("a:"+a.getAInt());System.out.println("b:"+b.getAInt());}}

运行结果：

a:0
b:1

1.1.2 深复制

拷贝对象和原始对象的引用类型引用不同对象。

在对对象调用clone()完成复制之后，接着对对象中的非基本类型的属性也调用clone()完成复制。

import java.util.Date;class Obj implements Cloneable{private Date birth=new Date();public Date getBirth() {return birth;}public void setBirth(Date birth) {this.birth=birth;}public void changeDate() {this.birth.setMonth(4);}public Object clone() {Obj o=null;try {o=(Obj)super.clone();}catch(CloneNotSupportedException e) {e.printStackTrace();}//实现深复制o.birth=(Date)this.getBirth().clone();return o;}
}public class DBTest{public static void main(String[] args) {Obj a=new Obj();Obj b=(Obj)a.clone();b.changeDate();System.out.println("a:"+a.getBirth());System.out.println("b:"+b.getBirth());}
}

运行结果：

a:Tue Nov 27 15:40:48 CST 2018
b:Sun May 27 15:40:48 CST 2018

Date.setMonth(int)：都标有删除线，因为被废弃了。是因为Date类在设计中有很多问题，如getYear指的是1900年以来的年数，getMonth是从0开始的。

setMonth(4)实际上是设置为5月，May

1.2 equals()

比较两个对象是否相同。

基本类型比较的是值，引用类型比较的是地址。

满足：自反性、对称性、传递性和一致性（多次调用结果一样）。

x.equals(x); // true
x.equals(y) == y.equals(x); // true
if (x.equals(y) && y.equals(z)) x.equals(z); // true;
x.equals(y) == x.equals(y); // true

与 null 的比较：对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false

要根据对象属性值进行比较时，需重写equals()。

public boolean equals(Object obj) {if(this==obj)return true;if(!(obj instanceof Person))return false;//将obj向下转型为Person引用，访问其属性Person p=(Person) obj;return this.age==p.age;
}

在重写Object中的equals()时，要注意equals(Object obj)的参数类型时Object；
在调用对象属性的时候，要进行类型转换，但转换之前，必须进行类型判断。

1.2.1 equals()源码

public boolean equals(Object obj){return (this==obj);
}

使用==
比较两个对象的内存地址

1.2.2 equals() 与 ==

对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。

1.3 toString()

返回该对象的字符串表示（对象类型+@+内存地址值）

Syso(s);——默认调用toString()

Syso(s.toString());和上面一句输出一样

需按对象的属性得到相应的字符串表示时，需要重写toString();

class Person extends Object{int age;public String toString() {return "Person [age="+age+"]";}
}

toString()源码

String toString(){return getClass().getName()+"@"+Integer.toHexString(hashCode());
}

getClass()：返回一个对象。返回Object的运行时类（字节码对象）
getName()：返回字节码名字（类名）
@：分隔符
Integer.toHexString()：类名调用方法，说明toHexString()是static方法。它以十六进制无符号整数形式返回一个整数参数的字符串表现形式
hashCode()：无对象调用，则属于Object，返回对象的哈希码值。阿静对象的内存地址以整数形式返回。

1.4 hashCode()

hasCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。

等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。

在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等。

下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。

我们希望将这两个对象当成一样的，只在集合中添加一个对象，但是因为 EqualExample 没有实现 hasCode() 方法，因此这两个对象的散列值是不同的，最终导致集合添加了两个等价的对象。

EqualExample e1 = new EqualExample(1, 1, 1);
EqualExample e2 = new EqualExample(1, 1, 1);
System.out.println(e1.equals(e2)); // true
HashSet<EqualExample> set = new HashSet<>();
set.add(e1);
set.add(e2);
System.out.println(set.size()); // 2

理想的散列函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的散列值上。

2. String类

字符串是常量，它们的值在创建之后不能更改

字符串本身不能更改，但str变量中记录的地址值可以改

String str="CSDN";

str="Zxin";

2.1 赋值方式

2.1.1 使用双引号的方式创建的对象和使用new方式（构造函数）创建的对象的区别

String s1=new String("hello");

String s2="hello"

String s3="hello";

s1==s3;//false

s2==s3;//true

字符串内容存储在方法区的常量池里面，便于字符串的重复使用。

public class Code2 {public static void main(String[] args) {String s1=new String("hello");String s2="hello";String s3="hello";String s4=new String("hello");System.out.println(s1==s3);//falseSystem.out.println(s2==s3);//trueSystem.out.println(s1==s4);//false      }
}

2.2 构造方法

String();
String(byte[] bytes);
String(byte[] bytes,int offset, int length);
String(char[] value);
String(char[] value,int offset,int length);
String(String original)——把字符串数据封装成字符串对象

2.3 方法

length():字符个数
subString(int beginIndex):从指定位置到字符串末尾的所有字符
subString(int beginIndex,int endIndex)：从指定位置开始到指定位置结束的所有字符串[beginIndex,endIndex)

trim()：去掉字符串两端空格

split(String str)：按照指定符号分割字符串

2.3.1 查找

startWith(String prefix)：以给定字符串开始
endsWith(String suffix)：以给定字符串结尾
contains(CharSequence s)：判断是否包含给定字符串

是，返回第一次出现该字符串的索引

否，返回-1

indexOf(String str)：判断是否包含给定字符串

是，返回true

否，false

charAt(int index)：获取字符串第index位置的字符

index范围：[0,length()-1]

2.3.2 转换

getBytes()：将字符串转换成一个字节数组

to CharArray()：将字符串转换为一个字符数组

to LowerCase()：转换为小写字符串

to UpperCase()：转换为大写字符串

2.3.3 判等

equals(Object obj)：比为骄傲字符串的内容是否相同

equalsIgnoreCase(String str)：忽略大小写

直接打印引用类型变量时，默认调用该类型进行重写后的toString()。

2.4 字符串拼接

String s="hello";

s+="world";

字符串拼接很耗时，也很浪费空间。

String的值是不可变的，这就导致每次对String的操作都会生成新的字符串内容。

3. StringBuffer

又称不可变字符序列

类似于String的字符缓冲区，通过某些方法调用可以改变该序列的长度和内容。

它是一个容器，可以装很多字符串，并且能够对其中的字符串进行各种操作。

3.1 方法

append(String str)：添加字符串

insert(int offset,String str)：在指定位置插入

delete(int start,int end)：删除子序列

replace(int start,int end,String str)：替换指定范围的内容（end-start=str.length()??）

reverse()：反转

toString()

以上方法返回的都是当前对象自己——StringBuffer可以改变当前字符序列的长度和内容

3.2 对象的方法链式调用（运行下）

不断添加数据，要对缓冲区的最后数据进行操作，必须转换成为字符串才可以。

String str=sb.append(true).append("hello").toString();

无论多少数据，数据什么类型都不重要，只要最终编程字符互传就可以使用StringBuffer这个容器。

4. StringBuilder

用在字符串缓冲区被单个线程使用时。

若可以，优先采用此类，它比StringBuffer快。

属于java.lang包，不用导包。

String内容是固定的；StringBuilder内容是可变的。

4.1 成员方法

capcacity()：返回当前容量——理论值

length()：返回长度（字符个数）——实际值

append(任意类型)：添加数据，并返回自身对象

reverse()

4.2

StringBuilder sb=bew StringBuilder();
StringBuilder sb2=sb.append("hello");

运行之后，sb和sb2里都是hello。

4.3 String<------>StringBuilder

1、String--->StringBuilder：StringBuilder(String s);构造方法

2、StringBuilder--->String：toString();

常用API-1（Object类、String类、StringBuffer类、StringBuilder类）相关推荐

常用API（Object、String、StringBuffer、用户登陆注册)
常用API 今日内容介绍 u Object u String u StringBuilder 第1章 Java的API及Object类在以前的学习过程中,我们都在学习对象基本特征.对象的使用以及对象 ...
String、StringBuffer、StringBuilder类
String.StringBuffer.StringBuilder类:java提供了string.stringbuffer两个类来封装字符串,并提供了一系列方法来操作字符串对象. String类是不可 ...
Java String、StringBuffer、StringBuilder类解析
String.StringBuffer.StringBuilder类解析概述 String类:代表字符串. 特点 String实现了Serializable接口,表示String是可序列化的实现了 ...
20191001：String，StringBuffer，StringBuilder类异同辨析
String,StringBuffer,StringBuilder类异同辨析框架 String对象的建立方法及底层 StringBuffer与String的区别 StringBuilder与Stri ...
深入理解String、StringBuffer和StringBuilder类的区别
Java提供了String.StringBuffer和StringBuilder类来封装字符串,并提供了一系列操作字符串对象的方法. 它们的相同点是都用来封装字符串:都实现了CharSequence接 ...
String、StringBuffer与StringBuilder类详解
目录一.String简介: 二.String的创建方式: 面试题一:String s = new String("abc");方式创建对象,在内存中创建了几个对象? 四.一个笔试 ...
Java基础知识（JAVA中String、StringBuffer、StringBuilder类的区别）
java中String.StringBuffer.StringBuilder是编程中经常使用的字符串类,他们之间的区别也是经常在面试中会问到的问题.现在总结一下,看看他们的不同与相同. 1.可变与不可 ...
Java常用类（1）--字符串相关类String、StringBuffer、StringBuilder全面知识
文章目录 String类 StringBuffer类 StringBuilder类 String:不可变的字符序列:底层使用char[]存储 StringBuffer:可变的字符序列:线程安全的,效率 ...
1.19 String、StringBuffer和StringBuilder类的区别
在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串.String 类是不可变类,即一旦一个 String 对象被创建以后,包含在这个对象中的字符序列是不可改变的,直至 ...
String类最详解（String、StringBuffer、StringBuilder、正则表达式）表格+代码让你一文读懂！！！
文章目录 String类概述创建字符串第一种创建方式第二种创建方式构造方法判断功能获取功能转换功能替换功能正则表达式 StringBuffer类概述 StringBuffer的方 ...

常用API-1（Object类、String类、StringBuffer类、StringBuilder类）