黑马程序员 常用对象API--集合框架笔记总结

-----------android培训、java培训、java学习型技术博客、期待与您交流！
------------

集合：用于存储对象的容器。
集合的特点：
1.存储的是对象。
2.集合的长度是可变的。
3.集合中不能存储基本数据类型。

集合容器因为内部的数据结构不同，有多种容器。不断向上抽取，就形成了集合框架。

框架的顶层Collection接口。
Collection的常见方法：
1.添加：
boolean add(Object obj);
boolean addAll(Collection coll);

2.删除：//会改变集合的长度。
boolean remove(Object obj);
boolean removeAll(Collection coll);//将两个集合中的相同元素从高调用removeAll的集合中删除。
void clear();//将集合清空。注意：集合还在。

3.判断：
boolean contains(Object obj);
boolean containsAll(Collection coll);
boolean isEmpty();//判断集合是否为空

4.获取：
int size();
Iterator iterator();//取出元素的方式：迭代器。
迭代器：专门用于取出集合中元素的方式。

5.其他：
boolean retainAll(Collection coll);//取交集。
Object[] toArray();//将集合转成数组。
-----------------------------------------------------
迭代器：取出集合中元素的方式。

取出方式一：
Iterator it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
取出方式二：(开发使用，省内存)
for(Iterator it = coll.iterator();it.hasNext(); ){
System.out.println(it.next());
}

迭代器的原理：
迭代器依赖于具体容器，每个容器的数据结构不同。
所以迭代器对象是在容器中进行内部实现的。
Iterator接口就是所有的Collection容器进行元素取出的公共接口。

对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可。
也就是iterator方法。

----------------------------------------------------

Collection下两大子体系。
List和Set的特点：
Collection
|---List：有序的（存入和取出的顺序一致），元素都有索引（角标），元素可以重复，

|---Set：无序，元素不能重复。

List的常见方法：有一个共性特点可以操作 角标。
1.添加
void add(index,element);
void add(index,collection);

2.删除
Object remove(index);

3.修改
Object set(index,element);

4.获取
Object get(index);
int indexOf(Object);
int lastIndexOf(object);
List subList(from,to);//包含头不包含尾
List集合可以完成对元素的增删改查。

ListIterator接口，列表迭代器：
List list = new ArrayList();
通用取出方式：
Iterator it = list.Itertor();
while(it.hasNest()){
System.out.println(it.nest());
}
List特有的取出元素方式：
for(int x=0; x<list.size();x++){
System.out.println(list.get(x));
}

Iterator迭代器在操作元素的过程中不要使用集合对元素进行操作，容易出现异常。

可以使用Iterator接口的子接口listItterator来完成在迭代中对元素更多的操作。

List list = new ArrayList();
ListIterator it = list.listIterator();//获取列表迭代器。
//可以实现在迭代过程中完成对元素的增删改查。
//只有list集合具备该迭代功能。
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("abc2")){
it.add("abc9");
}

it.hasPrevious();
it.previous();
用法和hasNext();,nest();完全相同，只是逆向的。

listIterator(int index);//从指定位置开始
----------------------------------------------------
List常用子类的特点：
List：
|--Vector：内部是数组数据结构，是同步的。可增长数组，延长一倍。增删和查找都很慢。

内部数组数据的大小为10，可变长度。
Vector特有功能，Enumeration接口，功能和Iterator接口的功能是重复的。
Iterator接口添加了一个可选的移除操作，和Iterator使用较短的方法名，
新的实现应优先考虑使用Iterator。

|--ArrayList：内部是数组数据结构，是不同步的。查询元素快。替代了Vector。Vector几乎不用了。延长50%。
|--LinkedList：内部是链表数据结构，是不同步的。增删元素快。
LinkedList：
addFirst();将元素插入到此列表的开头。
addLast();
jdk1.6
offerFirst();
offerLast();

