Java学习第十二天

1.集合：可以存储不同类型的对象，随着对象个数的增加，容量自动增加(顶层是一个接口)

2.为什么有这么多的集合？
　　　　每种集合底层使用的数据结构是不一样的，也就是说每种集合存储数据的特点是不一样的，
　　项目中根据数据的特点来选择不同的集合

3.实现存储不同类型的对象？
　　Object[] arr =new Object[3];
　　　　//常用方法：定义Object类型的数组就可以实现，但随着存储的对象的增加，数组的容量是固定不变的
　　　　//缺点：容量固定

4.集合体系最顶层的是Collection接口：这个接口定义的是整个体系最共性的东西

最共性的功能：
　　添加：
　　　　boolean add(Object o)//多态 集合中存储的都是对象,集合中存储的是对象的地址
　　　　boolean addAll(Collection<? extends E> c)
　　删除：
　　　　boolean remove(Object o)
　　　　boolean removeAll(Collection<?> c)
　　　　void clean()
　　判断：
　　　　boolean contains(Object o)
　　　　boolean acontainsAll(Collection<?> c)
　　　　boolean isEmpty()//判空
　　　　boolean equals(Object o)//重写了Object中的equals()方法，功能是比较两个集合中存储的数据是否一样
　　获取：
　　　　Iterator<E> iterator()//获取集合中的对象，集合遍历的方法，该方法返回的对象所属的类实现了Iterator接口
　　　　//使用iterator方法得到集合的内部类对象
　　　　int size()//获取集合中对象的个数
　　集合变数组：
　　　　Object[] toArray()//集合中有几个对象，数组的长度就是多少

 1 用例1：
 2 import java.util.*;
 3 class Demo1 
 4 {
 5 public static void main(String[] args) 
 6 {
 7 Collection coll=new ArrayList();//多态
 8 coll.add("java01");//添加对象
 9 coll.add("java02");
10 coll.add("java03");
11 coll.add(66);// int new Integer(66) 自动装箱
12 
13 coll.add(p);
14 
15 sop(coll);
16 
17 Collection c = new ArrayList();
18 c.add("hadoop");
19 c.add("spark");
20 
21 coll.addAll(c);//把别的集合中的数据添加到当前集合中
22 
23 sop(coll);
24 
25 coll.remove(66);//删除某一个对象
26 sop(coll);
27 
28 coll.removeAll(c);
29 sop(coll);
30 
31 boolean boo = coll.contains("java01");//判断是否包含某个对象
32 sop(boo);
33 boo=coll.containsAll(c);
34 sop(boo);
35 
36 boolean e=coll.isEmpty();
37 sop(e);
38 
39 sop(coll.size());//得到集合中对象的个数
40 
41 
42 Collection d = new ArrayList();
43 d.add("java01");
44 d.add("java02");
45 d.add("java03");
46 
47 e=coll.equals(d);//重写了Object中的equals()方法，功能是比较两个集合中存储的数据是否一样
48 sop(e);
49 
50 
51 //集合变数组：Object[] toArray() 遍历
52 Object[] arr = coll.toArray();//集合中有几个对象，数组的长度就是多少
53 for(int i=0;i<arr.length;i++){
54 sop(arr[i]);
55 }
56 }
57 
58 public static void sop(Object obj){
59 System.out.println(obj);
60 }
61 }

 1 用例2：
 2 import java.util.*;
 3 class Demo2 
 4 {
 5 public static void main(String[] args) 
 6 {
 7 //Iterator<E> iterator() 获取集合中的对象：该方法返回的对象所属的类实现了Iterator接口
 8 //使用iterator方法得到集合的内部类对象
 9 
10 Collection coll=new ArrayList();
11 
12 coll.add("java01");
13 coll.add("java02");
14 coll.add("java03");
15 
16 Iterator ite=coll.iterator();//迭代器
17 
18 while(ite.hasNext()){
19 Object obj = ite.next();//多态
20 String ss = (String)obj;
21 System.out.println(ss.toUpperCase());
22 }    
23 }
24 }

5.list接口：存储的数据是有序的(有序是指集合中存储的数据顺序和添加数据的顺序是一致的)，存储的数据是可以重复的

