-
Java中 判断集合中的元素相等的依据 详细解析
2017-02-05 23:30:49**你在调用contains()方法的时候, 或者是你在根据对象移除元素 remove(Object o) 你知道他们是如何判断集合中的元素是否 是相等的吗**? 接下来我们跟着源码去详细探究一下 数据数据结构不同判断的依据就不同,我们...我们经常使用的集合如ArrayList,LinkedList,Vector,
**你在调用contains()方法的时候, 或者是你在根据对象移除元素 remove(Object o) 你知道他们是如何判断集合中的元素是否
是相等的吗**?
接下来我们跟着源码去详细探究一下
数据数据结构不同判断的依据就不同,我们先来看一下List类的判断依据.先简单的了解一下
List类 : 有序,可以有重复元素。ArrayList 底层是一个对象数组
private transient Object[] elementData;
LinkedList 属于链式数据结构,底层用的是一个Node类的节点,包括指针域和数据域.private static class Node {
E item;
Node next;
Node prev;Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next; this.prev = prev; } }
ArrayList LinkedList他们都是线程不同步的 Vector非常类似ArrayList,但是Vector是同步的。, ArrayList LinkedList多线程访问会抛出 ConcurrentModificationException。如果想使他们线程同步的可以使用 Collections.synchronizedList 方法将该集合“包装”起来
回归正题
我们想知道他们如何判断集合元素是否相等,我们应该想到的是contains(Object o)方法,接下来我们看一下contains(Object o)方法
public boolean contains(Object o) { return indexOf(o) >= 0; }
他的方法内部调用了indexOf(o)这个方法,我们继续追踪看一下indexOf(o)方法
public int indexOf(Object o) { if (o == null) { for (int i = 0; i < size; i++) if (elementData[i]==null) return i; } else { for (int i = 0; i < size; i++) if (o.equals(elementData[i])) return i; } return -1; }
看到这里我们应该能明白了 先判断要查找的元素是否为空,不为空的话就调用equals方法.由此我们得到一个结论
List类中判断元素是否相等依赖的是equals方法.set类 : 无序,不允许重复
HashSet :
此实现不是同步的
我们知道HashSet它不允许出现重复元素,他是如何保证元素唯一的呢,我们应该首先想到的是看他的add()方法
如下public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
这里出现了一个map我们找找看看他是什么我们在上面看到了他的定义
private transient HashMap<E,Object> map;
现在我们知道了HashSet的内部其实是一个HashMap来维护的,众所周知HashMap的键是不允许有相同的,不用说HashMap的键就是HashSet的值,接下来我们只需要知道HashMap的键是如何保证唯一的就行了
我们就要追踪HashMap的添加元素方法 put(K key, V value)
public V put(K key, V value) { if (table == EMPTY_TABLE) { inflateTable(threshold); } if (key == null) return putForNullKey(value); int hash = hash(key); int i = indexFor(hash, table.length); for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } }
虽然有点麻烦我们只需要仔细看看 一定可以看明白 抓住最重要的一句
e.hash == hash && ((k = e.key) == key || key.equals(k))
现在我们也知道了HashSet 和HaspMap 保证元素唯一的办法是 先比较两个元素的哈希值,如果哈希值相等,在比较元素的地址是否相同,或者调用两个元素的equals方法如果哈希值不同,就根本不用在比较了.
-
Java如何判断两个集合的元素是否完全相等
2019-01-09 15:11:13Java如何判断两个集合的元素是否完全相等 博主最近在工作的时候遇到了这样的一个需求,前端的页面提交一个表单数据,传到后台,我需要做判断这个表单和已有的表单数据是否...Java如何判断两个集合的元素是否完全相等
博主最近在工作的时候遇到了这样的一个需求,前端的页面提交一个表单数据,传到后台,我需要做判断这个表单和已有的表单数据是否有完全相同的,如果有相同的数据,那么就返回一个false,这一个表单不能被保存,如果不同,就可以保存到数据库中。
一,实现
1. 最简单粗暴的方法,遍历循环
package list.demo; import java.io.Serializable; import java.util.*; import java.util.stream.Collectors; /** * 判断两个集合是否相等 */ public class CheckDiffList implements Serializable { public static void main(String[] args) { List<String> list = new ArrayList<>(); List<String> list1 = new ArrayList<>(); for (int i = 0; i < 1000; i++) { list.add("test" + i); list1.add("test" + (i * 2)); } System.out.println(checkDiffrent(list, list1)); } /** * 方法一:使用循环遍历 */ private static boolean checkDiffrent(List<String> list, List<String> list1) { long st = System.nanoTime(); if(list.size() != list1.size()) { System.out.println("消耗时间:" + (System.nanoTime() - st)); return false; } for(String str : list) { if(!list1.contains(str)) { System.out.println("消耗时间:" + (System.nanoTime() - st)); return false; } } System.out.println("消耗时间:" + (System.nanoTime() - st)); return true; } }
返回结果为:
消耗时间为: 16657988
false这是我想到的第一种方法,耗时较长,代码也不够简洁!
2. 使用List的retainAll方法进行比较
package list.demo; import java.io.Serializable; import java.util.*; import java.util.stream.Collectors; /** * 判断两个集合是否相等 */ public class CheckDiffList implements Serializable { public static void main(String[] args) { List<String> list = new ArrayList<>(); List<String> list1 = new ArrayList<>(); for (int i = 0; i < 1000; i++) { list.add("test" + i); list1.add("test" + (i * 2)); } System.out.println(checkDiffrent1(list, list1)); } /** * 方法2:利用List的 retainAll的方法进行判断 */ private static boolean checkDiffrent1(List<String> list, List<String> list1) { long st = System.nanoTime(); System.out.println("消耗时间为:" + (System.nanoTime() - st)); return !list.retainAll(list1); } }
返回结果为:
消耗时间为:7711
false但是这个retainAll这个方法有缺陷,如果集合A数组的大小没有改变,则返回false。如果集合A和集合B是完全相同的集合,也会返回false。两个集合没有交集,才会返回true。简单来说,判断两个集合是否有交集,有则返回false,无则返回true(这句话不严谨)。总结来说只有两个任何一个元素都不相等时才会返回true,否则返回false。那这个结果不是我想要的。
3. 利用HashMap的唯一性,把元素当做key,value可以重复。把list存到HashMap中
我们的需求是判断两个List中的元素是否相同,那么可以这样考虑:用一个map存放list的所有元素,其中的key为list1的各个元素,value为该元素出现的次数,接着把list2的所有元素也放到map里,如果已经存在则value+1,一旦value停止+1,说明有元素不同了,返回false。否则一直遍历直至list2中所有元素,返回true。这样我们只需循环m+n次,大大减少了循环的次数。
package list.demo; import java.io.Serializable; import java.util.*; import java.util.stream.Collectors; /** * 判断两个集合是否相等 */ public class CheckDiffList implements Serializable { public static void main(String[] args) { List<String> list = new ArrayList<>(); List<String> list1 = new ArrayList<>(); for (int i = 0; i < 1000; i++) { list.add("test" + i); list1.add("test" + (i * 2)); } System.out.println(checkDiffrent1(list, list1)); } /** * 方法3 * 利用HashMap key唯一,value可以重复的特点,把list中各种元素放到hashMap中 */ private static boolean checkDiffrent2(List<String> list, List<String> list1) { long st = System.nanoTime(); Map<String, Integer> map = new HashMap<>(list.size() + list1.size()); if (list.size() != list1.size()) { System.out.println("消耗时间为: " + (System.nanoTime() - st)); return false; } for (String str : list) { map.put(str, 1); } for (String str : list1) { Integer cc = map.get(str); if (null != cc) { continue; } System.out.println("消耗时间为: " + (System.nanoTime() - st)); return false; } System.out.println("消耗时间为: " + (System.nanoTime() - st)); return true; } }
结果:
消耗时间为: 4243019
false此方法使用了HashMap中key必须唯一,但是value可以重复的原因。但是HashMap是不同步的,所以线程不安全。
4. 利用MD5加密法来判断两个集合是否相等
package list.demo; import java.io.Serializable; import java.util.*; import java.util.stream.Collectors; /** * 判断两个集合是否相等 */ public class CheckDiffList implements Serializable { public static void main(String[] args) { List<String> list = new ArrayList<>(); List<String> list1 = new ArrayList<>(); for (int i = 0; i < 1000; i++) { list.add("test" + i); list1.add("test" + (i * 2)); } System.out.println(checkDiffrent1(list, list1)); } /** * md5加密法使用 * 方法4 */ private static boolean getDiffrent3(List<String> list, List<String> list1) { long st = System.nanoTime(); /** 使用Security的md5方法进行加密 */ String str = SecureUtil.md5(list.toString()); String str1 = SecureUtil.md5(list1.toString()); System.out.println("消耗时间为: " + (System.nanoTime() - st)); return str.equals(str1); } }
结果:
消耗时间为: 88603223
false这个方法很新奇吧,是我没有想到的,最好不要用这种方法,如果你在实际项目中使用这种方法,被打死了,请不要找我emmm~
5. 使用Java8的新特性steam流去比较两个数组是否相等
package list.demo; import java.io.Serializable; import java.util.*; import java.util.stream.Collectors; /** * 判断两个集合是否相等 */ public class CheckDiffList implements Serializable { public static void main(String[] args) { List<String> list = new ArrayList<>(); List<String> list1 = new ArrayList<>(); for (int i = 0; i < 1000; i++) { list.add("test" + i); list1.add("test" + (i * 2)); } System.out.println(checkDiffrent4(list, list1)); } /** * 使用stream流去比较两个数组是否相等 * 方法5 */ private static boolean checkDiffrent4(List<String> list, List<String> list1) { long st = System.nanoTime(); System.out.println("消耗时间为: " + (System.nanoTime() - st)); /** 先将集合转成stream流进行排序然后转成字符串进行比较 */ return list.stream().sorted().collect(Collectors.joining()) .equals(list1.stream().sorted().collect(Collectors.joining())); } }
结果:
99273484
false利用了Java8的新特性然后用collect(Collectors.joining())进行比较,虽然比较耗时,但是很好用是真的。
6. 使用list转成字符串进行比较是否相等
package list.demo; import java.io.Serializable; import java.util.*; import java.util.stream.Collectors; /** * 判断两个集合是否相等 */ public class CheckDiffList implements Serializable { public static void main(String[] args) { List<String> list = new ArrayList<>(); List<String> list1 = new ArrayList<>(); for (int i = 0; i < 1000; i++) { list.add("test" + i); list1.add("test" + (i * 2)); } System.out.println(checkDiffrent4(list, list1)); } /** * 使用list自带的sort方法先进性排序,然后转成toString去判断两个集合是否相等 * 方法6 */ private static boolean checkDiffrent5(List<String> list, List<String> list1) { long st = System.nanoTime(); System.out.println("消耗时间为: " + (System.nanoTime() - st)); list.sort(Comparator.comparing(String::hashCode)); list1.sort(Comparator.comparing(String::hashCode)); return list.toString().equals(list1.toString()); } }
结果:
2570
false个人感觉先将集合转成字符串,然后进行equal(),进行判断是一个比较优秀的方法, 比起用循环编辑要简洁很多。
二,总结
上面的六种方法的耗时时间依次是checkDiffrent5 < checkDiffrent1 < checkDiffrent2 < checkDiffrent < checkDiffrent3 < checkDiffrent4。所以最好的方法是使用list.sort()方法来进行排序,在用toString进行equal比较。
Security源代码地址:Security地址
附下我写的所有代码:package list.demo; import java.io.Serializable; import java.util.*; import java.util.stream.Collectors; /** * 判断两个集合是否相等 */ public class CheckDiffList implements Serializable { public static void main(String[] args) { List<String> list = new ArrayList<>(); List<String> list1 = new ArrayList<>(); for (int i = 0; i < 1000; i++) { list.add("test" + i); list1.add("test" + (i * 2)); } System.out.println(checkDiffrent(list, list1)); } /** * 方法一:使用循环遍历 */ private static boolean checkDiffrent(List<String> list, List<String> list1) { long st = System.nanoTime(); if(list.size() != list1.size()) { System.out.println("消耗时间:" + (System.nanoTime() - st)); return false; } for(String str : list) { if(!list1.contains(str)) { System.out.println("消耗时间:" + (System.nanoTime() - st)); return false; } } System.out.println("消耗时间:" + (System.nanoTime() - st)); return true; } /** * 方法2:利用List的 retainAll的方法进行判断 */ private static boolean checkDiffrent1(List<String> list, List<String> list1) { long st = System.nanoTime(); System.out.println("消耗时间为:" + (System.nanoTime() - st)); return !list.retainAll(list1); } /** * 方法3 * 利用HashMap key唯一,value可以重复的特点,把list中各种元素放到hashMap中 */ private static boolean checkDiffrent2(List<String> list, List<String> list1) { long st = System.nanoTime(); Map<String, Integer> map = new HashMap<>(list.size() + list1.size()); if (list.size() != list1.size()) { System.out.println("消耗时间为: " + (System.nanoTime() - st)); return false; } for (String str : list) { map.put(str, 1); } for (String str : list1) { Integer cc = map.get(str); if (null != cc) { continue; } System.out.println("消耗时间为: " + (System.nanoTime() - st)); return false; } System.out.println("消耗时间为: " + (System.nanoTime() - st)); return true; } /** * md5加密法使用 * 方法4 */ private static boolean getDiffrent3(List<String> list, List<String> list1) { long st = System.nanoTime(); /** 使用Security的md5方法进行加密 */ String str = SecureUtil.md5(list.toString()); String str1 = SecureUtil.md5(list1.toString()); System.out.println("消耗时间为: " + (System.nanoTime() - st)); return str.equals(str1); } /** * 使用stream流去比较两个数组是否相等 * 方法5 */ private static boolean checkDiffrent4(List<String> list, List<String> list1) { long st = System.nanoTime(); System.out.println("消耗时间为: " + (System.nanoTime() - st)); /** 先将集合转成stream流进行排序然后转成字符串进行比较 */ return list.stream().sorted().collect(Collectors.joining()) .equals(list1.stream().sorted().collect(Collectors.joining())); } /** * 使用list自带的sort方法先进性排序,然后转成toString去判断两个集合是否相等 * 方法6 */ private static boolean checkDiffrent5(List<String> list, List<String> list1) { long st = System.nanoTime(); System.out.println("消耗时间为: " + (System.nanoTime() - st)); list.sort(Comparator.comparing(String::hashCode)); list1.sort(Comparator.comparing(String::hashCode)); return list.toString().equals(list1.toString()); } }
-
集合 -- 如何判断两个字符串 List 集合中的元素是否完全相等
2020-12-29 22:37:54= null){ // 对作为参数的list进行排序 // 使得参与比较的list集合都有相同的排序规则 Collections.sort(list); listBuf.append(list.toString()); } return listBuf.toString(); } 输出结果: [A, C, D] [A, C, D...public static void main(String[] args){ List<String> list1 = new ArrayList<String>(); list1.add("A"); list1.add("C"); list1.add("D"); String str1 = getListId(list1); System.out.println(str1); List<String> list2 = new ArrayList<String>(); list2.add("A"); list2.add("D"); list2.add("C"); String str2 = getListId(list2); System.out.println(str2); boolean flag = str1.equals(str1); System.out.println(flag); } private static String getListId(List<String> list){ StringBuffer listBuf = new StringBuffer(); if(list != null){ // 对作为参数的list进行排序 // 使得参与比较的list集合都有相同的排序规则 Collections.sort(list); listBuf.append(list.toString()); } return listBuf.toString(); }
输出结果:
[A, C, D]
[A, C, D]
true -
正确重写hashcode hashcode与equals方法 集合元素如何判断是否相等 集合如何查看是否包含某个元素...
2016-02-29 18:17:00相等的两个对象,即equals(Object)方法判断两个对象相等,那么他们必须要有相同的hashcode hashcode相同的两个对象,他们可能相同,也可能不相同 简单地说可以这么理解,hashcode是java实现中经常用到的比如在HashMap ...首先记住两句话
相等的两个对象,即equals(Object)方法判断两个对象相等,那么他们必须要有相同的hashcode
hashcode相同的两个对象,他们可能相同,也可能不相同
简单地说可以这么理解,hashcode是java实现中经常用到的比如在HashMap HashSet,根据hashcode不等就可以断定两个对象不等,如果相等再去比较equals,大大减少了equals的调用次数,效率就高很多了
原理搜一下有很多文章,不再多说
重点说一下应用,大家或许看到很多地方说:
重写equals方法要同步重写hashcode,具体的怎么写却不知道
接下来就主要说一下,具体的怎么实现(小白围观,老鸟勿扰)
其实开场的两句话也是这个意思
场景:
当你需要实现你自己的对象上的逻辑相等时,需要重写equals方法
比如一个学生类
name,age,sex,class…等多重属性
假设就是public student{ //这么一个类
name
age
sex
class
}
(简写一下,不要较真…)
用自然语言说的话,就是姓名,性别,年龄,班级一样,在这个类上的话,我们就可以认为两个对象是相等的了
对吧
换成java语言就是
public boolean equals(Object obj) { if (obj instanceof Student) { Student student= (Student ) obj; if(this.name.equals(student.name) && this.age.equals(student.age)
&&this.sex.equals(student.sex)&&this.class.equals(student.class) ){ return true; } else{ return false; } //非该类实例,直接返回false } else{ return false; } }
很简单,比较相等,至少得是学生..不是直接返回false
如果是学生实例,就比较一下,姓名年龄性别班级,都相等了就是相等了
怎么保障重写equals方法后,这两个对象实例的hashcode也是一样的呢?
所有的hashcode都返回一样的值?答案是可以的在某些情况下,但是某些情况下你就要悲剧了,所以当然不要
常用的办法是用:判断相等的条件 用到的属性 来重写
直白点就是:利用刚才使用到的姓名 性别 年龄 班级 这几个属性的值来重写hashcode
使用它们的组合方式
可以使用这样子的形式
a1*属性1的int形式+a2 属性2的int形式+….
a为系数
所谓属性的int形式,大家要知道hashcode都是数值
这样子才能保障最后的结果也是一个int值,简单就这么理解吧
而且还有就是比如string已经有了他自己的hashcode实现了,可以直接调用的
比如我们的例子
我们可以这样子
public int hashCode() { // TODO Auto-generated method stub //根据判断是否相等的属性,来重写hashCode return ( this.name.hashCode() + this.sex.hashCode()+age+this.class.hashcode() ); }
系数可以随便,你甚至都可以用this.name.hashCode() *age
形式上可以变化多端
但是要注意几个条件就好了
1,相同的对象的hashcode肯定是相同的
2,最后生成的结果不能大于int的取值范围
3,尽可能的科学保证不是随随便便的一个对象hashcode都相等
友情提示:
[1]. HashSet判断、删除和添加元素等操作依据的是被操作元素所在的类的hashCode()和equals( )这两个方法。
[2]. ArrayList做同等的操作,依据的仅仅是equals( )方法
-
Java中如何判断一个集合中的一个元素不在另一个集合中?把不存在的元素移除
2017-03-20 23:41:30判断一个元素在集合中很容易,只需要遍历这个集合,然后与每个值进行比较,如果有相等的,那么就存在在集合中,然后反过来,就是不存在集合中的,找到它好像挺容易,但是写起代码来好像有点绕,那么,现在就把它写... -
java中写不在列表里_Java中如何判断一个集合中的一个元素不在另一个集合中?把不存在的元素移除...
2021-02-28 15:18:21判断一个元素在集合中很容易,只需要遍历这个集合,然后与每个值进行比较,如果有相等的,那么就存在在集合中,然后反过来,就是不存在集合中的,找到它好像挺容易,但是写起代码来好像有点绕,那么,现在就把它写... -
如何在Set集合中添加重复元素
2020-03-22 00:16:43Set集合元素重复比较 当你把对象加入HashSet时,HashSet会先计算对象的hashcode值来判断对象加入的位置,同时也会与其他已经加入的对象的hashcode值作比较,如果没有相符的hashcode,HashSet会假设对象没有... -
TreeMap和TreeSet在排序时如何比较元素?Collections工具类中的sort()方法如何比较元素?
2017-09-01 13:13:25TreeSet要求集合中的元素实现Comparable接口,并实现compareTo方法进行比较,如果compareTo方法实现的不好,可能会导致元素插入失败,因为集合内部也通过compareTo方法来比较元素是否相等(而不是通过equals),即... -
Java的set,map容器中如何唯一确定一个元素——hashCode()和equals()
2015-05-22 10:02:17问题描述如标题。 首先明确: 1.equals方法用于比较对象的内容是否相等(覆盖以后) 2.hashcode方法只有在集合中用到 ... 首先计算插入元素的hashCode,若容器中无与其相等的hashCode,则该元素肯定 -
stream去重_重复数据如何处理?List集合去重的四种方式
2020-12-19 04:34:04List集合在Java日常开发中是必不可少的,只要懂得运用各种各样的方法就可以大大提高我们开发的效率,适当活用各种方法才会使我们开发事半功倍。但是,有时候难免会遇到集合里的数据是重复的,需要进行去除。今天,就... -
JS 如何快速遍历一个集合
2019-04-25 20:32:53一般我们都是双重for循环去遍历一个集合里面的元素是否为选中。 比如: 集合A : [1,2,3,4,5] 集合B : [1,2] 判断集合A里面是否含有集合B? 一般我们会先遍历集合A,然后在遍历集合B,如果相等,那么直接就设置... -
java list 去重 相同的相加_JAVA开发技巧:重复数据如何处理?List集合去重的四种方式...
2020-12-21 08:33:39List集合在日常Java开发中是必不可少的,只要懂得运用各种各样的方法就可以大大提高我们开发的效率,适当活用各种方法才会使我们开发事半功倍。但是,有时候难免会遇到集合里的数据是重复的,需要进行去除。今天,就... -
0002_20170226_【我是菜鸟】_【Java】_HashSet中不能插入相同元素的原因
2017-02-26 17:42:08至于,HashSet中如何判断两个元素是否相同的,就没有深入学习。今天,看了一篇文章,终于是明白了。结论如下:**HashSet 判断两个对象相等的标准除了要求通过 equals() 方法比较返回 true 之外,还要求两个对象的 ... -
set中如何检重
2014-11-02 10:34:14将对象放入到集合中时,首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等,如果不相等直接将该对象放入集合中。 如果hashcode值相等,然后再通过equals方法判断要放入对象与集合中的任意... -
Set集合
2019-10-17 11:28:58Set是Collection子接口.模拟了数学上的集合概念 set集合存储特点: 不允许元素重复,当添加两个一样的元素的时候,添加会失败,add()方法返回false,判断两...在HashSet中如何判断两个对象是否相等的问题 两个对象的equ... -
Java集合之四Set、HashSet、LinkedHashSet、TreeSet
2017-12-17 20:41:58Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个 Set 集合中,则添加操作失败。 Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals 方法。 Set集合是如何判断两个元素是否相等的? 是... -
小学生级别Java笔记_无序集合Set接口下的两个类HashSet和TreeSet_2019/6/10
2019-06-13 09:58:321. HashSet集合是如何约束集合中对象不重复的 通过重写实体类的hashCode() 方法和equals(Object obj) 方法 当两个实体对象hashCode()相同时,自动调用equals(Object obj) 判断是否相同。若两次判断都相等,则add... -
集合框架-Set接口
2018-08-15 11:07:16在HashSet中如何判断两个对象是否相同问题 1、两个对象的equals方法比较相等,返回true,则说明是相同对象 2、两个对象的hashCode方法返回值相等 对象的hashCode值决定了对象在哈希表中的存储位置 二者缺一不可 ... -
java获取hashcode的值_Java如何计算hashcode值
2021-02-26 12:51:28在设计一个类的时候,很可能需要重写类的hashCode()方法,此外,在集合HashSet的使用上,我们也需要重写hashCode方法来判断集合元素是否相等。下面给出重写hashCode()方法的基本规则:· 在程序运行过程中,同一个... -
HashSet元素不重复底层比较
2017-07-30 16:27:12Set集合特点: 1.无序 2.不允许元素重复HashSet...hashCode()的值决定了该对象在该集合中的位置。 由于hashCode()值相同equals()返回false的情况比较麻烦,所以存储在哈希表中的对象都应该覆盖equals方法和h -
基于tensorflow的pix2pix代码中如何做到输入图像和输出图像分辨率不一致
2018-10-24 02:01:26问题:例如在自己制作了成对的输入(input256×256 target 200×256)后,如何让输入图像和输出图像分辨率不一致,例如成对图像中:input的分辨率是256×256, output 和target都是200×256,需要修改哪里的参数。... -
集合类(Collection) List/Set/Map... 的区别和联系
2010-12-17 23:15:00array还有一个缺点是,无法判断其中实际存有多少元素,length只是告诉我们array的容量。2、Java中有一个Arrays类,专门用来操作array。 arrays中拥有一组static函数,equals():比较两个array是否相等。array拥有相 -
为什么要重写hashcode()方法以及如何重写hashcode和equals方法
2017-08-23 20:02:30Java中的集合(Collection)有两类,一类是...通常想查找一个集合中是否包含某个对象,就是逐一取出每个元素与要查找的元素进行比较,当发现某个元素与要查找的对象进行equals方法比较的结果相等时,则停止继续查找并 -
Java如何计算hashcode值
2014-10-21 10:00:00在设计一个类的时候,很可能需要重写类的hashCode()方法,此外,在集合HashSet的使用上,我们也需要重写hashCode方法来判断集合元素是否相等。 下面给出重写hashCode()方法的基本规则: · 在程序运行过程中,...