【转载】Java集合容器全面分析
转自:http://blog.csdn.net/garfielder007/article/details/52143803
简介:
集合类Collection不是Java的核心类,是Java的扩展类。集合可以用来储存任何类型的对象,给程序员提供了代码编写的灵活性,但是同时也带来了类型安全的问题。JDK1.5集以上的版本支持Generics,这种新概念的提出改变了Java传统代码的编写方式。(Generics type)编程概念和技术应用于集合类,解决了集合类的类型安全问题,这可用于对任何数据类型的定义和操作。
集合和数组有了紧密的联系又有很多的不同之处。
集合和数组的相同之处:
1、它们都用来储存多个对象
2、有些集合类,例如ArrayList,实际上应用数组结构储存对象
集合类和数组的不同之处:
1、集合类是Java的扩充的API类,而数组是Java语言本身的数据结构
2、集合储存的对象是动态可变的,而数组的大小是静态不变的
3、集合只可用于储存对象,而数组可用来储存基本类型或者对象
4、集合一般使用方法,例如add(),或者iterator(),来添加或访问对象,而数组使用下标
5、集合可使用众多的方法,而数组可使用的方法较少
从整体的角度来看,集合类由两部分组成:Collection接口和Map接口。二级接口Set和List继承了Collection接口,并且导出三个常用的集合类HashSet、ArrayList、LinkedList
接口Map提供了两个常用的集合类:HaspMap、TreeMap
Collection和Map都包括在java。util包中。
Coll2ection定义接口类的基本方法,其二级接口Set与List是将集合类分为不同功能的两大类:Set(不允许有重复元素)、List(允许有重复元素)
虽然集合类有两个独立的接口构成,但是它们有着许多相同的集合操作方式,它们之间的不同在于对元素的储存方式。
1、Collection:定义对所有集合类操作的基本方法,例如size()/isEmpty()/contains()/add()/remove()/isterator()等15个方法,这是从Iterable接口继承而来。
2、Set:定义不允许重复元素和集合类的基本操作方法,集成Collection中的所有方法
3、List:定义允许重复元素的集合类的基本操作方法,继承了Collection‘中定义的所有方法,定义对一些方法的重载签名,增添了新的方法。
4、Map:定义对所有map集合类操作的基本方法,例如containsKey()/containsValue()/keySet()/put()/values()等14个方法,它本身就是一个根接口。
(1)ArrayList:数组式结构的集合类,其大小可自动调整,保持元素添加的位置,对元素的有序和随机访问非常有效,但不在结尾添加元素时效率不高
(2)LinkedList:与ArrayList相似,但应用链接式结构,不再结尾位置添加和删除元素非常有效
(3)HashSet:应用Hash码储存五重复元素的集合类,储存的元素必须完善hashCode()方法以保证其唯一性
我们在一般情况下,就可以把ArrayList和LinkedList看成是C语言中的数组和链表,它们的优劣性都可以参照一下。
Map接口中的常用类:
(1)HashMap:与HashSet相似,但它们属于不同的接口,以key-value一一对应的方式来储存无重复元素。
(2)TreeMap:与HashMap相似,但以树tree的数据结构储存元素,元素必须是key-value意义对应的方法储存,且自动按照key对象排序。
对于Map的KeySet()方法返回类型是Set,而Values()的返回类型是Collection。(应用性比较广)
下面两个程序,比较map中key-value的一一对应:
- package connections;
- import java.util.HashMap;
- import java.util.Map;
- public class EmployeeMapTest {
- public static void main(String[] args) {
- Map<String, String> employeeMap = new HashMap<String, String>();
- employeeMap.put("1000", "litianpeng");
- employeeMap.put("115", "zuxiaoyu");
- employeeMap.put("1102", "lihuanhuan");
- //employeeMap.put("115", "surprise");
- System.out.println(employeeMap);
- }
- }
运行截图:
- package connections;
- import java.util.HashMap;
- import java.util.Map;
- public class EmployeeMapTest {
- public static void main(String[] args) {
- Map<String, String> employeeMap = new HashMap<String, String>();
- employeeMap.put("1000", "litianpeng");
- employeeMap.put("115", "zuxiaoyu");
- employeeMap.put("1102", "lihuanhuan");
- employeeMap.put("115", "surprise");
- System.out.println(employeeMap);
- }
- }
运行截图:
可以看出来key=115的键值已经被替代了。
下面介绍Collection集合类:
1、ArraList:以数组作为实现的结构,氮元素不受固定空间的限制,是大小可变的数组,但是任何不再结尾处增添元素的操作,都需要移位,ArrayList可以接受任何Object对象作为它的元素,但不允许是基本类型,且对元素的访问和操作通过调用方法进行。
注意:系统预设ArrayList的元素数为10,可以指定ArrayList对象储存元素的大小,其空间将随着元素的增添和清除而自动增加或者减少。
2、LinkedList:链接表LinkedList与ArrayList相似,但应用节点node数据结构实现,因而提高了不再结尾处增添或者删除元素操作的效率。
3、HashSet:HashSet集合主要应用于简单快速、与检索有关的操作
HashSet与ArrayList和LinkedList相比,主要有下列不同的特点:
(1)应用hash表结构
(2)不允许有重复的元素
(3)元素是无序的,即按照哈希码储存
(4)自定义集合元素必须覆盖hashcode()方法来产生哈希码
4、Iterator:元素迭代器,在ArrayList和LinkedList中都提供方法iterator(),用来返回一个指定类型的元素迭代器Iterator对集合的引用,用来对各元素按次序遍历。
boolean hasNext():如果仍有元素,返回真,否则返回假
E next():返回下一个元素
void remove():删除迭代器当前指向集合中的元素
下面介绍Map集合类:
主要包括HashMap和TreeMap两大类,它们中的每一个元素必须应用一对key-value来储存。由key来映射value。
注意
(1)key与value必须是对象,而不允许是基本数据类型
(2)key在一个集合中必须具有唯一性,即key不允许有重复,但允许有重复的value出现
1、HashMap:HashMap实现Map接口,它利用Hash表结构,因而集合中的元素不按次序排列。
注意:系统预设HashMap的元素数目为16,也可以自己指定HashMap储存的元素数目。
由于HashMap不支持迭代器,可以利用keySet()方法,以set引用返回HashMap集合中所有的key,再利用元素迭代器对元素进行遍历,对元素的遍历,可以调用values()实现
2、TreeMap:TreeMap与HashMap相似,实现了Map接口,所有元素都是key-value的映射。两者之间的不同点在于
(1)TreeMap是应用于Tree数据结构储存key-value元素,而HashMap利用Hash表结构
(2)TreeMap集合中的各个映射单元是按照key自动排序的,而HashMap集合中的各映射单元是无序的
(3)TreeMap集合更加有效利用存储空间,而HashMap必须指定或者使用预设映射单元存储空间
一、Set与Map
Set集合的继承体系:
Map集合的继承体系:
从上面的继承关系我们可以看出来,实现Map接口和Set接口的接口名、类名完全相似。
从上一篇博文的分析我们可以知道,Map集合的key具有一个特征:所有的key不能重复,且key之间没有顺序(TreeMap是有顺序的),如果将Map集合的所有key集中起来,那这些key就组成了一个set集合,则map集合提供了keySet()方法返回所有key组成的集合。这样就实现了Map到Set之间的转换。其实也可以实现Set到Map之间的转换。
下面简单实现一下将Set扩展成Map,自定义个一个SimpleEntry类,
代码如下:
- package com.crazyit;
- import java.util.HashSet;
- import java.util.Iterator;
- import java.util.Map;
- class SimpleEntry<K, V> implements Map.Entry<K, V>, java.io.Serializable {
- private final K key;
- private V value;
- public SimpleEntry(K key, V value) {
- this.key = key;
- this.value = value;
- }
- public SimpleEntry(Map.Entry<? extends K, ? extends V> entry) {
- this.key = entry.getKey();
- this.value = entry.getValue();
- }
- public K getKey() {
- return key;
- }
- public V getValue() {
- return value;
- }
- public V setValue(V value) {
- V oldValue = this.value;
- this.value = value;
- return oldValue;
- }
- public boolean equals(Object o) {
- if (o == this) {
- return true;
- }
- if (o.getClass() == SimpleEntry.class) {
- SimpleEntry se = (SimpleEntry) o;
- return se.getKey().equals(getKey());
- }
- return false;
- }
- public int hashCode() {
- return key == null ? 0 : key.hashCode();
- }
- public String toString() {
- return key + "=" + value;
- }
- }
- public class Set2Map<K, V> extends HashSet<SimpleEntry<K, V>> {
- public void clear() {
- super.clear();
- }
- public boolean containsKey(K key) {
- return super.contains(new SimpleEntry<K, V>(key, null));
- }
- boolean containsValue(Object value) {
- for (SimpleEntry<K, V> se : this) {
- if (se.getValue().equals(value)) {
- return true;
- }
- }
- return false;
- }
- public V get(Object key) {
- for (SimpleEntry<K, V> se : this) {
- if (se.getKey().equals(key)) {
- return se.getValue();
- }
- }
- return null;
- }
- public V put(K key, V value) {
- add(new SimpleEntry<K, V>(key, value));
- return value;
- }
- public void putAll(Map<? extends K, ? extends V> m) {
- for (K key : m.keySet()) {
- add(new SimpleEntry<K, V>(key, m.get(key)));
- }
- }
- public V removeEntry(Object key) {
- for (Iterator<SimpleEntry<K, V>> it = this.iterator(); it.hasNext();) {
- SimpleEntry<K, V> en = (SimpleEntry<K, V>) it.next();
- if (en.getKey().equals(key)) {
- V v = en.getValue();
- it.remove();
- return v;
- }
- }
- return null;
- }
- public int size() {
- return super.size();
- }
- }
自定义的一个SimpleEntry<K,V>类,当一个Set的所有集合元素都是SimpleEntry<K,V>对象的时候,该Set就变成了一个Map<K,V>集合。接下来,程序以HashSet<SimpleEntry<K,V>>为父类派生了一个子类Set2Map<K,V>,这个扩展类完全可以被当成Map使用,因此上面程序中的Set2Map<K,V>类中也提供了Map集合应该提供的绝大部分方法。
总结:可以通过对Set加以改造,将Set变为Map,这个改造的Map集合在功能上几乎可以和系统提供的Map一样。
二、HashMap与HashSet分析比较:
1、HashMap与HashSet都是采用传统的Hash算法决定集合的存储位置,这样可以保证快速存、取集合元素。
注意:集合虽然说存储Java对象,但实际上不会真正将Java对象放入Set集合中,而只是在Set集合中保留这些对象的引用罢了。
对于HashMap、HashSet及其子类而言,它们采用了Hash算法来决定集合中元素的存储位置
当在创建HashMap的时候,有一个默认的负载因子,其默认值为0.75,,这是时间和空间成本上的一种折衷,增大负载因子就可以减少Hash表所占用的内存空间,但会增加查询数据的时间开销,而查询又是最频繁的操作。减小负载因子会提高数据查询的性能,但是增加Hash表所占用的内存空间。
2、对于HashSet,它是基于HashMap实现的,HashSet底层采用HashMap来保存所有的元素,因此HashSet的实现相对容易一些。
注意:HashSet的绝大部分方法都是通过调用HashMap来实现的,因此HashSet和HashMap两个集合在实现本质上是相同的。
如果向HashSet中添加一个已经存在的元素,新添加的集合元素不会覆盖已有的集合元素。
下面我们看一个精彩的程序:
- package com.crazyit;
- import java.util.HashSet;
- import java.util.Set;
- public class HashSetTest {
- public static void main(String[] args) {
- Set<Name> s = new HashSet<Name>();
- s.add(new Name("li", "tianpeng"));
- System.out.println(s.contains(new Name("li", "tianpeng")));
- }
- }
- class Name {
- private String first;
- private String last;
- public Name(String first, String last) {
- this.first = first;
- this.last = last;
- }
- }
下面是结果截图:
打印出来的结果竟然是“false”,我们命名已经添加了一个new Name("abc","123")对象。
这是因为HashSet判断两个对象相等的标准除了要通过equals()方法比较返回true之外,还要两个对象的hashCode()返回值相等,而上面的程序没有没有重写Name类的hashCode()方法,两个Name对象的返回值并不相等,因此HashSet会把它们当成2个对象来处理。
下面重写了hashCode()方法:
- package com.crazyit;
- import java.util.HashSet;
- import java.util.Set;
- public class HashSetTest {
- public static void main(String[] args) {
- Set<Name> s = new HashSet<Name>();
- s.add(new Name("li", "tianpeng"));
- System.out.println(s.contains(new Name("li", "tianpeng")));
- }
- }
- class Name {
- private String first;
- private String last;
- public Name(String first, String last) {
- this.first = first;
- this.last = last;
- }
- public int hashCode() {
- return first.hashCode();
- }
- public boolean equals(Object o) {
- if (this == o)
- return true;
- if (o.getClass() == Name.class) {
- Name n = (Name) o;
- return n.first.equals(first);
- }
- return false;
- }
- }
运行结果截图如下:
三、TreeMap与TreeSet比较分析:
1、TreeSet底层采用一个NavigableMap来保存TreeSet集合的元素,但是,由于NavigableMap只是一个接口,因此底层仍然使用TreeMap来包含集合中所有元素。
注意:TreeSet里绝大部分方法都是直接调用TreeMap的方法来实现的。
2、TreeMap则采用一种“红黑树”的排序二叉树来保存Map中的每一个元素,每个元素被当成“红黑树”的一个节点对待。
每次添加一个新元素时,此新元素作为“红黑树”的根节点被添加到已有的红黑树中。这样利用红黑树可以快速地插入与删除还有查找。
下面是TreeMap的应用程序:
- package com.crazyit;
- import java.util.TreeMap;
- public class TreeMapTest {
- public static void main(String[] args) {
- TreeMap<String, Double> map = new TreeMap<String, Double>();
- map.put("ccc", 89.0);
- map.put("zzz", 89.0);
- map.put("aaa", 89.0);
- map.put("bbb", 89.0);
- System.out.println(map);
- }
- }
运行结果如下:
关于红黑树的介绍:以后我们会慢慢提到。
总结:Treemap本质上就是一个“红黑树”,而TreeMap上的每一个元素就是该红黑树上的节点。
四、Map和List比较分析:
1、Map的values()方法,Map集合是一个关联数组,Map可以根据key来获取对应的value,所以这些value可以组成一个List集合。但是Map的values()方法并未返回一个List集合。
可以从下面的代码中看出:
- package com.crazyit;
- import java.util.HashMap;
- import java.util.TreeMap;
- public class MapValueTest {
- public static void main(String[] args) {
- HashMap<String, Double> scores = new HashMap<String, Double>();
- scores.put("语文", 89.0);
- scores.put("数学", 83.0);
- scores.put("英文", 84.0);
- System.out.println(scores.values());
- System.out.println(scores.values().getClass());
- TreeMap<String, Double> health = new TreeMap<String, Double>();
- health.put("身高", 173.0);
- health.put("体重", 171.0);
- System.out.println(health.values());
- System.out.println(health.values().getClass());
- }
- }
运行结果如下:
可以看出来Map中values()方法返回的值的集合不是List对象。
2、TreeMap:与HashMap优点类似,TreeMap的values()方法返回同样的Values对象,但是此处的Values类是TreeMap的私有内部类,因为TreeMap是用“红黑树”实现的,所以此时Values类当然要考虑红黑树的一些特性。
总结:HashMap和TreeMap中的values()方法并未把Map中的value重新组合成一个包含元素的集合对象,这样可以大大降低系统的开销。
五、Map和List的分析比较:
Map与Set的底层结构很相似,从用法也有一些相似的地方:
(1)Map接口提供了get(K key)方法允许Map对象根据key取得value
(2)List接口提供了get(int index)方法允许List对象根据元素索引取得value
可以把List看成所有key都是int类型的Map,也可以把Map看成key可以是任何类型的List。
六、ArrayList和LinkedList分析比较:
在List集合的实现类中,主要有3种:ArrayList、Vector和LinkedList。其中Vector还有一个Stack子类,此Stack子类仅在Vector父类的基础上增加了5个方法,这5个方法就将一个Vector扩展成了Stack,实际从本质上来讲,Stack仍然是一个Vector,它只是比Vector多了5个方法罢了。
但实际上,Java不推荐使用Stack类,而使推荐使用Deque实现类,Java提供了一个Deque接口,并为该接口提供了一个ArrayDeque实现类,在无需保证线程安全的情况下,程序完全可以使用ArrayDeque来代替Stack类。
Deque接口代表双端队列这种数据结构,它既有队列FIFO的性质,也有栈FILO的性质。
1、Vector与ArrayList区别:
(1)从序列化机制来看,ArrayList的实现比Vector实现更安全
(2)但Vector是ArrayList的线程安全版本,Vector和ArrayList的绝大部分方法都是相同的,只是Vector的方法增加了synchronized关键字
注意:在多线程条件下使用List集合,而且需要保证List集合的线程安全,仍然可以不使用Vector,考虑将ArrayList包装成线程安全的集合类。Java提供了一个Collections工具类,通过该工具类synchronizedList方法可以将一个普通的ArrayList包装成线程安全的ArrayList。
2、ArrayList和LinkedList区别:
(1)ArrayList是一种顺序存储的线性表
(2)LinkedList是一种链式存储的线性表,其本质就是一个双向链表,因为它不仅实现了List接口,而且实现了Deque接口。
总结:ArrayList取数的性能优越,LinkedList插入、删除的性能优越。
七、Iterator迭代器:
下面看关于迭代器的几个代码:
- package com.crazyit;
- import java.util.ArrayList;
- import java.util.Iterator;
- public class ArrayListRemove {
- public static void main(String[] args) {
- ArrayList<String> list = new ArrayList<String>();
- list.add("111");
- list.add("222");
- list.add("333");
- Iterator<String> it = list.iterator();
- while (it.hasNext()) {
- String ele = it.next();
- if (ele.equals("222"))
- list.remove(ele);
- }
- }
- }
此时并没有产生异常,
下面再看一个代码:
- package com.crazyit;
- import java.util.ArrayList;
- import java.util.Iterator;
- public class ArrayListRemove {
- public static void main(String[] args) {
- ArrayList<String> list = new ArrayList<String>();
- list.add("111");
- list.add("222");
- list.add("333");
- Iterator<String> it = list.iterator();
- while (it.hasNext()) {
- String ele = it.next();
- if (ele.equals("333"))
- list.remove(ele);
- }
- }
- }
此时会产生如下异常:
- package com.crazyit;
- import java.util.Iterator;
- import java.util.TreeSet;
- public class ArrayListRemove {
- public static void main(String[] args) {
- TreeSet<String> set = new TreeSet<String>();
- set.add("111");
- set.add("222");
- set.add("333");
- Iterator<String> it = set.iterator();
- while (it.hasNext()) {
- String ele = it.next();
- if (ele.equals("333"))
- set.remove(ele);
- }
- }
- }
此时并不会产生异常,
再看下面的代码:
- package com.crazyit;
- import java.util.Iterator;
- import java.util.TreeSet;
- public class ArrayListRemove {
- public static void main(String[] args) {
- TreeSet<String> set = new TreeSet<String>();
- set.add("111");
- set.add("222");
- set.add("333");
- Iterator<String> it = set.iterator();
- while (it.hasNext()) {
- String ele = it.next();
- if (ele.equals("222"))
- set.remove(ele);
- }
- }
- }
此时产生如下异常:
总结:
(1)实际上,对于ArrayList、Vector、LinkedList等List集合而言,如果正在遍历倒数第2个集合元素,使用List集合的remove()方法删除集合的任意一个元素并不会发生异常,当正在遍历其他元素时删除其他元素就会发生相关异常。
(2)对于TreeSet、HashSet等Set集合而言,当使用Iterator遍历它们时,如果正在遍历最后一个集合元素时,使用Set集合的remove()方法删除结婚的元素并不会引发异常,但是如果在遍历其他集合元素时删除其他元素,就会引发相关异常。
因为对于List集合,如果在遍历最后第2个元素时执行删除操作,则List调用Iterator对应的hashNext()方法判断已经没有下一个元素了,则不会取next()了。
而对于Set集合,在遍历最后一个元素时,此时遍历操作已经完成,删除Set中元素不会产生任何影响。
from: http://blog.csdn.NET/litianpenghaha/article/details/22575639?utm_source=tuicool&utm_medium=referral
http://blog.csdn.Net/litianpenghaha/article/details/22601041
【转载】Java集合容器全面分析的更多相关文章
- [转载]Java集合容器简介
Java集合容器主要有以下几类: 1,内置容器:数组 2,list容器:Vetor,Stack,ArrayList,LinkedList, CopyOnWriteArrayList(1.5),Attr ...
- java集合源码分析(六):HashMap
概述 HashMap 是 Map 接口下一个线程不安全的,基于哈希表的实现类.由于他解决哈希冲突的方式是分离链表法,也就是拉链法,因此他的数据结构是数组+链表,在 JDK8 以后,当哈希冲突严重时,H ...
- Java集合容器简介
Java集合容器主要有以下几类: 1,内置容器:数组 2,list容器:Vetor,Stack,ArrayList,LinkedList, CopyOnWriteArrayList(1.5),Attr ...
- Java 集合源码分析(一)HashMap
目录 Java 集合源码分析(一)HashMap 1. 概要 2. JDK 7 的 HashMap 3. JDK 1.8 的 HashMap 4. Hashtable 5. JDK 1.7 的 Con ...
- java集合源码分析(三):ArrayList
概述 在前文:java集合源码分析(二):List与AbstractList 和 java集合源码分析(一):Collection 与 AbstractCollection 中,我们大致了解了从 Co ...
- 面霸篇:Java 集合容器大满贯(卷二)
面霸篇,从面试角度作为切入点提升大家的 Java 内功,所谓根基不牢,地动山摇. 码哥在 <Redis 系列>的开篇 Redis 为什么这么快中说过:学习一个技术,通常只接触了零散的技术点 ...
- [转载] Java集合框架之小结
转载自http://jiangzhengjun.iteye.com/blog/553191 1.Java容器类库的简化图,下面是集合类库更加完备的图.包括抽象类和遗留构件(不包括Queue的实现): ...
- Java集合源码分析(三)LinkedList
LinkedList简介 LinkedList是基于双向循环链表(从源码中可以很容易看出)实现的,除了可以当做链表来操作外,它还可以当做栈.队列和双端队列来使用. LinkedList同样是非线程安全 ...
- [转载] Java集合---HashMap源码剖析
转载自http://www.cnblogs.com/ITtangtang/p/3948406.html 一.HashMap概述 HashMap基于哈希表的 Map 接口的实现.此实现提供所有可选的映射 ...
随机推荐
- 0级搭建类008-Ubuntu Server Linux安装 (18.04.2) 公开
项目文档引子系列是根据项目原型,制作的测试实验文档,目的是为了提升项目过程中的实际动手能力,打造精品文档AskScuti. 项目文档引子系列目前不对外发布,仅作为博客记录.如学员在实际工作过程中需提前 ...
- Office办公软件Excel使用整理
Office办公软件Excel使用整理 Excel默认打印预览于当前连接的打印机的纸张大小保持一致. Excel sheet不见了怎么办 -------------- 设置Excel第二页打印开始的位 ...
- 你写的 Python 代码总是不规范?用它!
今天咱们来说说 代码风格 ! 不同的编程语言 有不同的代码风格 Python 的代码规范 就是人们常说的 PEP8 在这个网站 https://www.python.org ...
- asp.net core 自定义基于 HttpContext 的 Serilog Enricher
asp.net core 自定义基于 HttpContext 的 Serilog Enricher Intro 通过 HttpContext 我们可以拿到很多有用的信息,比如 Path/QuerySt ...
- 教你阅读Python开源项目代码
为什么要阅读开源代码 阅读 Python 开源项目代码主要有如下三个原因: 在工作过程中遇到一些问题 Google 和 StackOverFlow 等网站找不到解决办法,只能去翻源码. 对某些项目或者 ...
- python笔记06
python笔记06 数据类型 上个笔记内容补充 补充 列表 reverse,反转. v1 = [1,2,3111,32,13] print(v1) v1.reverse() print(v1) v1 ...
- Flask知识总结
1.-----------------路由设置的2种方式----------------- 查看源码,route方法里,本质是执行app.add_url_rule() 因此可以这么写(主流方式): @ ...
- Linux下用Bash语言实现输出最大值的功能
题目链接: 题目描述 编写一个程序,输入a.b.c三个值,输出其中最大值. 输入 一行数组,分别为a b c 输出 a b c其中最大的数 样例输入 10 20 30 样例输出 30 复习下Linux ...
- [USACO17DEC] Barn Painting - 树形dp
设\(f[i][j]\)为\(i\)子树,当\(i\)为\(j\)时的方案数 #include <bits/stdc++.h> using namespace std; #define i ...
- Mesh R-CNN 论文翻译(实验部分)
本文为 Mesh R-CNN 论文翻译(原理部分)的后续.Mesh R-CNN 原论文. 4 实验 我们在ShapeNet上对网格预测分支进行基准测试,并与最先进的方法相比较.然后,我们在野生的有 ...