大杂烩 -- equals、hashCode联系与区别
基础大杂烩 -- 目录
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
Equals
1、默认情况（没有覆盖equals方法）下equals方法都是调用Object类的equals方法，而Object的equals方法主要用于判断对象的内存地址引用是不是同一个地址（是不是同一个对象）。
public boolean equals(Object obj) {
return (this == obj);
}
2 、如果类中覆盖了equals方法，那么就要根据具体的代码来确定equals方法的作用了，覆盖后一般都是通过对象的内容是否相等来判断对象是否相等。
@Override
public boolean equals(Object obj) {
// 1.地址相等
if (this == obj)
return true;
// 2.不为空
if (obj == null)
return false;
// 3.类型相同
if (getClass() != obj.getClass())
return false;
StudentOverrideEquals other = (StudentOverrideEquals) obj;
// 4.属性相等
if (age != other.age)
// 4.1基本数据类型判断值
return false;
// 4.2引用数据类型。1.空值判断，2.非空调用自身equals()
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
HashCode
1.默认情况（没有覆盖hashCode方法）下hashCode方法都是调用Object类的hashCode方法，而Object的hashCode方法的返回值的默认实现是根据对象的内存地址进行计算。
public native int hashCode();
2.如果类中覆盖了hashCode方法，那么就要根据具体的代码来确定hashCode方法的返回值，覆盖后一般都是通过对象的属性计算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、不覆写hashCode（Tt02）
覆写equals、不覆写hashCode（Tt03）
不覆写equals、 覆写hashCode（Tt04）
覆写equals、 覆写hashCode（Tt05）
覆写equals、 覆写hashCode（返回值不同）（Tt06）
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
Tt02：不覆写equals、不覆写hashCode
Class ： Student
package limeMianShi.duolaidian.equals_hashcode; /**
* 没有覆盖equals、hashCode方法
*
* @author lime
*
*/
public class Student { private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
} }
Class : main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set; /**
* 没有覆盖equals、hashCode方法
*
* @author lime
*
*/
public class Test02 { public static void main(String[] args) {
List<Student> list = new LinkedList<Student>();
Set<Student> set = new HashSet<Student>();
Student stu1 = new Student("lime",25);
Student stu2 = new Student("lime", 25);
System.out.println("stu1 == stu2 : "+(stu1 == stu2));
System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode());
System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1);
list.add(stu2);
System.out.println("list size:"+ list.size()); set.add(stu1);
set.add(stu2);
System.out.println("set size:"+ set.size());
}
}
Console :
stu1 == stu2 : false
stu1.equals(stu2) : false
stu1-->HashCode:1865127310
stu2-->HashCode:515132998
list size:2
set size:2
Tt03：覆写equals、不覆写hashCode
Class ： StudentOverrideEquals
package limeMianShi.duolaidian.equals_hashcode; /**
* 覆写equals方法
*
* @author lime
*
*/
public class StudentOverrideEquals { private String name;
private int age; public StudentOverrideEquals() {
super();
} public StudentOverrideEquals(String name, int age) {
super();
this.name = name;
this.age = age;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} @Override
public boolean equals(Object obj) {
// 1.地址相等
if (this == obj)
return true;
// 2.不为空
if (obj == null)
return false;
// 3.类型相同
if (getClass() != obj.getClass())
return false;
StudentOverrideEquals other = (StudentOverrideEquals) obj;
// 4.属性相等
if (age != other.age)
// 4.1基本数据类型判断值
return false;
// 4.2引用数据类型。1.空值判断，2.非空调用自身equals()
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
Class ： main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set; /**
* 覆写equals方法
*
* @author lime
*
*/
public class Test03 { public static void main(String[] args) {
List<StudentOverrideEquals> list = new LinkedList<StudentOverrideEquals>();
Set<StudentOverrideEquals> set = new HashSet<StudentOverrideEquals>();
StudentOverrideEquals stu1 = new StudentOverrideEquals("lime",25);
StudentOverrideEquals stu2 = new StudentOverrideEquals("lime", 25);
System.out.println("stu1 == stu2 : "+(stu1 == stu2));
System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode());
System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1);
list.add(stu2);
System.out.println("list size:"+ list.size()); set.add(stu1);
set.add(stu2);
System.out.println("set size:"+ set.size());
}
}
Console ：
stu1 == stu2 : false
stu1.equals(stu2) : true
stu1-->HashCode:1865127310
stu2-->HashCode:515132998
list size:2
set size:2
Tt04：不覆写equals、覆写hashCode
Class ： StudentOverrideHashCode
package limeMianShi.duolaidian.equals_hashcode; /**
* 覆盖hashCode方法
*
* @author lime
*
*/
public class StudentOverrideHashCode { private String name;
private int age;
public StudentOverrideHashCode(String name, int age) {
super();
this.name = name;
this.age = age;
}
public StudentOverrideHashCode() {
super();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@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;
}
}
Class ： main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set; /**
* 覆写hashCode方法
*
* @author lime
*
*/
public class Test04 { public static void main(String[] args) {
List<StudentOverrideHashCode> list = new LinkedList<StudentOverrideHashCode>();
Set<StudentOverrideHashCode> set = new HashSet<StudentOverrideHashCode>();
StudentOverrideHashCode stu1 = new StudentOverrideHashCode("lime",25);
StudentOverrideHashCode stu2 = new StudentOverrideHashCode("lime", 25);
System.out.println("stu1 == stu2 : "+(stu1 == stu2));
System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode());
System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1);
list.add(stu2);
System.out.println("list size:"+ list.size()); set.add(stu1);
set.add(stu2);
System.out.println("set size:"+ set.size());
}
}
Console ：
stu1 == stu2 : false
stu1.equals(stu2) : false
stu1-->HashCode:3323549
stu2-->HashCode:3323549
list size:2
set size:2
Tt05：覆写equals、覆写hashCode
Class : StudentOverrideEqualsHashCode
package limeMianShi.duolaidian.equals_hashcode; /**
* 覆盖equals 和 hashCode方法
*
* @author lime
*
*/
public class StudentOverrideEqualsHashCode { private String name;
private int age;
public StudentOverrideEqualsHashCode(String name, int age) {
super();
this.name = name;
this.age = age;
}
public StudentOverrideEqualsHashCode() {
super();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@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;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
StudentOverrideEqualsHashCode other = (StudentOverrideEqualsHashCode) 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;
}
}
Class : main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set; /**
* 覆写equals、hashCode方法
*
* @author lime
*
*/
public class Test05 { public static void main(String[] args) {
List<StudentOverrideEqualsHashCode> list = new LinkedList<StudentOverrideEqualsHashCode>();
Set<StudentOverrideEqualsHashCode> set = new HashSet<StudentOverrideEqualsHashCode>();
StudentOverrideEqualsHashCode stu1 = new StudentOverrideEqualsHashCode("lime",25);
StudentOverrideEqualsHashCode stu2 = new StudentOverrideEqualsHashCode("lime", 25);
System.out.println("stu1 == stu2 : "+(stu1 == stu2));
System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode());
System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1);
list.add(stu2);
System.out.println("list size:"+ list.size()); set.add(stu1);
set.add(stu2);
System.out.println("set size:"+ set.size());
}
}
Console :
stu1 == stu2 : false
stu1.equals(stu2) : true
stu1-->HashCode:3323549
stu2-->HashCode:3323549
list size:2
set size:1
Tt05：覆写equals、覆写hashCode（返回值不同）
Class ： StudentOverrideEqualsHashCodeneq
package limeMianShi.duolaidian.equals_hashcode; /**
* equals 相等，hashCode不等
*
* @author lime
*
*/
public class StudentOverrideEqualsHashCodeneq { private String name;
private int age;
public StudentOverrideEqualsHashCodeneq(String name, int age) {
super();
this.name = name;
this.age = age;
}
public StudentOverrideEqualsHashCodeneq() {
super();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
return (int) (Math.random()*10);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
StudentOverrideEqualsHashCodeneq other = (StudentOverrideEqualsHashCodeneq) 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;
}
}
Class ： main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set; /**
* 覆写equals、hashCode(返回值不同)方法
*
* @author lime
*
*/
public class Test06 extends Object{ public static void main(String[] args) {
List<StudentOverrideEqualsHashCodeneq> list = new LinkedList<StudentOverrideEqualsHashCodeneq>();
Set<StudentOverrideEqualsHashCodeneq> set = new HashSet<StudentOverrideEqualsHashCodeneq>();
StudentOverrideEqualsHashCodeneq stu1 = new StudentOverrideEqualsHashCodeneq("lime",25);
StudentOverrideEqualsHashCodeneq stu2 = new StudentOverrideEqualsHashCodeneq("lime", 25);
System.out.println("stu1 == stu2 : "+(stu1 == stu2));
System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode());
System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1);
list.add(stu2);
System.out.println("list size:"+ list.size()); set.add(stu1);
set.add(stu2);
System.out.println("set size:"+ set.size());
}
}
Console :
stu1 == stu2 : false
stu1.equals(stu2) : true
stu1-->HashCode:1
stu2-->HashCode:6
list size:2
set size:2
Tt07：覆写equals、覆写hashCode(修改属性值，改变hashCode，remove）
Class ：StudentOverrideEqualsHashCode
package limeMianShi.duolaidian.equals_hashcode; /**
* 覆盖equals 和 hashCode方法
*
* @author lime
*
*/
public class StudentOverrideEqualsHashCode { private String name;
private int age;
public StudentOverrideEqualsHashCode(String name, int age) {
super();
this.name = name;
this.age = age;
}
public StudentOverrideEqualsHashCode() {
super();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@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;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
StudentOverrideEqualsHashCode other = (StudentOverrideEqualsHashCode) 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;
}
}
Class : main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set; /**
* 覆写equals、hashCode方法。修改参与计算hashCode的属性
*
* @author lime
*
*/
public class Test07{ public static void main(String[] args) {
List<StudentOverrideEqualsHashCode> list = new LinkedList<StudentOverrideEqualsHashCode>();
Set<StudentOverrideEqualsHashCode> set = new HashSet<StudentOverrideEqualsHashCode>();
StudentOverrideEqualsHashCode stu1 = new StudentOverrideEqualsHashCode("lime",25);
StudentOverrideEqualsHashCode stu2 = new StudentOverrideEqualsHashCode("lime", 25);
System.out.println("stu1 == stu2 : "+(stu1 == stu2));
System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode());
System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1);
list.add(stu2);
System.out.println("list size:"+ list.size()); set.add(stu1);
set.add(stu2);
System.out.println("set size:"+ set.size()); System.out.println("修改stu1的name");
stu1.setName("oracle");
System.out.println("stu1-->HashCode:" + stu1.hashCode());
set.remove(stu1);
System.out.println("set size:"+ set.size());
}
}
Console ：
stu1 == stu2 : false
stu1.equals(stu2) : true
stu1-->HashCode:3323549
stu2-->HashCode:3323549
list size:2
set size:1
修改stu1的name
stu1-->HashCode:-1008860090
set size:1
结果分析：
set添加元素时，首先判断hashCode一致，在判断equals一致。
set移除元素时，首先判断hashCode一致，根据hashCode移除元素。
当我们将某个对象存到set中时，如果该对象的属性参与了hashcode的计算，那么以后就不能修改该对象参与hashcode计算的那些属性了，否则会引起意向不到的错误的。正如测试中，不能够移除stu1对象。
hashSet本质是封装hashMap
package java.util;
import java.io.InvalidObjectException;
public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable{
static final long serialVersionUID = -5024744406713321676L;
private transient HashMap<E,Object> map;
private static final Object PRESENT = new Object();
public HashSet() {
map = new HashMap<>();
}
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
public Iterator<E> iterator() {
return map.keySet().iterator();
}
public int size() {
return map.size();
}
public boolean isEmpty() {
return map.isEmpty();
}
public boolean contains(Object o) {
return map.containsKey(o);
}
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
public void clear() {
map.clear();
}
@SuppressWarnings("unchecked")
public Object clone() {
try {
HashSet<E> newSet = (HashSet<E>) super.clone();
newSet.map = (HashMap<E, Object>) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
s.defaultWriteObject();
s.writeInt(map.capacity());
s.writeFloat(map.loadFactor());
s.writeInt(map.size());
for (E e : map.keySet())
s.writeObject(e);
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
int capacity = s.readInt();
if (capacity < 0) {
throw new InvalidObjectException("Illegal capacity: " + capacity);
}
float loadFactor = s.readFloat();
if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
throw new InvalidObjectException("Illegal load factor: " +
loadFactor);
}
int size = s.readInt();
if (size < 0) {
throw new InvalidObjectException("Illegal size: " +
size);
}
capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f), HashMap.MAXIMUM_CAPACITY);
map = (((HashSet<?>)this) instanceof LinkedHashSet ?
new LinkedHashMap<E,Object>(capacity, loadFactor) :
new HashMap<E,Object>(capacity, loadFactor));
for (int i=0; i<size; i++) {
@SuppressWarnings("unchecked")
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}
public Spliterator<E> spliterator() {
return new HashMap.KeySpliterator<E,Object>(map, 0, -1, 0, 0);
}
}
set-->add：
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
set-->remove :
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
总结：
1、equals方法用于比较对象的内容是否相等（覆盖以后）
2、hashcode方法只有在集合中用到
3、当覆盖了equals方法时，比较对象是否相等将通过覆盖后的equals方法进行比较（判断对象的内容是否相等）。
4、将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。
5、将元素放入集合的流程图：
啦啦啦
啦啦啦
大杂烩 -- equals、hashCode联系与区别的更多相关文章
- （转）从一道面试题彻底搞懂hashCode与equals的作用与区别及应当注意的细节
背景:学习java的基础知识,每次回顾,总会有不同的认识.该文系转载 最近去面试了几家公司,被问到hashCode的作用,虽然回答出来了,但是自己还是对hashCode和equals的作用一知半解的, ...
- JavaSE的包装类，自动装箱和自动拆箱 ,字符窜转换，toString(),equals(), hashCode()的区别
一.基本数据类型和包装类 包装类均位于Java.lang包,包装类和基本数据类型的对应关系如下表所示: Primitive-Type Wrapper-Class byte ...
- equals(),hashcode(),克隆学习心得
equals(),hashcode(),克隆学习心得 其实在开发时候,很少去重写equals(),hashCode()方法,但是有些时候业务需要还是要重写. 注意: 重写equals()方法一定要重写 ...
- android 判断字符串是否为空与比对["=="与equals（）的区别]
if (s == null || s.equals("")) ; } s.equals("")里面是要比对的字符串 声明字符串未赋初始值或值,然后比对就会出错, ...
- equals方法和==的区别
equals方法和==的区别 首先大家知道,String既可以作为一个对象来使用,又可以作为一个基本类型来使用.这里指的作为一个基本类型来使用只是指使用方法上的,比如String s = &quo ...
- 讲的很详细的一篇关于object equals() & hashCode() 的文章
转: 讲的很详细的一篇关于object equals() & hashCode() 的文章 哈希表这个数据结构想必大多数人都不陌生,而且在很多地方都会利用到hash表来提高查找效率.在Java ...
- java中的 equals + hashCode
[0]README 0.1)本文转自 core java volume 1, 旨在理清 equals + hashCode方法: [1]equals方法 1.1) Object中的 equals 方法 ...
- Java中BigDecimal的equals与compareTo的区别
有个是否为零的判断[BigDecimal.ZERO.equals(ratio)]我用了BigDecimal的equals方法,结果,判断失败,因此特地分析一下equals与compareT ...
- Java易混小知识——equals方法和==的区别
一.equals方法和==的区别 1.equals是String对象的方法,可以通过".“调用. 2.== 是一个运算符. 二.常用的比较用法 1.基本数据类型比较. equals和==都比 ...
- 在@Data注释lombok上使用继承警告等于/ hashCode(Warning equals/hashCode on @Data annotation lombok with inheritance)
生成equals / hashCode实现但没有调用超类,即使这个类没有扩展java.lang.Object.如果这是故意的,请将 @EqualsAndHashCode(callSuper = fal ...
随机推荐
- Voltage Translation for Analog to Digital Interface ADC
Voltage Translation for Analog to Digital Interface 孕龙逻辑分析仪 ZeroPlus Logic Analyzer How to modify an ...
- 网站SSL证书在线检测
网站SSL证书在线检测 http://web.chacuo.net/netsslcheck OpenSSL命令行工具的证书操作 http://blog.csdn.net/a351945755/arti ...
- Linux下tomcat修改成的80端口无法访问
转自: https://blog.csdn.net/u013252047/article/details/72834415 tomcat放到服务器上访问8080端口还需要输入端口号,造成访问不便,好多 ...
- 临时和永久关闭Selinux
临时关闭: [root@localhost ~]# getenforceEnforcing [root@localhost ~]# setenforce 0[root@localhost ~]# ge ...
- js-BootstrapValidator简单使用
本例使用版本 <!-- 新 Bootstrap 核心 CSS 文件 --> <link href="http://cdn.static.runoob.com/libs/bo ...
- Android -- 再来一发Notification
之前写过一个Notificaiton的文章,用上面的方式去操作也是OK的,但是到后面的SDK之后,有些方法被弃用,甚至我到SDK23的时候,我发现有些方法直接没了,所以在这里重新写一下最新的用法. h ...
- React页面隐藏#
将 hashHistory 改为 browserHistory 路由用到的,可以在routes.jsx上把hashHistory 改成browserHistory https://github.com ...
- Spring AOP项目应用——方法入参校验 & 日志横切
转载:https://blog.csdn.net/Daybreak1209/article/details/80591566 应用一:方法入参校验 由于系统多个方法入参均对外封装了统一的Dto,其中D ...
- postgresql ltree类型
最近一个月使用Postgresql的时候,经常遇到ltree的数据,感觉有些别扭,可是有绕不过去.今天决心整理一下,以后使用方便一些. 一.简介 ltree是Postgresql的一个扩展类型,由两位 ...
- 基于ubuntu搭建 WordPress 个人博客
系统要求:Ubuntu 16.04.1 LTS 64 位操作系统 准备 LAMP 环境:(LAMP 是 Linux.Apache.MySQL 和 PHP 的缩写,是 Wordpress 系统依赖的基础 ...