------- android培训、java培训、期待与您交流！ ----------
集合
集合的由来
图解
java中集合框架
java中集合体系也是不断向上抽取而来的
集合框架的构成图
Collection
Collection是集合框架中的常用接口。
1、List元素是有序的，元素可以重复。因为该集合体系有索引。
2、Set元素是无序的，元素不可以重复。
Collection接口中的常见操作
1、添加元素
add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。
2、删除元素
remove(Objectobj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3、判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4、获取个数，集合长度
size();
5、取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
应用事例
public class CollectionDemo {
public static void main(String[] args) {
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
show(c1,c2);
}
public static void show(Collection c1,Collection c2){
//给c1添加元素。
c1.add("abc1");
c1.add("abc2");
c1.add("abc3");
c1.add("abc4");
//给c2添加元素。
c2.add("abc1");
c2.add("abc2");
c2.add("abc3");
c2.add("abc4");
c2.add("abc5");
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
//演示addAll
// c1.addAll(c2);//将c2中的元素添加到c1中。
//演示removeAll
// boolean b = c1.removeAll(c2);//将两个集合中的相同元素从调用removeAll的集合中删除。
// System.out.println("removeAll:"+b);
//演示containsAll
// boolean b = c1.containsAll(c2);
// System.out.println("containsAll:"+b);
//演示retainAll
boolean b = c1.retainAll(c2);//取交集，保留和指定的集合相同的元素，而删除不同的元素。
//和removeAll功能相反 。
System.out.println("retainAll:"+b);
System.out.println("c1:"+c1);
}
public static void show(Collection coll){
//1,添加元素。add.
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
System.out.println(coll);
//2，删除元素。remove
// coll.remove("abc2");//会改变集合的长度
//清空集合.
// coll.clear();
System.out.println(coll.contains("abc3"));
System.out.println(coll);
}
}迭代
迭代是取出集合中元素的一种方式。
因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。
如图
迭代的常见操作
hasNext();有下一个元素，返回真
next();取出下一个元素
remove();移除
应用事例
public class IteratorDemo {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
//使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
Iterator it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}List
组成
List：元素是有序的，元素可以重复。
|--ArrayList：底层的数据结构使用的是数组结构。查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList：底层使用的是链表数据结构。增删速度很快，查询稍慢。线程不同步。
|--Vector：底层是数组数据结构。线程同步。
List的特有方法
凡是可以操作角标的方法都是该体系特有的方法。1、增
booleanadd(index,element);//指定位置添加元素
BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素
2、删
Booleanremove(index);//删除指定位置的元素
3、改
set(index,element);//修改指定位置的元素。
4、查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5、其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1
public class ListDemo {
public static void main(String[] args) {
List list = new ArrayList();
show(list);
}
public static void show(List list) {
//添加元素
list.add("abc1");
list.add("abc2");
list.add("abc3");
System.out.println(list);
//插入元素。
list.add(1,"abc9");
//删除元素。
System.out.println("remove:"+list.remove(2));
//修改元素。
System.out.println("set:"+list.set(1, "abc8"));
//获取元素。
System.out.println("get:"+list.get(0));
//获取子列表。
System.out.println("sublist:"+list.subList(1, 2));
System.out.println(list);
}
}ListIterator
ListIterator是List集合特有的迭代器，是Iterator的子接口。
Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加、修改等，就需要使用其子接口：ListIterrator。该接口只能通过List集合的ListIterator方法获取。
ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
应用事例
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
System.out.println("list:"+list);
ListIterator it = list.listIterator();//获取列表迭代器对象
//它可以实现在迭代过程中完成对元素的增删改查。
//注意：只有list集合具备该迭代功能.
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("abc2")){
it.set("abc9");
}
}Vector
枚举Enumeration
是Vector特有的取出方式。其实枚举和迭代是一样的。
方法
addElement(obj);//添加元素，相当于add(obj);Enumerationelements();//Vector特有取出方式(枚举)
hasMoreElements();//相当于Iterator的hasNext()方法
nextElements();//相当于Iterator的next()方法
应用事例
public class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector();
v.addElement("abc1");
v.addElement("abc2");
v.addElement("abc3");
v.addElement("abc4");
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println("nextelment:"+en.nextElement());
}
}
}LinkedList
LinkedList：底层使用的是链表数据结构。增删速度很快。
特有方法：
1、增
addFirst();
addLast();
2、获取
//获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
应用事例
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList link = new LinkedList();
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
link.addFirst("abc4");
System.out.println(link.getFirst());//获取第一个但不删除。
System.out.println(link.removeFirst());//获取元素但是会删除。
Iterator it = link.iterator();
while(it.hasNext()){
System.out.println(it.next());
System.out.println(link);
}
}
}Arraylist与Linkedlist区别图解
Set
Set：元素是无序，元素不可以重复。
1、HasSet
HashSet：线程不安全，存取速度快。
可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。
注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
应用事例
public class HashSetDemo {
public static void main(String[] args) {
HashSet hs = new HashSet();
hs.add("hehe");
hs.add("hahah");
hs.add("xixii");
hs.add("hehe");
Iterator it = hs.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}2、TreeSet
a、底层的数据结构为二叉树结构
b）可对Set集合中的元素进行排序，TreeSet类实现了Comparable接口，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。
排序的两种方式1）第一种排序方式： 让元素自身具备比较性。（实现Comparable接口，覆盖compareTo方法）
2）第二种方式：比较器
当元素自身不具备比较性时，定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合。
特点
1）该集合存储键值对，一对一对往里存
2）要保证键的唯一性。
Map集合的常用方法
1、添加
Vput(K key,V value);//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。
voidputAll(Map <? extends K,? extends V> m);//添加一个集合
2、删除
clear();//清空
Vremove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
Vget(Object key);//通过键获取对应的值
size();//获取集合的长度
Collection<V>value();//获取Map集合中所以得值，返回一个Collection集合
public static void method(Map<Integer,String> map){
// 添加元素。
System.out.println(map.put(8, "wangcai"));//返回null
System.out.println(map.put(8, "xiaoqiang"));//wangcai 存相同键，值会覆盖。
map.put(2,"zhangsan");
map.put(7,"zhaoliu");
//删除。
// System.out.println("remove:"+map.remove(2));
//判断。
// System.out.println("containskey:"+map.containsKey(7));
//获取。
System.out.println("get:"+map.get(6));
System.out.println(map);
}Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。
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集合中，而这个关系的数据类型就是：Map.Entry
a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。
应用事例
Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
<span style="white-space:pre"> </span>Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();
<span style="white-space:pre"> </span>while(it.hasNext()){
<span style="white-space:pre"> </span>Map.Entry<Integer, String> me = it.next();
<span style="white-space:pre"> </span>Integer key = me.getKey();
<span style="white-space:pre"> </span>String value = me.getValue();
<span style="white-space:pre"> </span>System.out.println(key+"::::"+value);
<span style="white-space:pre"> </span>}
扫一扫
377
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
