目录
Collction集合:保存若干个元素的某种容器,长度不固定
一 ，list 接口继承colltion其实现类有:Arraylist linkedlist
list常用方法
linkedlist的用法与Arraylist大致相同
list的遍历:
Arraylist的遍历:
linkedlist 的遍历：
Map集合：
Map的遍历:
Queue队列:
常用方法:
遍历方法:
Priorityqueue优先级队列:
遍历方法:
Deque双端队列:
常用方法:
遍历方法:
Collction集合:保存若干个元素的某种容器,长度不固定
其有list接口和set接口，是除Map外所有集合的根接口；
list 接口继承colltion其实现类有:Arraylist linkedlistlist一种有序(有序即是与输入结果相同)集合，允许重复； 允许添加null;
eg:
Listarrayslist = new ArrayList (); arrayslist.add("A"); arrayslist.add("B"); arrayslist.add("B");//允许重复 arrayslist.add("C"); arrayslist.add(null);//允许添加null System.out.println(arrayslist); 结果为 [A,B,B,C,null]
linkedlist与arraylist的数组结构不同,其是双向链表结构,添加的元素每个都是以Node类型的对象存在；可以快速用 getfirst();与getlast();分别取出首元素和尾元素;
eg:
LinkedListlinkedlist = new LinkedList (); linkedlist.add("A"); linkedlist.add("B"); linkedlist.add("B"); linkedlist.add("C"); linkedlist.add(null); System.out.println(linkedlist); System.out.println(linkedlist.getFirst());//取出队首元素 System.out.println(linkedlist.getLast());//取出队尾元素 输出结果为 [A, B, B, C, null] A null
list常用方法
list常用方法以Arraylist为例；
添加元素:add() ; addAll() ；
删除元素：claer() ; remove() ;
修改:set( , );
判断:contians(); 判断集合是否包含指定元素 isEmpty();判断元素是否为空;
eg:
import java.util.ArrayList;
import java.util.List;
public class Damo11 {
public static void main(String[] args) {
List arraylist2= new ArrayList();
List arraylist1 = new ArrayList();
arraylist1.add("A");
arraylist1.add("B");
arraylist2.addAll(arraylist1);
System.out.println(arraylist1);
System.out.println(arraylist2);
arraylist1.clear();//将集合清空
System.out.println(arraylist1);
arraylist2.remove("A");//删除指定元素
System.out.println(arraylist2);
arraylist2.set(0, "F");//指定下标,将其修改为指定元素;
System.out.println(arraylist2);
System.out.println(arraylist2.contains("F"));
System.out.println(arraylist2.isEmpty());
}
}
输出结果为
[A, B]
[A, B]
[]
[B]
[F]
true
false
linkedlist的用法与Arraylist大致相同
但其有几个特有方法如:
getfirst(); getlast(); removefist(); removelast();
eg:
import java.util.LinkedList;
public class Damo11 {
public static void main(String[] args) {
LinkedList linkedlist = new LinkedList();
linkedlist.add("A");
linkedlist.add("B");
linkedlist.add("C");
linkedlist.add("F");
System.out.println(linkedlist);
System.out.println(linkedlist.getFirst());//获取首节点
System.out.println(linkedlist.getLast());//获取尾节点
System.out.println(linkedlist.removeFirst());//去除首节点
System.out.println(linkedlist.removeLast());//去除尾节点
}
}
输出结果为
[A, B, C, F]
A
F
A
F
list的遍历:
Arraylist的遍历:
遍历可用 for each 遍历 ,只能顺序遍历,不能对某个指定元素进行操作;
for循环遍历，指定下标位置，用list集合的get(i)方法获取元素,是最为基础的方法
iterate迭代器进行遍历,
在遍历方法中iterate迭代器的遍历最为高效；并且for each实际在内部也是使用iterator在进行遍历；
eg：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Damo11 {
public static void main(String[] args) {
List arrayslist = new ArrayList();
arrayslist.add("A");
arrayslist.add("B");
arrayslist.add("B");//允许重复
arrayslist.add("C");
arrayslist.add(null);//允许添加null
System.out.println(arrayslist);
//for each进行遍历
for (String string : arrayslist) {
System.out.println(string);
}
//for 循环进行遍历
for (int i = 0; i < arrayslist.size(); i++) {
System.out.println(arrayslist.get(i));
}
//iterate迭代器进行遍历
Iterator it =arrayslist.iterator();//获取迭代器对象
while(it.hasNext()){
String it1=it.next();
System.out.println(it1);
}
}
}
输出结果为：
[A, B, B, C, null]
A
B
B
C
null
A
B
B
C
null
A
B
B
C
null
linkedlist 的遍历：
与Arraylist相同，也可用for each ；for循环，iterator迭代器进行遍历；但由于linkedlist与Arraylist内部结构不同,所以在使用for循环遍历时，速度会随着索引的增大，而减慢；同样的使用迭代器遍历才是最高效的；
eg：
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class Damo11 {
public static void main(String[] args) {
List arrayslist = new LinkedList();
arrayslist.add("A");
arrayslist.add("B");
arrayslist.add("B");//允许重复
arrayslist.add("C");
arrayslist.add(null);//允许添加null
System.out.println(arrayslist);
//for each进行遍历
for (String string : arrayslist) {
System.out.println(string);
}
//for 循环进行遍历
for (int i = 0; i < arrayslist.size(); i++) {
System.out.println(arrayslist.get(i));
}
//iterate迭代器进行遍历
Iterator it =arrayslist.iterator();//获取迭代器对象
while(it.hasNext()){
String it1=it.next();
System.out.println(it1);
}
}
}
输出结果为：
[A, B, B, C, null]
A
B
B
C
null
A
B
B
C
null
A
B
B
C
null
Map集合：
是一种依照键（key）存储元素的容器。在Map中键（key）可以使任意类型的对象。Map中不能有重复的键（Key），每个键（key）都有一个对应的值（value）。一个键（key）和它对应的值构成map集合中的一个元素。我们可以用键（key）来快速获取对应的值(value)
其实现类有:hashMap linkedhashMap TreeMap
Map中的键(key)不允许重复,并且一个键只能关联一个值(value),当添加进的元素键(key)相同,值(value)不同时,Map就会把原本键(key)关联的值(value)进行覆盖;
以hashmap为例;
import java.util.HashMap;
import java.util.Map;
public class Damo07 {
public static void main(String[] args) {
Map hashMap = new HashMap();
hashMap.put("A", "1");
hashMap.put("B", "2");
hashMap.put("C", "3");
System.out.println("原"+hashMap);
hashMap.put("A", "2");//会覆盖原有value上的值
System.out.println("覆盖后"+hashMap);
}
}
输出结果为:
原{A=1, B=2, C=3}
覆盖后{A=2, B=2, C=3}
Map的遍历:
方式一，将Map转化为set集合，通过set集合的迭代器取出set集合中的元素，即是Map中的所有键，再通过get方法获取对应的值；
eg：
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Damo07 {
public static void main(String[] args) {
Map hashMap = new HashMap();
hashMap.put("A", "1");
hashMap.put("B", "2");
hashMap.put("C", "3");
System.out.println(hashMap);
Set set = hashMap.keySet();
Iterator it = set.iterator();
while (it.hasNext()) {
String key = it.next();
String value = hashMap.get(key);
System.out.println("key="+key+"--value="+value);
}
}
}
输出结果为：
{A=1, B=2, C=3}
key=A--value=1
key=B--value=2
key=C--value=3
方法二：获取所有的value值，不能获取key的对象
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class Damo02 {
public static void main(String[] args) {
Map hashMap = new HashMap();
hashMap.put("A", "1");
hashMap.put("B", "2");
hashMap.put("C", "3");
System.out.println(hashMap);
Collection col = hashMap.values();
Iterator it = col.iterator();
while (it.hasNext()) {
System.out.println("value="+it.next());
}
}
}
输出结果为：
{A=1, B=2, C=3}
value=1
value=2
value=3
方法三：
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Damo03 {
public static void main(String[] args) {
Map hashMap = new HashMap();
hashMap.put("A", "1");
hashMap.put("B", "2");
hashMap.put("C", "3");
System.out.println(hashMap);
Set> entry =hashMap.entrySet();
Iterator> it = entry.iterator();
while (it.hasNext()) {
Map.Entry en = it.next();
System.out.println("key="+en.getKey()+"--value="+en.getValue());
}
}
}
输出结果为:
{A=1, B=2, C=3}
key=A--value=1
key=B--value=2
key=C--value=3
Queue队列:
是先进先出的有序表(FIFO)，只能在尾部添加元素，在队首将元素输出,所以元素的放入顺序就是输出的顺序;同时要避免将null加入到队列中；其实现类有linkedlist和ArrayBlockingQueue,
有界队列：有界限，大小长度受限制，常见的实现类ArrayBlockingQueue
无界队列：无界限，大小长度受限制，常见的实现类linkedlist
eg：
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
public class Damo02 {
public static void main(String[] args) {
//无界队列:队列容量不受限制
Queue queue1 = new LinkedList();
queue1.add("A1");
queue1.add("A2");
queue1.add("A3");
queue1.add("A4");//添加元素
//取出队首元素,并删除,如果是空队列时,则会返回null;
System.out.println(queue1.poll());
System.out.println(queue1.poll());
System.out.println(queue1.poll());
System.out.println(queue1.poll());
System.out.println(queue1.poll());
System.out.println(queue1.peek());
//有界队列:队列容量受构造方法的限制，当超出界限是会抛出
//java.lang.IllegalStateException异常
Queue queue2 = new ArrayBlockingQueue(5);
queue2.add("B1");
queue2.add("B2");
queue2.add("B3");
queue2.add("B4");//添加元素
queue2.add("B5");
System.out.println(queue2.poll());
System.out.println(queue2.poll());
System.out.println(queue2.poll());
System.out.println(queue2.poll());
System.out.println(queue2.poll());
}
}
输出结果为：
A1
A2
A3
A4
null
null
B1
B2
B3
B4
B5
常用方法:
添加元素: add(E)；offer(E)；
获取元素: remove(E)；poll(E); / elemnt(E); pook(E); 同样都是获取元素,但二者不同的是;前者是获取队首元素并将其删除,后者只是获取队首元素.
注意在队列中更加推荐使用offer(E)来添加元素；用poll(E)来取出队首元素,
eg:
import java.util.LinkedList;
import java.util.Queue;
public class Damo02 {
public static void main(String[] args) {
//无界队列:队列容量不受限制
Queue queue1 = new LinkedList();
queue1.add("A1");
queue1.add("A2");
queue1.offer("A3");
queue1.offer("A4");
//取出队首元素,并删除,如果是空队列时,则会返回null;
System.out.println(queue1.peek());
System.out.println(queue1.peek());
System.out.println(queue1.poll());
System.out.println(queue1.poll());
}
}
输出结果为:
A1
A1
A1
A2
遍历方法:
使用while循环进行遍历
import java.util.LinkedList;
import java.util.Queue;
public class Damo02 {
public static void main(String[] args) {
//无界队列:队列容量不受限制
Queue queue1 = new LinkedList();
queue1.add("A1");
queue1.add("A2");
queue1.offer("A3");
queue1.offer("A4");
while (!queue1.isEmpty()) {
System.out.println(queue1.poll());
}
}
}
输出结果为:
A1
A2
A3
A4
Priorityqueue优先级队列:
一种特殊的队列,可实现"插队",其并没有排序的能力,只是可保证优先级最高的元素排在队列的最前列;
eg:
import java.util.PriorityQueue;
public class Damo03 {
public static void main(String[] args) {
PriorityQueue pqueue = new PriorityQueue();
pqueue.offer("B");
pqueue.offer("A");
pqueue.offer("D");
pqueue.offer("C");
System.out.println(pqueue.poll());
System.out.println(pqueue.poll());
System.out.println(pqueue.poll());
System.out.println(pqueue.poll());
}
}
输出结果为:
A
B
C
D
遍历方法:
while循环
import java.util.PriorityQueue;
public class Damo03 {
public static void main(String[] args) {
PriorityQueue pqueue = new PriorityQueue();
pqueue.offer("B");
pqueue.offer("A");
pqueue.offer("D");
pqueue.offer("C");
while (!pqueue.isEmpty()) {
System.out.println(pqueue.poll());
}
}
}
输出结果为:
A
B
C
D
Deque双端队列:
与Queue(队列)，Priorityqueue (优先级队列)只能在队首出队,队尾入队的结构不同,双端队列,允许两端进队,两端入队
eg:
import java.util.Deque;
import java.util.LinkedList;
public class Damo01 {
public static void main(String[] args) {
Deque deque = new LinkedList();
deque.offerFirst("陈");//添加到队首
deque.offerLast("xi");//添加到队尾
deque.offer("520");//添加到队尾
deque.offer("1314");
System.out.println(deque);
//出队
System.out.println(deque.poll());//出对首(可以使用该方法,但是不推荐)
System.out.println(deque.pollFirst());//出队首
System.out.println(deque.pollLast());//出队尾
}
}
输出结果为:
[陈, xi, 520, 1314]
陈
xi
1314
常用方法:
大致方法与Queue相同，有几个特殊儿的方法如:
offerfirst(E);添加元素到队首.offerlast(E);添加元素到队尾；
pollFirst(E);输出队首元素 pollLast(E);输出队尾元素
遍历方法:同样的可使用while循环进行遍历,不同的时双端队列可正序遍历和逆序遍历;
import java.util.Deque;
import java.util.LinkedList;
public class Damo02 {
public static void main(String[] args) {
Deque deque = new LinkedList();
deque.offerFirst("陈");//添加到队首
deque.offerLast("xi");//添加到队尾
deque.offer("520");//添加到队尾
deque.offer("1314");
System.out.println(deque);
//正向输出
// while (!deque.isEmpty()) {
// System.out.println(deque.pollFirst());
// }
//逆序输出
while (!deque.isEmpty()) {
System.out.println(deque.pollLast());
}
}
}
输出结果为:
[陈, xi, 520, 1314]
1314
520
xi
陈
