java常用类重写
- Object 类的toString（）方法
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
class Test{
public static void main(String[] args) {
Person per = new Person("鲍星博", 21);
System.out.println(per);
}
}
输出为
我们不希望得到这样的结果，所以重写tostring方法；
@Override
public String toString() {
return "名字为："+this.name+"年龄为："+this.age;
}
更改后输出为
得到了我们想要的结果。
2.equals方法
String类对象比较 使用的是 equals()方法，实际上String类的equals()方法就是覆写 Object类中的equals()方法
- 基本数据类型的比较用 == (如： a == 3，b == 4, a == b，比较的是值是否相等）
- 引用类型数据比较：调用 equals()方法进行比较
class Test{
public static void main(String[] args) {
Person per = new Person("鲍星博", 21);
Person per2 = new Person("鲍星博", 21);
System.out.println(per.equals(per2));
//System.out.println(per);
}
}
Per 和per2的值相同，但是输出结果为，这是因为equals比较的是引用对象的地址
我们想要他们相同，所以需要重写equals（）函数
我们重写equals（）
@Override
public boolean equals(Object obj) {
if(obj ==null){
return false;
}
if(obj == this){
return true;
}
if(!(obj instanceof Person)){
return false;
}
Person person = (Person)obj;
return person.name.equals(this.name) && person.age==this.age;
}
之后输出结果为：
达到了我们想要的结果。
3.hashcode()
我们可以看到Object的hashcode()方法的修饰符为native,表明该方法是否操作系统实现，java调用操作系统底层代码获取哈希值。
public native int hashCode();
/**
* Indicates whether some other object is "equal to" this one.
*
* The { @code equals} method implements an equivalence relation
* on non-null object references:
*
* It is reflexive: for any non-null reference value
* { @code x}, { @code x.equals(x)} should return
* { @code true}.
* It is symmetric: for any non-null reference values
* { @code x} and { @code y}, { @code x.equals(y)}
* should return { @code true} if and only if
* { @code y.equals(x)} returns { @code true}.
* It is transitive: for any non-null reference values
* { @code x}, { @code y}, and { @code z}, if
* { @code x.equals(y)} returns { @code true} and
* { @code y.equals(z)} returns { @code true}, then
* { @code x.equals(z)} should return { @code true}.
* It is consistent: for any non-null reference values
* { @code x} and { @code y}, multiple invocations of
* { @code x.equals(y)} consistently return { @code true}
* or consistently return { @code false}, provided no
* information used in { @code equals} comparisons on the
* objects is modified.
* For any non-null reference value { @code x},
* { @code x.equals(null)} should return { @code false}.
*
*
* The { @code equals} method for class { @code Object} implements
* the most discriminating possible equivalence relation on objects;
* that is, for any non-null reference values { @code x} and
* { @code y}, this method returns { @code true} if and only
* if { @code x} and { @code y} refer to the same object
* ({ @code x == y} has the value { @code true}).
*
* Note that it is generally necessary to override the { @code hashCode}
* method whenever this method is overridden, so as to maintain the
* general contract for the { @code hashCode} method, which states
* that equal objects must have equal hash codes.
*
* @param obj the reference object with which to compare.
* @return { @code true} if this object is the same as the obj
* argument; { @code false} otherwise.
* @see #hashCode()
* @see java.util.HashMap
*/
HashSet的底层是通过HashMap实现的，最终比较set容器内元素是否相等是通过比较对象的hashcode来判断的
重写hashcode
@Override
public int hashCode() {
int result = name.hashCode();
result = 17*result ;
return result;
}
执行如下代码：
Person per = new Person("鲍星博", 21);
Person per2 = new Person("鲍星博", 21);
System.out.println(per.hashCode());
System.out.println(per2.hashCode());
Set set = new HashSet();
set.add(per);
set.add(per2);
//输出了一个对象，说明他们的hashcode相同，如果不重写，说明他们的hashcode不相同
System.out.println(set);
输出为
- String
String的对象不可变
String 类是被 final 修饰的，即 String 类不能被继承。
通过源代码可以看到，substring，replace 最后都是通过 new String(xxx) 来产生了一个新的 String 对象，最原始的字符串并没有改变
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}
public String replace(char oldChar, char newChar) {
if (oldChar != newChar) {
int len = value.length;
int i = -1;
char[] val = value; /* avoid getfield opcode */
while (++i < len) {
if (val[i] == oldChar) {
break;
}
}
if (i < len) {
char buf[] = new char[len];
for (int j = 0; j < i; j++) {
buf[j] = val[j];
}
while (i < len) {
char c = val[i];
buf[i] = (c == oldChar) ? newChar : c;
i++;
}
return new String(buf, true);
}
}
return this;
}
public static void main(String[] args) {
String str1 = "abc123456";
//前闭后开
String str2 = str1.substring(0,3);
System.out.println(str1);
System.out.println(str2);
}
输出为
- StringBuilder
StringBuilder 中的字符可变
我们假设使用 append 方法，该方法返回的依然是 StringBuffer 对象本身，说明他确实是值改变了
StringBuilder str3 = new StringBuilder("adoke152");
str3.append("666");
System.out.println(str3);
输出为
说明Stringbuilder的值变了。
String 对象的操作符“+”其实被赋予了特殊的含义，该操作符是 Java 中仅有的两个重载过的操作符。而通过反编译可以看到，String 对象在进行“+”操作的时候，其实是调用了 StringBuilder 对象的 append() 方法来加以构造
- String、StringBuffer、StringBuilder 对比
StringBuilder > StringBuffer > String
当然这个是相对的，不一定在所有情况下都是这样。
比如String str = “hello” + "world"的效率就比 StringBuilder st = new StringBuilder().append(“hello”).append(“world”)要高。
因此，如果是字符串相加操作或者改动较少的情况下，使用 String str = "hello" + "world" + ... 这种形式；土改时字符串相加比较多的话，建议使用 StringBuilder
线程安全
StringBuffer 线程安全的，StringBuilder 不是线程安全的