大杂烩 -- 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 ...
随机推荐
- Linux.Centos安装scp反复失败的解决方式
现象 在A服务器用scp命令从B服务器拉文件时, 报找不到scp指令的错误 在A服务器运行 scp --help 发现是有指令的 在B服务器上 常规方式, 安装openssh-clients yum ...
- 网络编程（2）—UDP
1.UDP协议: 将数据.源.目的封装成数据包,不需要建立连接 每个数据包大小在64K一下 因无需建立连接,所以是不可靠的 发送完毕,无需释放资源,速度快 2.UDP编程步骤: 发送端: 1.创建发送 ...
- FDMEMTABLE将修改后的数据序列为JSON
FDMEMTABLE将修改后的数据序列为JSON procedure TForm1.Button3Click(Sender: TObject); var memtable: TFDMemTable; ...
- [Sqoop]将Hive数据表导出到Mysql
业务背景 mysql表YHD_CATEG_PRIOR的结构例如以下: -- Table "YHD_CATEG_PRIOR" DDL CREATE TABLE `YHD_CATEG_ ...
- java并发之如何解决线程安全问题
并发(concurrency)一个并不陌生的词,简单来说,就是cpu在同一时刻执行多个任务. 而Java并发则由多线程实现的. 在jvm的世界里,线程就像不相干的平行空间,串行在虚拟机中.(当然这是比 ...
- Windows上的git、github部署及基本使用方法
1.介绍 Git是一个开源的分布式版本控制系统,可以有效.高速地处理从很小到非常大的项目版本管理.Git 是 Linus Torvalds 为了帮助管理 Linux 内核开发而开发的一个开放源码的版本 ...
- Tkinter(2.x 与3.X的区别)
1.包的引入 2.X下是 from Tkinter import * 而3.x是 from tkinter import * 否则,会报找不到tkinter的错误 Traceback (most re ...
- 未解决：长字符串含…
用reduce拼了一个超长sql语句,大约65000字符,运行通不过,报错: OperationalError: (1054, "Unknown column 'nan' in 'field ...
- HOW TO REPLACE ALL OCCURRENCES OF A CHARACTER IN A STD::STRING
From: http://www.martinbroadhurst.com/replacing-all-occurrences-of-a-character-in-a-stdstring.html T ...
- Linux 10字符串命令病毒的处理记录
刚上线的测试服务器不停的向外发包,且CPU持续100%,远程登录后查看发现有一长度为10的随机字符串进程,kill掉,会重新生成另外长度为10的字符串进程.删除文件也会重复生成,非常痛苦.查阅cron ...