常用对象API--集合框架笔记总结

 

集合：用于存储对象的容器。

集合的特点：

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));