黑马程序员技术交流社区

标题: 集合框架 [打印本页]

作者: trj1123131766 时间: 2015-8-4 22:43
标题: 集合框架
本人深圳黑马学员,刚学到集合,不知道这个章节怎么学,需不需要做一些笔记之类的东西.或者是只要完成老师的任务就可以了.希望各位能给个建议,感激不尽.

作者: 一枚小小媛 时间: 2015-8-4 23:55
把一些笔记给楼主分享一下：
【一】
1.集合
作用:
是一个容器,用于持有对象.
优点:
可以存储任意类型的对象. ->集合中存储的元素的数据类型可以是任意的.
add(Object obj); 正是多态的机制,多态作为方法的形参可以接收范围更广的实际参数.
可以存储任意多个对象.  ->集合的长度可变
注意:
集合持有的只是对象的引用,非对象本身.
集合存储的元素的类型必须是类类型.集合只能存储对象,不能直接存储基本数据类型(存在了自动装箱) 1.5只有出现的自动装箱.
2.集合体系值_Collection
为什么要先了解接口,不去直接学习集合类ArrayList
ArrayList list=new ArrayList(); ->
Collection coll=new ArrayList(); ->
由于集合时一个体系,集合中最为共享的行为,都定义在了Collection 中, 如果先学习了解Collection,就了解了集合具备的最为基本的行为.
学完集合共性的行为,可以继续研究的该体系的更为具体的实现类.
|---Collection
接口, 定义集合体系最为基本的行为(方法)
3.集合体系之_List
|---Collection 接口
|---List 接口
继承了Collection接口. 该List 接口是一个子接口,向对于父,有着更多的功能.
特点:
有序:
元素存在在改集合体系中是有序的,按照添加的顺序,决定了元素在集合中的位置.
有角标:
操作该体系的集合时,可以根据角标操作元素.
元素可以重复:
该集合体系可以添加重复的元素.
验证:
验证通过.
总结:
List 体系中的集合具备:有角标,有序,元素可以重复
图书管理系统的时候:
增加的图书,按照顺序存放...
List接口中定义的特有的方法(规范)
增加:
     void add(int index, E element)
     boolean addAll(int index, Collection<? extends E> c)
删除:
remove(int index)
修改:
set(int index, E element)
查找:
E get(int index)
int indexOf(Object o)
int lastIndexOf(Object o)
其他方法:
subList(int fromIndex, int toIndex)
测试集合:
测试通过,总结List 集合中的特有方法,都是通过角标实现操作.
4.集合实现类_ArrayList
要求自定义集合类:
类似与ArrayList 的一个集合类,能够增,删,查,改元素.
|---Collection
接口,定义了集合体系的共性的方法.
|---List
接口特点: 有序,有角标,元素可重复.
|---ArrayList
实现类, ArrayList 类内部维护了一个数组,数组的元素是Object 类型,保证可以添加任意类型对象.
ArrayList 内部有专业的方法,检测数组,如果数组已满,创建一个新数组,将旧数组的元素拷贝到新数组,使用新数组作为存储的容器.继续添加新元素.
数组实现内存地址连续:
好处: 内存地址连续,有角标,可以通过角标快速的查找. ->查找快.
弊端:增加: 使用的角标 add(0,元素) 新元素添加到集合中该该位置的旧元素需要整体往后移动.
增加时,如果数组满了,需要创建新数组,拷贝数组元素, 增加时速度很慢 ->增加慢
               删除: 删除指定位置的元素,该元素后的所有元素都要整体往前移动.
增删是很慢的.
总计: ArrayList 数组实现,内存地址连续,通过角标快速的查找->查找块
               增加,删除元素时,设计到了元素的拷贝,和数组的扩容. 增删慢.