6.list的3个子类：
　　ArrayList:底层数据结构使用的是数组，线程不安全的，查找速度快，增删速度慢(数组开辟的内存是连续的)
　　Vector:底层数据结构使用的是数组，线程安全的，查找速度快，增删速度慢，被ArrayList替代了
　　linkedList:底层数据结构是链表，线程不安全的，查找速度慢，增删速度快

7.list特有的功能：都是可以操作下标的的功能
　　增：
　　　　void add(int index,E element)
　　　　boolean addAll(int index,Colletion<? extends E> c)

　　删：
　　　　E remove(int index)//返回被删除的对象

　　改：
　　　　E set(int index,E element)

　　查：
　　　　//ListIterator提供了对集合进行添加修改和删除的功能，可以在实现迭代过程中对集合进行添加修改删除
　　　　ListIterator<E> ListIterator
　　　　//返回此列表元素的列表迭代器(按适当顺序)
　　　　ListIterator<E> ListIterator(int index)

　　　　Lis<E> subList(int fromIndex,int lastIndex)//截取指定list,[x,y)
　　　　E get(int index))

8.Iterator迭代器：得到迭代器是已经明确了集合中的元素
　　　在集合迭代过程中对集合进行添加，修改，删除都会引发异常ConcurrentModificationException

9.集合的遍历：Iterator iterator()
　　因为数据存储在集合的内部，内部类可以直接操作集合内部的数据
　　所以集合使用内部类来遍历数据，因为不同的集合存储数据的结构不同
　　所以遍历的方式也不同，所以对所有的内部类提取共性的行为
　　定义在一个接口中，这个借口就是Iterator，共性的方式就是
　　boolean hasNext()
　　object next()
　　因此内部类都实现了Iterator接口的

10ListIterator迭代器：提供了对集合进行添加修改和删除的功能，可以实现在迭代过程中对集合进行添加修改和删除

 1 LinkedList自己特有的功能：
 2 1:
 3 addFirst() 添加到链表的头
 4 addLast() 添加到链表的尾
 5 
 6 
 7 2:getFirst() 得到链表的头节点
 8 getLast() 得到链表的尾节点
 9 
10 3:removeFirst() 删除链表的头节点
11 removeLast() 删除链表的尾节点
12 
13 从jdk1.6出现的
14 
15 offerFirst()
16 offerLast()
17 
18 peekFirst()//集合为空返回null，不会异常
19 peekLast()//集合为空返回null，不会异常
20 
21 pollFirst()//集合为空返回null，不会异常
22 pollLast()//集合为空返回null，不会异常

11.遍历集合的五种方法：

 1 1.Iterator ite = list.iterator();
 2 while(ite.hasNext()){
 3 Object obj =ite.next();
 4 sop(obj);
 5 }
 6 
 7 2.for(Iterator it=list.iterator();it.hasNext();){
 8 Object o = it.next();
 9 sop(o);
10 }
11 
12 3.for(int i=0;i<list.size();i++){
13 sop(list.get(i));
14 }
15 
16 
17 4.while(!list.isEmpty()){
18 sop(list.remove(0));
19 }
20 
21 5. //实现对集合的遍历
22 Enumeration en = v.elements();
23 while(en.hasMoreElements()){
24 Object obj = en.nextElement();
25 System.out.println(obj);
26 }

12.使用LinkedList实现队列

 1 import java.util.*;
 2 //实现队列
 3 class MyQueue
 4 {
 5 private LinkedList link;
 6 
 7 MyQueue(){
 8 link=new LinkedList();
 9 }
10 
11 //进队
12 public void enQueue(Object obj){
13 link.addLast(obj);
14 }
15 
16 //出队
17 public Object deQueue(){
18 return link.removeFirst();
19 }
20 
21 //判断队列是否为空
22 public boolean isNull(){
23 return link.isEmpty();
24 }
25 }
26 
27 class Demo7 
28 {
29 public static void main(String[] args) 
30 {
31 MyQueue q=new MyQueue();
32 q.enQueue("1");
33 q.enQueue("2");
34 q.enQueue("3");
35 
36 while(!q.isNull()){
37 System.out.println(q.deQueue());
38 }
39 }
40 }