getFirst();返回此列表的第一个元素。链表为空会抛出异常。
getLast();
jdk1.6
peekFirst();获取但不移除列表的第一个元素。链表为空会返回null
peekLast();

removeFirst();获取此列表的第一个元素，并删除。
removeLast();
jdk1.6
poolFirst()获取并移除。
poolLast();
----------------------------------------------------------------------------

Set：元素不可重复，无序。
Set接口中的方法和Collection中的一致。
|--HashSet：内部数据结构是哈希表，是不同步的。
|--LinkedHashSet:哈希表和链表同时使用。有序，唯一。
需要唯一用set，不需要用List。
哈希表确定元素是否相同的依据
1.判断的是两个元素的哈希值是否相同。
如果相同，再判断两个元素的内容是否相同。
2.判断哈希值相同，其实判断的是对象的hashCode()的方法。
判断内容更新相同，用的是equals方法。
注意：如果哈希值不同，不需要判断equals方法。

HashSet集合数据结构是哈希表，所以存储元素的时候使用的是元素的hashCode方法来确定位置，
如果位置相同再通过元素的equals来确定元素是否相同。
ArrayList判断元素相同判断equals方法

|--TreeSet：有指定顺序（按照元素的自然顺序）。
可以对Set集合中的元素进行指定顺序的排序。是不同步的。
可指定顺序，比较器返回值1，-1可实现有序。1正序，-1倒序
对象想要存入TreeSet需要实现Comparable
TreeSet:判断元素唯一性的方式：就是根据比较方法的返回结构是否是0，是0就是相同元素，不存。
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元素需要实现Comparable接口。覆盖compareTo方法。

TreeSet对元素进行排序的方式二：
如果不要按照对象中具备的自然顺序进行排序，或者对象中不具备自然顺序。怎么办？
可以让集合自身具备比较功能,定义类，覆盖Coparator接口，覆盖Compare方法。
将给类对象作为参数传递给TreeSet集合的构造函数。

构造函数：TreeSet(Comparator<? super E> comparator)
TreeSet ts = new TreeSet(new ComparatorByName());
元素自身具备比较功能时也是以比较器为主。
比较器比较常用。
---------------------------------------------------------------------
Map:一次添加一对元素。Collection一次添加一个元素。
Map集合也称为双列集合，Collection也称为单列集合。
其实Map集合存储的就是键值对。
map集合必须保持键的唯一性。

常用方法：
1.添加：
value put(key,value);返回前一个和key关联的值，如果没有返回null
2.删除;
value remove(key);根据指定的key删除这个键值对，
void clear();清空map集合。
3.判断：
boolean containsKey(key);
boolean containsValue(value);
boolean siEmpty();
4.获取：
value get(key);通过键拿值，如果没有该键，返回null。
可以通过返回null，判断是否包含指定键。
int size();获取键值对的个数。

keySet();
取出map中的所有元素。
通过keySet()方法获取map中所有的键所在的set集合，再通过set的迭代器获取每一个键，
然后对每一个键通过Map集合的get方法获取其对应的值即可。
方式一：keySet

Map<Integer,String> map = new HashMap<Integer,String>();
map.put(1,"wangcai");
map.put(2,"xiaoqiang");
map.put(3,"zhangsan");
map.put(4,"lisi");
Set<Integer> keySet = map.keySet();
Iterator<Integer> it = keySet.iterator();
while(it.hasNext()){
Integer key = it.next();
String value = map.get(key);
System.out.println(key+":"+value);
}

通过Map转成Set就可以迭代，找到了另一个方法。entrySet。该方法将键和值的映射关系存到了set集合中。
这个映射关系的类型就是Map.Entry类型（结婚证）
方式二：entrySet

