大杂烩 -- 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 ...
随机推荐
- C#6.0特性与vs2015
C#6.0 中的那些新特性 1. 自动属性的初始化 public string Name { get; set; } = "zhangsan"; 2. 只读属性初始化 public ...
- 数据结构C语言版--静态顺序表的基本功能实现（一）
/* * 功能:创建一个线性表,并输出 * 静态分配内存 */ #include<stdio.h> //stdio.h是C的标准I/O库 //#include<iostream> ...
- [YARN] 2.2 GB of 2.1 GB virtual memory used. Killing container.
Spark程序在yarn的集群运行,出现 Current usage: 105.9 MB of 1 GB physical memory used; 2.2 GB of 2.1 GB virtual ...
- Java调用使用SSL/HTTPS协议来传输的axis webservice服务
使用SSL/HTTPS协议来传输 Web服务也可以使用SSL作为传输协议.虽然JAX-RPC并没有强制规定是否使用SSL协议,但在tomcat 下使用HTTPS协议. 1.使用JDK自带的工具创建密匙 ...
- Windows如何安装pip
下载这个文件: https://bootstrap.pypa.io/get-pip.py 然后到下载目录执行Python命令: (管理员权限执行) python get-pip.py
- JavaScript 编码规范（中文/Airbnb公司版）
Airbnb 是一家位于美国旧金山的公司,本文是其内部的 JavaScript编码规范,写得比较全面,在 Github 上有 16,686 + Star,3,080 + fork,前端开发人员可参考. ...
- 解决微信小程序ios端滚动卡顿的问题
方案1:直接使用微信小程序提供的 “scroll-view " 组件. <scroll-view scroll-y style="height: 100%;"> ...
- 郑晔谈 Java 开发：新工具、新框架、新思维【转载】【整理】
原文地址 导语:"我很惊讶地发现,现在许多程序员讨论的内容几乎和我十多年前刚开始做 Java 时几乎完全一样.要知道,我们生存的这个行业号称是变化飞快的.其实,这十几年时间,在开发领域已经有 ...
- Android apk签名的两种方法
编辑推荐:稀土掘金,这是一个针对技术开发者的一个应用,你可以在掘金上获取最新最优质的技术干货,不仅仅是Android知识.前端.后端以至于产品和设计都有涉猎,想成为全栈工程师的朋友不要错过! 为了保证 ...
- 【概念原理】四种SQL事务隔离级别和事务ACID特性
摘要: SQL事务隔离级别和事务的ACID特性 事务是一组读写操作,并且具有只有所有操作都成功才算成功的特性. 事务隔离级别 SQL事务隔离级别由弱到强分别是:READ_UNCOMMITTED.R ...