-
集合框架
2019-06-05 22:01:12如果不知道程序运行时需要多少对象,或者需要更复杂的方式类存储对象,可以使用集合框架,collection集合框架用来存储和操作不同类型的对象数组。 三.集合框架的体系 集合框架中提供了一个内部类专门操作集合中的元素...一.概念
集合框架:动态的对象数组,集合无需指定长度,可动态扩张
二.为什么需要集合框架
如果不知道程序运行时需要多少对象,或者需要更复杂的方式类存储对象,可以使用集合框架,collection集合框架用来存储和操作不同类型的对象数组。
三.集合框架的体系
集合框架中提供了一个内部类专门操作集合中的元素,这个内部类就是迭代器 数据结构
集合框架的由来:数据多了用对象进行存储,对象多了用集合来进行存储。而存储数据的方式(数据结构)各有不同,所以存储的容器也就有多种,从而形成了集合框架这一体系。
四.ArrayList与Linkedlist的区别
ArrayList:数据结构不同、数组结构、查询快、增删慢、增长因子1.5倍
Linkedlist:链表结构、查询慢、增删快、addFirst(特有的增加方法)removeFirst(特有的移除方法)1.ArrayList是实现了基于动态数组的数据结构,LinkedList是基于链表结构。 2.对于随机访问的get和set方法,ArrayList要优于LinkedList,因为LinkedList要移动指针。 3.对于新增和删除操作add和remove,LinkedList比较占优势,因为ArrayList要移动数据。
五.去除list集合中重复元素
1.定义去重的方法(定义一个新的容器,判断新的容器是否包含指定的元素,如果包含,那么不添加新容器中,如果不包含,那么添加到新容器中)ArrayList list = new ArrayList(); list.add(26); list.add(39); list.add(5); list.add(40); list.add(39); list.add(25); ArrayList newlist=repeatlist(list); System.out.println(list.size()); System.out.println(newlist.size()); } private static ArrayList repeatlist(ArrayList list) { // TODO Auto-generated method stub ArrayList newlist = new ArrayList(); for (Object object : list) { if(!newlist.contains(object)) { newlist.add(object); } } return newlist; }
2.自定义的对象需要去去重的话,就需要重写Object的equals方法public class Quchong { public static void main(String[] args) { ArrayList l = new ArrayList(); l.add(new person(18, "张三")); l.add(new person(20, "李四")); l.add(new person(23, "王五")); l.add(new person(18, "张三")); l.add(new person(19, "麻子")); ArrayList newlist=repeatlist(l); System.out.println(l.size()); System.out.println(newlist.size()); } private static ArrayList repeatlist(ArrayList list) { // TODO Auto-generated method stub ArrayList newlist = new ArrayList(); for (Object object : list) { if(!newlist.contains(object)) { newlist.add(object); } } return newlist; } } class person{ private int age; private String name; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public person() { super(); } public person(int age, String name) { super(); this.age = age; this.name = name; } @Override public String toString() { return "person [age=" + age + ", name=" + name + "]"; } @Override public boolean equals(Object obj) { if(obj instanceof person) { person p=(person)obj; System.out.println(this.getName()+"——————————"+p.getName()); return this.getName().equals(p.getName()) && this.getAge()==p.getAge(); } return false; } }
六.堆栈与队列
1.堆栈的特性:元素先加入最后移除(子弹夹)public static void main(String[] args) { DuiZhan dz=new DuiZhan(); dz.push("a"); dz.push("b"); dz.push("c"); dz.push("d"); dz.bianli(); } } class DuiZhan{ private LinkedList d=new LinkedList(); //堆栈的增加方法(addfirst) public void push(Object obj) { d.addFirst(obj); } //堆栈的移除方法(removefirst) public Object pop() { return d.removeFirst(); } //根据迭代器方式的遍历 public void bianli() { Iterator iterator = d.iterator(); while(iterator.hasNext()) { System.out.println(iterator.next()); } }
1.队列的特性:元素先加入先移除(水管)public static void main(String[] args) { DuiZhan dz=new DuiZhan(); dz.push("a"); dz.push("b"); dz.push("c"); dz.push("d"); dz.bianli(); } } class DuiZhan{ private LinkedList d=new LinkedList(); //队列的增加方法(addlast) public void push(Object obj) { d.addLast(obj); } //队列的移除方法(removefirst) public Object pop() { return d.removeFirst(); } //根据迭代器方式的遍历 public void bianli() { Iterator iterator = d.iterator(); while(iterator.hasNext()) { System.out.println(iterator.next()); } }
(下图是辅助用图)
七.vector中的枚举
枚举有自己特有的遍历方式,但是与迭代器也是相差不大Vector v=new Vector<>(); v.add(22); v.add(25); v.add(26); v.add(28); v.add(29); Enumeration elements = v.elements(); while(elements.hasMoreElements()) { System.out.println(elements.nextElement()); } }
八.collection
list集合的三种遍历方法ArrayList list = new ArrayList(); list.add(26); list.add(39); list.add(5); list.add(40); list.add(39); list.add(25); //集合list的三种遍历方式 //1.根据集合下标进行for循环 for (int i = 0; i <list.size(); i++) { System.out.println(list.get(i)); } //2.运用迭代器进行遍历 Iterator iterator = list.iterator(); while(iterator.hasNext()) { System.out.println(iterator.next()); } //3.foreach方法遍历 for (Object object : list) { System.out.println(object); }
-
Java集合框架总结
2019-08-08 09:13:16集合框架:用于存储数据的容器。 集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。 任何集合框架都包含三大块内容:对外的接口、接口的实现和对集合运算的算法。 接口:表示集合的抽象数据类型。接口...简介
集合框架:用于存储数据的容器。
集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。
任何集合框架都包含三大块内容:对外的接口、接口的实现和对集合运算的算法。接口:表示集合的抽象数据类型。接口允许我们操作集合时不必关注具体实现,从而达到“多态”。在面向对象编程语言中,接口通常用来形成规范。
实现:集合接口的具体实现,是重用性很高的数据结构。
算法:在一个实现了某个集合框架中的接口的对象身上完成某种有用的计算的方法,例如查找、排序等。这些算法通常是多态的,因为相同的方法可以在同一个接口被多个类实现时有不同的表现。事实上,算法是可复用的函数。
它减少了程序设计的辛劳。集合框架通过提供有用的数据结构和算法使你能集中注意力于你的程序的重要部分上,而不是为了让程序能正常运转而将注意力于低层设计上。
通过这些在无关API之间的简易的互用性,使你免除了为改编对象或转换代码以便联合这些API而去写大量的代码。 它提高了程序速度和质量。特点
-
对象封装数据,对象多了也需要存储。集合用于存储对象。
-
对象的个数确定可以使用数组,对象的个数不确定的可以用集合。因为集合是可变长度的。
集合和数组的区别
-
数组是固定长度的;集合可变长度的。
-
数组可以存储基本数据类型,也可以存储引用数据类型;集合只能存储引用数据类型。
-
数组存储的元素必须是同一个数据类型;集合存储的对象可以是不同数据类型。
数据结构:就是容器中存储数据的方式。
对于集合容器,有很多种。因为每一个容器的自身特点不同,其实原理在于每个容器的内部数据结构不同。
集合容器在不断向上抽取过程中,出现了集合体系。在使用一个体系的原则:参阅顶层内容。建立底层对象。
使用集合框架的好处
- 容量自增长;
- 提供了高性能的数据结构和算法,使编码更轻松,提高了程序速度和质量;
- 允许不同 API 之间的互操作,API之间可以来回传递集合;
- 可以方便地扩展或改写集合,提高代码复用性和可操作性。
- 通过使用JDK自带的集合类,可以降低代码维护和学习新API成本。
Iterator接口
Iterator接口,用于遍历集合元素的接口。
在Iterator接口中定义了三个方法:
修饰与类型 方法与描述 boolean
hasNext()
如果仍有元素可以迭代,则返回true。E
next()
返回迭代的下一个元素。void
remove()
从迭代器指向的 collection 中移除迭代器返回的最后一个元素(可选操作)。每一个集合都有自己的数据结构(就是容器中存储数据的方式),都有特定的取出自己内部元素的方式。为了便于操作所有的容器,取出元素。将容器内部的取出方式按照一个统一的规则向外提供,这个规则就是Iterator接口,使得对容器的遍历操作与其具体的底层实现相隔离,达到解耦的效果。
也就说,只要通过该接口就可以取出Collection集合中的元素,至于每一个具体的容器依据自己的数据结构,如何实现的具体取出细节,这个不用关心,这样就降低了取出元素和具体集合的耦合性。
使用迭代器遍历集合元素
public static void main(String[] args) { List<String> list1 = new ArrayList<>(); list1.add("abc0"); list1.add("abc1"); list1.add("abc2"); // while循环方式遍历 Iterator it1 = list1.iterator(); while (it1.hasNext()) { System.out.println(it1.next()); } // for循环方式遍历 for (Iterator it2 = list1.iterator(); it2.hasNext(); ) { System.out.println(it2.next()); } }
使用Iterator迭代器进行删除集合元素,则不会出现并发修改异常。
因为:在执行remove操作时,同样先执行checkForComodification(),然后会执行ArrayList的remove()方法,该方法会将modCount值加1,这里我们将expectedModCount=modCount,使之保持统一。
ListIterator接口
ListIterator是一个功能更加强大的迭代器, 它继承于Iterator接口,只能用于各种List类型的访问。可以通过调用listIterator()方法产生一个指向List开始处的ListIterator, 还可以调用listIterator(n)方法创建一个一开始就指向列表索引为n的元素处的ListIterator。
特点
- 允许我们向前、向后两个方向遍历 List;
- 在遍历时修改 List 的元素;
- 遍历时获取迭代器当前游标所在位置。
常用API
修饰与类型 方法与描述 void
add(E e)
将指定的元素插入到列表 (可选操作)。boolean
hasNext()
如果此列表迭代器在前进方向还有更多的元素时,返回true
。boolean
hasPrevious()
如果此列表迭代器在相反方向还有更多的元素时,返回true
。E
next()
返回列表中的下一个元素和光标的位置向后推进。int
nextIndex()
返回调用next()
后返回的元素索引。E
previous()
返回列表中的上一个元素和光标的位置向前移动。int
previousIndex()
返回调用previous()
后返回的元素索引 。void
remove()
删除列表中调用next()
或previous()
的返回最后一个元素。void
set(E e)
用指定元素替换列表中调用next()
或previous()
的返回最后一个元素。Collection接口
所有集合类都位于java.util包下。Java的集合类主要由两个接口派生而出:Collection和Map,Collection和Map是Java集合框架的根接口,这两个接口又包含了一些子接口或实现类。
-
Collection一次存一个元素,是单列集合;
-
Map一次存一对元素,是双列集合。Map存储的一对元素:键–值,键(key)与值(value)间有对应(映射)关系。
单列集合继承关系图
Collection集合主要有List和Set两大接口
-
List:有序(元素存入集合的顺序和取出的顺序一致),元素都有索引。元素可以重复。
-
Set:无序(存入和取出顺序有可能不一致),不可以存储重复元素。必须保证元素唯一性。
List集合
List是元素有序并且可以重复的集合。
List的主要实现:ArrayList, LinkedList, Vector。
List常用方法
ArrayList、LinkedList、Vector 的区别
ArrayList LinkedList Vector 底层实现 数组 双向链表 数组 同步性及效率 不同步,非线程安全,效率高,支持随机访问 不同步,非线程安全,效率高 同步,线程安全,效率低 特点 查询快,增删慢 查询慢,增删快 查询快,增删慢 默认容量 10 / 10 扩容机制 int newCapacity = oldCapacity + (oldCapacity >> 1);//1.5 倍 / 2 倍 总结:
- ArrayList 和 Vector 基于数组实现,对于随机访问get和set,ArrayList优于LinkedList,因为LinkedList要移动指针。
- LinkedList 不会出现扩容的问题,所以比较适合随机位置增、删。但是其基于链表实现,所以在定位时需要线性扫描,效率比较低。
- 当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能;
- 当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。
遍历时操作元素
遍历集合时,同时操作集合中的元素(增删等)
/** * Description: for循环遍历 * 输出结果: * [a, b, c, d, e] * 由结果可知,第二个元素b并未删除,原因是当第一个元素b被删除后,它后面所有的元素都向前移动了一个单位,循环时导致第二个元素b漏掉了 */ public static void remove(List<String> list) { for (int i = 0; i < list.size(); i++) { String s = list.get(i); if (s.equals("b")) { list.remove(s); } } } /** * Description: foreach循环遍历 * * 会报错:java.util.ConcurrentModificationException。这是因为在这里,foreach循环遍历容器本质上是使用迭代器进行遍历的,会对修改次数modCount进行检查,不允许集合进行更改操作 */ public static void remove2(List<String> list) { for (String s : list) { if (s.equals("b")) { list.remove(s); } System.out.println(s); } } /** * Description: 使用迭代器遍历 */ public static void remove3(List<String> list) { Iterator<String> it = list.iterator(); while (it.hasNext()) { String s = it.next(); if (s.equals("b")) { it.remove(); } } }
使用迭代器遍历删除时,能够避免方法二中出现的问题。这是因为:在ArrayList中,modCount是指集合的修改次数,当进行add或者delete时,modCount会+1;expectedModCount是指集合的迭代器的版本号,初始值是modCount,但是当集合进行add或者delete操作时,modCount会+1,而expectedModCount不会改变,所以方法二中会抛出异常。但是it.remove操作时,会同步expectedModCount的值,把modCount的值赋予expectedModCount。所以不会抛出异常。
测试方法
public static void main(String[] args) { List<String> arrayList = new ArrayList<String>(); arrayList.add("a"); arrayList.add("b"); arrayList.add("b"); arrayList.add("c"); arrayList.add("d"); arrayList.add("e"); // remove(arrayList); // remove2(arrayList); remove3(arrayList); System.out.println(arrayList); }
总结:如果想正确的循环遍历删除(增加)元素,需要使用方法三,也就是迭代器遍历删除(增加)的方法。
Set集合
Set集合元素无序(存入和取出的顺序不一定一致),并且没有重复对象。
Set的主要实现类:HashSet, TreeSet。Set常用方法
HashSet、TreeSet、LinkedHashSet的区别
HashSet TreeSet LinkedHashSet 底层实现 HashMap 红黑树 LinkedHashMap 重复性 不允许重复 不允许重复 不允许重复 有无序 无序 有序,支持两种排序方式,自然排序和定制排序,其中自然排序为默认的排序方式。 有序,以元素插入的顺序来维护集合的链接表 时间复杂度 add(),remove(),contains()方法的时间复杂度是O(1) add(),remove(),contains()方法的时间复杂度是O(logn) LinkedHashSet在迭代访问Set中的全部元素时,性能比HashSet好,但是插入时性能稍微逊色于HashSet,时间复杂度是 O(1)。 同步性 不同步,线程不安全 不同步,线程不安全 不同步,线程不安全 null值 允许null值 不支持null值,会抛出 java.lang.NullPointerException 异常。因为TreeSet应用 compareTo() 方法于各个元素来比较他们,当比较null值时会抛出 NullPointerException异常。 允许null值 比较 equals() compareTo() equals() HashSet如何检查重复
当你把对象加入HashSet时,HashSet会先计算对象的hashcode值来判断对象加入的位置,同时也会与其他加入的对象的hashcode值作比较,如果没有相符的hashcode,HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象,这时会调用equals()方法来检查hashcode相等的对象是否真的相同。如果两者相同,HashSet就不会让加入操作成功。
hashCode()与equals()的相关规定:- 如果两个对象相等,则hashcode一定也是相同的
- 两个对象相等,equals方法返回true
- 两个对象有相同的hashcode值,它们也不一定是相等的
- 综上,equals方法被覆盖过,则hashCode方法也必须被覆盖
hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode(),则该class的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)。
总结:
HashSet是一个通用功能的Set,而LinkedHashSet 提供元素插入顺序保证,TreeSet是一个SortedSet实现,由Comparator 或者 Comparable指定的元素顺序存储元素。Map接口
Map 是一种把键对象和值对象映射的集合,它的每一个元素都包含一对键对象和值对象。 Map没有继承于Collection接口,从Map集合中检索元素时,只要给出键对象,就会返回对应的值对象。
Map 的常用实现类:HashMap、TreeMap、HashTable、LinkedHashMap、ConcurrentHashMap双列集合继承关系图
Map常用方法
HashMap、HashTable、TreeMap的区别
- TreeMap:基于红黑树实现。
- HashMap:基于哈希表实现。
- HashTable:和 HashMap 类似,但它是线程安全的,这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类,不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全,并且 ConcurrentHashMap 的效率会更高,因为 ConcurrentHashMap 引入了分段锁。
- LinkedHashMap:使用双向链表来维护元素的顺序,顺序为插入顺序或者最近最少使用(LRU)顺序。
HashMap HashTable TreeMap 底层实现 哈希表(数组+链表) 哈希表(数组+链表) 红黑树 同步性 线程不同步 同步 线程不同步 null值 允许 key 和 Vale 是 null,但是只允许一个 key 为 null,且这个元素存放在哈希表 0 角标位置 不允许key、value 是 null value允许为null。
当未实现 Comparator 接口时,key 不可以为null
当实现 Comparator 接口时,若未对 null 情况进行判断,则可能抛 NullPointerException 异常。如果针对null情况实现了,可以存入,但是却不能正常使用get()访问,只能通过遍历去访问。hash 使用hash(Object key)扰动函数对 key 的 hashCode 进行扰动后作为 hash 值 直接使用 key 的 hashCode() 返回值作为 hash 值 容量 容量为 2^4 且容量一定是 2^n 默认容量是11,不一定是 2^n 扩容 两倍,且哈希桶的下标使用 &运算代替了取模 2倍+1,取哈希桶下标是直接用模运算 HashMap在JDK1.7和JDK1.8中有哪些不同
不同 JDK 1.7 JDK 1.8 存储结构 数组 + 链表 数组 + 链表 + 红黑树 初始化方式 单独函数: inflateTable()
直接集成到了扩容函数 resize()
中hash值计算方式 扰动处理 = 9次扰动 = 4次位运算 + 5次异或运算 扰动处理 = 2次扰动 = 1次位运算 + 1次异或运算 存放数据的规则 无冲突时,存放数组;冲突时,存放链表 无冲突时,存放数组;冲突 & 链表长度 < 8:存放单链表;冲突 & 链表长度 > 8:树化并存放红黑树 插入数据方式 头插法(先讲原位置的数据移到后1位,再插入数据到该位置) 尾插法(直接插入到链表尾部/红黑树) 扩容后存储位置的计算方式 全部按照原来方法进行计算(即hashCode ->> 扰动函数 ->> (h&length-1)) 按照扩容后的规律计算(即扩容后的位置=原位置 or 原位置 + 旧容量) 集合工具类Collections
Collections:集合工具类,方便对集合的操作。这个类不需要创建对象,内部提供的都是静态方法。
静态方法:
Collections.sort(list);//list集合进行元素的自然顺序排序。 Collections.sort(list,new ComparatorByLen());//按指定的比较器方法排序。 class ComparatorByLen implements Comparator<String>{ public int compare(String s1,String s2){ int temp = s1.length()-s2.length(); return temp==0?s1.compareTo(s2):temp; } } Collections.max(list);//返回list中字典顺序最大的元素。 int index = Collections.binarySearch(list,"zz");//二分查找,返回角标。 Collections.reverseOrder();//逆向反转排序。 Collections.shuffle(list);//随机对list中的元素进行位置的置换。 //将非同步集合转成同步集合的方法:Collections中的 XXX synchronizedXXX(XXX); //原理:定义一个类,将集合所有的方法加同一把锁后返回。 List synchronizedList(list); Map synchronizedMap(map);
Collection 和 Collections的区别
Collections是个java.util下的类,是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化(将非同步的集合转换成同步的)等操作。 Collection是个java.util下的接口,它是各种集合结构的父接口,继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。
数组工具类 Arrays
用于操作数组对象的工具类,里面都是静态方法。
数组 -> 集合:asList方法,将数组转换成list集合。
String[] arr ={"abc","kk","qq"}; List<String> list =Arrays.asList(arr);//将arr数组转成list集合。
将数组转换成集合,有什么好处呢?用aslist方法,将数组变成集合;
可以通过list集合中的方法来操作数组中的元素:isEmpty()、contains、indexOf、set; 注意(局限性):数组是固定长度,不可以使用集合对象增加或者删除等,会改变数组长度的功能方法。比如add、remove、clear。(会报不支持操作异常UnsupportedOperationException); 如果数组中存储的引用数据类型,直接作为集合的元素可以直接用集合方法操作。 如果数组中存储的是基本数据类型,asList会将数组实体作为集合元素存在。
集合 -> 数组:用的是Collection接口中的toArray()方法;
如果给toArray传递的指定类型的数据长度小于了集合的size,那么toArray方法,会自定再创建一个该类型的数据,长度为集合的size。 如果传递的指定的类型的数组的长度大于了集合的size,那么toArray方法,就不会创建新数组,直接使用该数组即可,并将集合中的元素存储到数组中,其他为存储元素的位置默认值null。 所以,在传递指定类型数组时,最好的方式就是指定的长度和size相等的数组。
将集合变成数组后有什么好处?限定了对集合中的元素进行增删操作,只要获取这些元素即可。
用基本数据类型的数组转换ArrayList,ArrayList的size有问题
public static void main(String[] args) { int[] arr1 = { 1, 2, 3, 4, 5 }; List<int[]> intList = Arrays.asList(arr1); // intList size: 1 System.out.println(String.format("intList size: %s", intList.size())); Integer[] arr2 = { 1, 2, 3, 4, 5 }; List<Integer> integerList = Arrays.asList(arr2); // integerList size: 5 System.out.println(String.format("integerList size:%s", integerList.size())); }
asList方法接受的参数是一个泛型的变长参数,我们知道基本数据类型是无法泛型化的,也就是说基本类型是无法作为asList方法的参数的, 要想作为泛型参数就必须使用其所对应的包装类型。但是这个这个实例中为什么没有出错呢?因为该实例是将int 类型的数组当做其参数,而在Java中数组是一个对象,它是可以泛型化的。所以该例子是不会产生错误的。既然例子是将整个int 类型的数组当做泛型参数,那么经过asList转换就只有一个int 的列表了.
结论:
在使用asList()时尽量不要将基本数据类型数组转List.
asList转换得到的ArrayList不是java.util.ArrayList
public static void main(String[] args) { String[] arr = {"abc", "kk", "qq"}; List<String> list = Arrays.asList(arr); // 添加一个元素,抛出异常UnsupportedOperationException list.add("bb"); }
原因:
此处ArrayList是Arrays的内部类,并没有add方法,add方法是父类AbstractList的,但是没有具体实现,
而是直接抛出UnsupportedOperationException异常.正确操作
public static void main(String[] args) { String[] arr = {"abc", "kk", "qq"}; // 使用new ArrayList包裹一层 List<String> list = new ArrayList<>(Arrays.asList(arr)); list.add("bb"); }
如何选用集合?
主要根据集合的特点来选用,比如我们需要根据键值获取到元素值时就选用Map接口下的集合,需要排序时选择TreeMap,不需要排序时就选择HashMap,需要保证线程安全就选用ConcurrentHashMap.当我们只需要存放元素值时,就选择实现Collection接口的集合,需要保证元素唯一时选择实现Set接口的集合比如TreeSet或HashSet,不需要就选择实现List接口的比如ArrayList或LinkedList,然后再根据实现这些接口的集合的特点来选用。
-
-
Java集合框架详解(一)java集合框架概览
2019-08-21 14:39:15讲解java集合框架的文章有很多,本章是我从开始学习java到工作几年以来的一些总结,希望给初学者有帮助,大神看到错误的地方也请指点。 本次连载博客建议的阅读顺序为: Java集合框架详解(一)java集合框架概览 ...讲解java集合框架的文章有很多,本章是我从开始学习java到工作几年以来的一些总结,希望给初学者有帮助,大神看到错误的地方也请指点。
本次连载博客建议的阅读顺序为:
Java集合框架详解(三)Map-LinkedHashMap
Java集合框架详解(四)Map-TreeMap,HashTable,ConcurrentHashMap
Java集合框架详解(五)Collection-Set
Java集合框架详解(六)Collection-List
Java集合框架详解(七)Collection-Queue
Java集合框架详解(八)常用的集合第三方工具类和注意点
Java集合框架详解(九)JDK8对集合的处理
java集合继承关系
从上图可以看出,java集合总共分成两大类,Map和Collection。这二者的区别是Map的元素是成对出现的,就是我们经常提到的键值对。而Collection的元素是单个出现的。
下面的文章将分别对Map和Collection进行详细讲解。
-
Java 集合框架
2020-05-18 22:10:58由浅入深理解java集合(一)——集合框架 Collection、Map Java 集合框架 数据结构与算法——常用数据结构及其Java实现 java 中几种常用数据结构 Java - 集合框架完全解析 Java集合框架常见面试题.md 详解Java集合框架...参考:
- 由浅入深理解java集合(一)——集合框架 Collection、Map
- Java 集合框架
- 数据结构与算法——常用数据结构及其Java实现
- java 中几种常用数据结构
- Java - 集合框架完全解析
- Java集合框架常见面试题.md
- 详解Java集合框架,让你全面掌握!
- Java集合框架完全解析
- JAVA集合框架总结
java.util.Collection [I] +--java.util.List [I] +--java.util.ArrayList [C] +--java.util.LinkedList [C] +--java.util.Vector [C] //线程安全 +--java.util.Stack [C] //线程安全 +--java.util.Set [I] +--java.util.HashSet [C] +--java.util.SortedSet [I] +--java.util.TreeSet [C] +--Java.util.Queue[I] +--java.util.Deque[I] +--java.util.PriorityQueue[C] java.util.Map [I] +--java.util.SortedMap [I] +--java.util.TreeMap [C] +--java.util.Hashtable [C] //线程安全 +--java.util.HashMap [C] +--java.util.LinkedHashMap [C] +--java.util.WeakHashMap [C] [I]:接口 [C]:类 本图来源于网络。
-
集合框架--集合框架体系概述
2017-03-09 09:42:56集合框架体系主要如上图所示,集合类主要分为两大类:Collection和Map。 先简单概述几个相关问题。 1、先说明下什么是集合? 当数据多了需要存储,需要容器,但是数据的个数又不确定的时候,无法使用数组(数组... -
java 集合框架 简单介绍
2017-04-12 10:13:00为什么需要集合框架,如果没有集合框架,会怎样? 3.使用了那种设计模式? 4.集合框架的核心算法分析 1.集合框架是什么? 集合框架是对常用的数据结构和算法进行封装的聚合体。 数据结构有: 数组,链表,... -
Java集合框架
2020-04-05 13:45:55Java集合框架 集合框架设计设计的目标 框架必须是高性能的。基本集合(动态数组、链表、树、哈希表)的实现也必须是高效的。 框架允许不同类型的集合,以类似的方式工作,具有高度的互操作性。 对一个集合的扩展和... -
JDK源码【集合框架】Java集合框架概述
2016-12-23 12:41:17一、前言 众所周知Java集合框架在Java语言中的地位是非常重要的,在平时编码中使用很频繁,要想更好的应用Java集合需要对其原理有充分了解,现准备从源码角度梳理各个集合类的原理和数据结构。二、集合框架图 先... -
集合框架(一) - 集合框架概述
2017-05-22 18:49:41相关概念集合框架: 一堆用来表示和操作`集合`的类. 集合: 存放数据的容器.二. 可以从这三方面来学习和理解1. 对外的接口. 2. 接口的实现. 3. 集合运算的算法.三. 结构图(简要图和详图) 1. 集合框架由两部分组成: ...
-
(新)备战2021软考网络规划设计师终极解密套餐
-
锁---互斥锁 VS 读写锁
-
(新)备战2021软考网络工程师终极解密培训套餐
-
MySQL性能优化的最佳经验.zip
-
Java星选一卡通
-
将两条宽带通过两个路由器组成一个局域网的方法.zip
-
visual c++ vc内存池源代码,用于分配固定大小的内存,速度超快又方便.zip
-
【2021】UI自动化测试框架(Selenium3)
-
锁---可重入锁 VS 非可重入锁
-
SSM框架配置文件
-
PostgreSQL-11.10-osr507-Binary.tar.gz
-
三维地图GIS大数据可视化
-
vant的展示组件-Tag 标签
-
linux内核5-中断
-
阿里巴巴开发手册-最新版.pdf
-
【数据分析-随到随学】Spark理论及实战
-
flash actionscript3游戏开发教程 as3系列教程.zip
-
ucosii+STM32 BLDC电机控制器设计.zip
-
python数据分析基础
-
【数据分析-随到随学】Python数据获取