Map<Integer,String> map = new HashMap<Integer,String>();
map.put(1,"wangcai");
map.put(2,"xiaoqiang");
map.put(3,"zhangsan");
map.put(4,"lisi");
Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
Iterator<Map.Entry<Integer,String>> it = entrySet.iterator();
while(it.hasNext()){
Map.Entry<Integer, String> me = it.next();
Integer key = me.getKey();
String value = me.getValue();
System.out.println(key+":::"+value);
}
Collection values
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(1,"wangcai");
map.put(2,"xiaoqiang");
map.put(3,"zhangsan");
map.put(4,"lisi");
Collection<String> values =map.values();
Iterator<String> it = values.iterator();
while(it.hasNext()){
Sysetm.out.println(it.next());
}

----------------------------------------------------
Map集合常见子类对象。
|--Hashtable:内部结构是哈希表，是同步的。不支持null作为键或者值
|--Properties：用来存储键值对型的配置文件信息。和io相结合。

|--HashMap：内部结构是哈希表，不是同步的。支持null作为键和值

|--LinkedHashMap可保证有序。
|--TreeMap：内部结构是二叉树，是不同步的。可以对Map集合中的键进行排序。

集合使用的一些技巧：
需要唯一吗？
需要：Set
需要指定顺序吗？
需要：TreeSet
不需要：HashSet
想要一个和存储一致的顺序（有序）：LinkedHashSet

不需要：List
需要频繁增删吗？
需要：LinkedList
不需要：ArrayList

如何记住每一个容器的结构和所属体系。

看名字：后缀名就是该集合所属的体系。

List有角标有序，可重复。Set元素唯一

前缀名就是该集合的数据结构。

看到Array就想到数组，就要想到查询快，有角标。
看到Linked就要想到链表就要想到增删快，add get remove+first last的方法。
看到Hash就要想到哈希表，就要想到唯一性，元素需要想到覆盖hashCode方法和equals方法。
看到tree就要想到二叉树，就要想到排序，就要想到两个接口Comparble，Comprtor。
通常这些常用的集合容器都是不同步的。

工具类：
Collections：是集合框架的工具类，里面的方法都是静态的。
Collections.sort(list);
Collections.sort(list,comparator);根据比较器顺序进行排序
Collections.swap(list,i,j);
int index = Collections.binarySearch(list,"abc");
Collections.max(Collection coll);//获取最大值。
Collections.max(Collection coll,comparator)
Collections.reverseOrder();//返回一个比较器，将具备着自然排序的元素进行逆转。
Collections.reverseOrder(new ComparatorByLength());
Collections.shuffle(list);//随机对list进行排序。
将非同步的集合转成同步集合：
List list = new ArrayList();//非同步的。
list = Collections.synchronizedList(list);//同步的

Arrays:集合框架的工具类。里面的方法都是静态的。
binarySearch,copyOf,sort

int[] arr = {1,2,3,5,4}
System.out.println(Arrays.toString(arr));//[1,2,3,5,4]

重点：数组转成集合
ListasList(数组)将数组转成集合。
String[] arr = {"abc","hehe","haha"};
List<String> list = Arrays.asList(arr);
boolean b = list.contains("xixi");

好处：可以使用集合的方法操作数据里的元素。
注意：数组的长度是固定的，所以对集合的增删方法是不可以使用的。

如果数组中的元素是实体对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行存储。
如果数组中的元素是基本类型数值，那么会将该数组作为集合中的元素进行存储。
集合中不能存储基本数据类型。
int[] arr = {31,21,33,45};
List<int[]> list = Arrays.asList(arr);
System.out.println(list);[[I@dc8569]

集合转成数组：
使用的就是Collection接口中的toArray方法。
集合转成数组可以对集合中的元素的操作方法进行限定，不允许其进行增删。。

List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
//toArray方法需要传入一个指定类型的数组。
如果长度小于集合的size，那么该方法创建一个桶类型并和集合相同size的数组。
如果长度大于集合的size，那么该方法就会使用指定的数组存储集合中的元素，其他位置默认为null
所以建议长度就指定为集合的size。
String[] str = list.toArrray(new String[list.size()]);
System.out.println(Arrays.toString(arr));

-----------android培训、java培训、java学习型技术博客、期待与您交流！
------------