注意:
调用ArrayList 默认无参数构造,底层维护的数组长度是10.
当明确存储的元素的个数,可以直通通过有参数构造,指定集合的长度(数组的长度)
ArrayList数组扩容时,新数组的长度是老数组的长度的1.5倍.  old*3/2+1
简答总结:
ArrayList 数组实现,内存地址连续, 查找快,增删慢
5.课堂练习:
ArrayList 可以存储重复元素.
编写程序,去除ArrayList 重复元素.
测试: 重复的String
               重复的自定义对象. Person
               什么是重复的人, 人中有姓名和年龄. 逻辑需求: 姓名相同年龄相同,视为同一个人. 把ArrayList程序中姓名相同的年龄相同的的去除
   实现:
        去除ArrayList 重复元素, 定义一个新的ArrayList 集合,遍历旧的ArrayList 集合. 取出ArrayList 中的每一个元素.添加到新的ArrayList中.
        使用新集合添加元素时,一定要检测新集合中是否包含了该元素,如果包含,就不再添加.
     核心的代码: 使用ArrayList 集合的contains 方法,检测集合中是否包含指定元素.
     注意: 使用ArrayList的contains 方法,无法检测出自定义对象的重复元素.查看源代码  原因-> contains 方法使用的是indexOf 方法
           ->indexOf(Object e) 方法是集合用于查找指定元素在集合中的位置.
           -> indexOf 方法内部: 遍历集合维护的数组,取出每一个元素, 和要查找的元素进行对比(元素的equals)
     ArrayList 的方法
     Object[] elemetData;
     int size;
     public boolean contains(Object e){
     return indexOf(e)>=0;
     }
     public int indexOf(Object e){
     for(int i=0;i<size;i++){
     if(o.equals(this.elementData[i])){
     return i;
     }
     }
     return -1;
     }

     注意: 使用ArrayList 存储自定义对象时,需要重写对象的equals 方法,建立对象的特有的比较方式...
        否则ArrayList中contains 方法,indexOf 方法无法正常工作
总结:
   ArrayList 是实际开发中使用最为频繁的一个集合.
6.List 集合的遍历方式:
一: toArray 方法,集合变数组
二: get(int index)  取出每一个.
7.集合实现类_LinkedList
|---Collection
接口
|---List 接口, 有序,有角标,元素可重复.
|---ArrayList
数组实现,查找快,增删慢.
|---LinkedList
双向链表实现, 链表内部使用节点对象(Node)对象,存储元素. 使用LinkedList 增加一个元素, 在LinkedList 就创建一个Node 节点对象.
节点对象保存元素.  节点和节点之间内存地址是不连续的. 节点和节点之间需要记录他们之间的引用.上一个节点需要记录下一个节点.
简单总结: 内部地址不连续查找慢,增删快.
class LinkedList{
class Node{
Node next;
Node(Object obj){

}
}
Node head;
Node tail;
public boolean add(Object obj){
Node n=new Node(obj);
if(head==null&&tail==null){
head=tail=n;
}else{
...
}
}
}
LinkedList特有方法:
由于双向链表实现,提供了操作头和尾的方法.
addFirst(E e)
addLast(E e)
getFirst()
getLast()
removeFirst()
removeLast()
由于LinkedList 在JDK1.5 后实现了Deque 接口. 具备了实现堆栈和队列的数据结构
堆栈: ->先进后出子弹夹
压栈: push();
弹栈: pop)();
注意: 弹栈后,集合中没有元素.
队列: ->先进先出.  排队.
进队  offer()
出队:poll()
8. 学习:
第一步: 练习List 中的方法. ArrayList中方法,LinkedList 中的方法.
必须掌握基本的方法, List  全部都会. 一个亲自测试... 每一个方法记好笔记.
集合的基本使用...  图书管理系统...
第二步: 掌握List 的特性, ArrayList 实现原理,LinkedList 的实现原理, 各自的优缺点.
   原理.
第三步: 自定类实现ArrayList LinkedList Stack 类的效果...
9.集合体系
|---Collection 接口 1.2 出现
|---List 接口1.2 出现.
有序,有角标,元素可重复
|---ArrayList 实现类
1.2出现 , 数组实现,内存地址连续,查找快增删慢.  不同步的. 大部分的集合操作,都是在单线程下... 如果是多线程操作集合?
|---LinkedList
1.2出现, 双向链表,内存地址不连续, 查找慢(中间的慢,头和尾其实不瞒),增删快
|---Vector
1.0出现,数组实现, 同步的(多线程下,线程安全.)  单线程下,还需要同步,性能低.
有自己的特有的操作元素的方法,但是方法名过长, 在1.2 被ArrayList 替代.
特有方法:
增加一个元素:
addElement(E obj) add()
elementAt(int index)  get()
insertElementAt(E obj, int index) set()
removeAllElements()  clear()
在JDK1.0的时候,如何取出Vector 集合中的元素?
通过Vector 的elements 方法获取到一个Enumeration 接口的实现类对象.
通过该对象的 hasMoreElements 和nextElement 方法取出集合中的元素.
为什么被淘汰:
1.0出现,线程同步(性能低),方法名过长(不方便使用),数组的扩容是100%(效率低)
在1.2 后被ArrayList 替代.
多线程操作:
ArrayList -> 使用Collections 的方法 synchronizedList(List list); 将不同步的集合转换为同步的集合.

