java常用类重写
- Object 类的toString()方法
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()方法进行比较
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);
}
}
我们想要他们相同,所以需要重写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.
*
* @paramobjthe reference object with which to compare.
* @return{ @code true} if this object is the same as the obj
*argument; { @code false} otherwise.
* @see#hashCode()
* @seejava.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 类是被 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
我们假设使用 append 方法,该方法返回的依然是 StringBuffer 对象本身,说明他确实是值改变了
StringBuilder str3 = new StringBuilder("adoke152");
str3.append("666");
System.out.println(str3);
输出为
说明Stringbuilder的值变了。
String 对象的操作符“+”其实被赋予了特殊的含义,该操作符是 Java 中仅有的两个重载过的操作符。而通过反编译可以看到,String 对象在进行“+”操作的时候,其实是调用了 StringBuilder 对象的 append() 方法来加以构造
- String、StringBuffer、StringBuilder 对比
当然这个是相对的,不一定在所有情况下都是这样。
比如String str = “hello” + "world"的效率就比 StringBuilder st = new StringBuilder().append(“hello”).append(“world”)要高。
因此,如果是字符串相加操作或者改动较少的情况下,使用 String str = "hello" + "world" + ... 这种形式;土改时字符串相加比较多的话,建议使用 StringBuilder
线程安全
【java常用类重写】StringBuffer 线程安全的,StringBuilder 不是线程安全的
推荐阅读
- JAVA(抽象类与接口的区别&重载与重写&内存泄漏)
- 为什么你的路演总会超时()
- 标签、语法规范、内联框架、超链接、CSS的编写位置、CSS语法、开发工具、块和内联、常用选择器、后代元素选择器、伪类、伪元素。
- 事件代理
- Java|Java OpenCV图像处理之SIFT角点检测详解
- java中如何实现重建二叉树
- thinkphp|thinkphp 3.2 如何调用第三方类库
- 使用composer自动加载类文件
- 一个健康的APP和健全的人格大体类似
- 数组常用方法一