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：
import java.util.*;
class Demo1 
{
public static void main(String[] args) 
{
Collection coll=new ArrayList();//多态
coll.add("java01");//添加对象
coll.add("java02");
coll.add("java03");
coll.add(66);// int new Integer(66) 自动装箱

coll.add(p);

sop(coll);

Collection c = new ArrayList();
c.add("hadoop");
c.add("spark");

coll.addAll(c);//把别的集合中的数据添加到当前集合中

sop(coll);

coll.remove(66);//删除某一个对象
sop(coll);

coll.removeAll(c);
sop(coll);

boolean boo = coll.contains("java01");//判断是否包含某个对象
sop(boo);
boo=coll.containsAll(c);
sop(boo);

boolean e=coll.isEmpty();
sop(e);

sop(coll.size());//得到集合中对象的个数


Collection d = new ArrayList();
d.add("java01");
d.add("java02");
d.add("java03");

e=coll.equals(d);//重写了Object中的equals()方法，功能是比较两个集合中存储的数据是否一样
sop(e);


//集合变数组：Object[] toArray() 遍历
Object[] arr = coll.toArray();//集合中有几个对象，数组的长度就是多少
for(int i=0;i<arr.length;i++){
sop(arr[i]);
}
}

public static void sop(Object obj){
System.out.println(obj);
}
}

 

用例2：
import java.util.*;
class Demo2 
{
public static void main(String[] args) 
{
//Iterator<E> iterator() 获取集合中的对象：该方法返回的对象所属的类实现了Iterator接口
//使用iterator方法得到集合的内部类对象

Collection coll=new ArrayList();

coll.add("java01");
coll.add("java02");
coll.add("java03");

Iterator ite=coll.iterator();//迭代器

while(ite.hasNext()){
Object obj = ite.next();//多态
String ss = (String)obj;
System.out.println(ss.toUpperCase());
}    
}
}

 

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迭代器：提供了对集合进行添加修改和删除的功能，可以实现在迭代过程中对集合进行添加修改和删除

LinkedList自己特有的功能：
1:
addFirst() 添加到链表的头
addLast() 添加到链表的尾


2:getFirst() 得到链表的头节点
getLast() 得到链表的尾节点

3:removeFirst() 删除链表的头节点
removeLast() 删除链表的尾节点

从jdk1.6出现的

offerFirst()
offerLast()

peekFirst()//集合为空返回null，不会异常
peekLast()//集合为空返回null，不会异常

pollFirst()//集合为空返回null，不会异常
pollLast()//集合为空返回null，不会异常

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

1.Iterator ite = list.iterator();
while(ite.hasNext()){
Object obj =ite.next();
sop(obj);
}

2.for(Iterator it=list.iterator();it.hasNext();){
Object o = it.next();
sop(o);
}

3.for(int i=0;i<list.size();i++){
sop(list.get(i));
}


4.while(!list.isEmpty()){
sop(list.remove(0));
}

5. //实现对集合的遍历
Enumeration en = v.elements();
while(en.hasMoreElements()){
Object obj = en.nextElement();
System.out.println(obj);
}

 

12.使用LinkedList实现队列

import java.util.*;
//实现队列
class MyQueue
{
private LinkedList link;

MyQueue(){
link=new LinkedList();
}

//进队
public void enQueue(Object obj){
link.addLast(obj);
}

//出队
public Object deQueue(){
return link.removeFirst();
}

//判断队列是否为空
public boolean isNull(){
return link.isEmpty();
}
}

class Demo7 
{
public static void main(String[] args) 
{
MyQueue q=new MyQueue();
q.enQueue("1");
q.enQueue("2");
q.enQueue("3");

while(!q.isNull()){
System.out.println(q.deQueue());
}
}
}