作者: 花千骨 时间: 2015-8-4 23:55
很详细，很全面

作者: 一枚小小媛 时间: 2015-8-4 23:56
【二】然后是集合比较重要的知识点之一：遍历

package list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* 遍历List集合的三种方法
*
* @author 小媛
*
*/
public class ListPrintTest {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();//LinkedList
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
list.add("g");
list.add("h");
ListPrint3(list);
}
/**
* 通过for循环，使用下角标然后操作集合对象的get方法拿到集合的元素
* @param list
*/
public static void ListPrint1(List<String> list) {
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i));
}
}
/**
* 使用list内部封装好的迭代器遍历循环获取集合的元素
* @param list
*/
public static void ListPrint2(List<String> list) {
for (Iterator<String> i = list.iterator(); i.hasNext();) {
String element = i.next();
System.out.print(element);
}
}
/**
* java1.5新特性增强for循环
* @param list
*/
public static void ListPrint3(List<String> list) {
for(String element : list){
System.out.print(element);
}
}
}

复制代码

作者: 一枚小小媛 时间: 2015-8-4 23:57

package list;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* @author 小媛
* Set集合遍历
*/
public class SetPrintTest {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
set.add("a");
set.add("bb");
set.add("ccc");
set.add("dddd");
set.add("eeeee");
set.add("ffff");
set.add("ggg");
set.add("hh");
set.add("i");
SetPrint1(set);
}
/**
* 使用迭代器
* @param set
*/
public static void SetPrint1(Set<String> set){
for(Iterator<String> i = set.iterator(); i.hasNext(); ){
String element = i.next();
System.out.println(element);
}
}
/**
* 增强for
* @param set
*/
public static void SetPrint2(Set<String> set){
for(String element : set){
System.out.println(element);
}
}
}

复制代码

作者: 一枚小小媛 时间: 2015-8-4 23:58
最后是Map集合的遍历

package list;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
/**
* @author 小媛
* Map的遍历
*/
public class MapPrint {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "QQ");
map.put(2, "VV");
map.put(3, "AA");
map.put(6, "PP");
map.put(7, "HH");
map.put(8, "KK");
MapPrint2(map);
}
/**
* 通过Entry集合增强for遍历获取键-值
* @param map
*/
public static void MapPrint1(Map<Integer, String> map) {
for (Entry<Integer, String> entry : map.entrySet()) {
System.out.println(entry);
}
}
/**
* 通过获取Key集合，增强for遍历获取键-值
* @param map
*/
public static void MapPrint2(Map<Integer, String> map) {
for (Integer key : map.keySet()) {
System.out.println(key + " = " + map.get(key));
}
}
/**
* 直接获取Value集合，增强for遍历获取值
* @param map
*/
public static void MapPrint3(Map<Integer, String> map) {
for(String value : map.values()){
System.out.println(value);
}
}
}

复制代码

作者: 一枚小小媛 时间: 2015-8-5 00:01
集合的类型与各自的特性

---|Collection: 单列集合

---|List: 有存储顺序, 可重复

---|ArrayList: 数组实现, 查找快, 增删慢

由于是数组实现, 在增和删的时候会牵扯到数组

增容, 以及拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快

---|LinkedList: 链表实现, 增删快, 查找慢由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高但查询时需要一个一个的遍历, 所以效率较低

---|Vector: 和ArrayList原理相同, 但线程安全, 效率略低

和ArrayList实现方式相同, 但考虑了线程安全问题, 所以效率略低

---|Set: 无存储顺序, 不可重复

---|HashSet 线程不安全，存取速度快。底层是以哈希表实现的。

---|TreeSet 红-黑树的数据结构，默认对元素进行自然排

序（String）。如果在比较的时候两个对象

返回值为0，那么元素重复。

---| Map: 键值对键不可重复，键可以重复

---|HashMap 线程不安全，存取速度快。底层是以哈希表实现的.

---|TreeMap 红-黑树的数据结构，默认对元素进行自然排

序（String）。如果在比较的时候两个对象

返回值为0，那么元素重复

---|HashTable 底层也是使用了哈希表维护的，存取的读取快，存储元素是

无序的。

小媛就这么多总结了。楼主加油

1358578317_6547.png (134.8 KB, 下载次数: 8)

集合结构图

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2