大杂烩 -- 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 ...
随机推荐
- Codeforces Round #410 (Div. 2) 题解 【ABCD】
A 题意:问你恰好修改一个字符,能不能使得字符串变成回文串 题解:显然直接for一遍,如果长度为偶数,那么不一样的必须是1个:如果长度为奇数,那么不一样的也可以是0个 #include<bits ...
- C#高级编程9 第16章 错误和异常
C#高级编程9 第16章 错误和异常 了解这章可以学会如何处理系统异常以及错误信息. System.Exception类是.NET运行库抛出的异常,可以继承它定义自己的异常类. try块代码包含的代码 ...
- 在远程桌面服务中配置RD网关直接访问内网
原文地址:http://wangchunhai.blog.51cto.com/225186/1139388/ 远程桌面网关(RD 网关)是一项角色服务,使授权远程用户可以从任何连接到 Internet ...
- 【转】大数据分析中Redis怎么做到220万ops
原文:http://www.cnblogs.com/nnhy/archive/2018/01/16/Redis220.html 大数据时代,海量数据分析就像吃饭一样,成为了我们每天的工作.为了更好的为 ...
- 移动基于Percona XTRADB Cluster的大数据解决方式
移动基于Percona XTRADB Cluster的大数据解决方式 一.移动的去IOE之旅 近期由于"棱镜门"事件的曝光.引起了国家对信息安全问题的注 ...
- （转）GrabPass捕捉屏幕纹理
转自:http://blog.sina.com.cn/s/blog_89d90b7c0102va4m.html 最近在看热扭曲效果,里面用到了GrabPass. 之前看过官方翻译版本的说明http:/ ...
- chrome 浏览器的插件权限有多大？
转自:https://segmentfault.com/q/1010000003777353 1)Chrome插件本身有机制控制,不会无限制的开放很多权限给你2)页面的DOM元素时可以操作的,Chro ...
- Recover database using backup controlfile until cancel
http://searchoracle.techtarget.com/answer/Recover-database-using-backup-controlfile-until-cancel Wha ...
- MySql之修改操作与进阶
一:更新特定行 UPDATE tableName SET 列名 = 值,列名 = 值... WHERE 条件; 二:使用子查询更新数据 UPDATE tableName SET 列名 = SELECT ...
- 手把手教你整合最优雅SSM框架：SpringMVC + Spring + MyBatis
在写代码之前我们先了解一下这三个框架分别是干什么的? 相信大以前也看过不少这些概念,我这就用大白话来讲,如果之前有了解过可以跳过这一大段,直接看代码! SpringMVC:它用于web层,相当于con ...