黑马程序员——集合（一）

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 

1、概述

       集合就是一个容器，是用来存储对象的，里面可以存储不同的对象，只要是对象，就可以存储，集合可以分为很多种，他们的底层的存储结构是不一样的(数据结构)，所以不同的集合有不同的功能，根据情况选择不同集合。但是他们有共同的特点，就把特点抽取出来了，形成了接口Collection。

       集合的长度是变化的，数组的度长是固定的。

2、共性方法

（1）Add方法的参数类型是Object，以便于接收任意类型对象。

（2）集合中存储的都是对象的引用（地址）

public static void base_method() {

ArrayList al = new ArrayList();

// 1、添加元素

al.add("java01");

al.add("java02");

al.add("java03");

al.add("java04");

// 打印原集合

sop("原集合：" + al);

// 2、删除元素

al.remove("java02");

// al.clear(); //清空集合中的元素

sop("后来的集合：" + al);

//3、 获取长度

sop("al的长度："+al.size());

//4、判断

sop("al中是否含有java01："+al.contains("java01"));

sop("al是否为空："+al.isEmpty());

}

3、迭代器

       迭代器是用来获取集合中元素，其实迭代器是集合的内部类，因为捏不累读取本类的数据最方便，但是不同的集合他们的存储的结构不同，并且每个集合都要读取数据，所以就把他们共同的方法抽取出来，然后利用本类来返回他们自己的迭代器，这样既方便又安全。

       hasNext(),判断元素是否可以迭代next()方法然后迭代的下一个元素remove()从集合中移除此元素

Iterator it=al.iterator();
while(it.hasNext())
{
 System.out,println(it.next());
}

for(Iterator it=al.iterator();it.hasNext();)
{
 System.out,println(it.next());
}

第一种方式while循环完后，对象还在内存中，而第二种方式for循环完后，对象被回收了，因为实在for内部定义的，属于局部变量。

4、List集合共性方法

        List中的元素是有序的，元素可以重复，因为该集合体系有索引
Set元素是无序的，不可以重复。

List集合中特有方法：

增：
add(index,obj)在指定位置插入元素。
addAll(index,Collection)添加一个集合进去
删：
remove(index)移除指定位置的元素。
改：
set(index,obj)修改指定位置元素
查：
get(index)
for(int i=0;i<al.size();i++)
{
 al.get(i);
}
迭代器获取：
Iterator it=al.iterator();
while(it.hasNext())
{
 System.out,println(it.next());
}
//通过indexOf获取对象的位置
al.indexOf(obj);
//截取字串
al.subList(start,end);

5、ListIterator

List集合特有的迭代器：ListIterator是Iterator的子接口。

在迭代时，不可以通过集合对象的方法操作集合中的元素（会发生ConcurrModificationException异常），而Iterator方法有限，如果想要添加、修改就要用ListIterator。

public class ListDemo {

  public static void main(String[] args) {

    List list = new ArrayList();

    list.add("java01");

    list.add("java02");

    list.add("java03");

    System.out.println("集合：" + list);

    /* 在第二位置添加元素 */

    list.add(1, "java00");

    System.out.println("集合：" + list);

    /* 利用自己的迭代器读取和插入数据，在java03后面添加元素 */

    ListIterator it = list.listIterator(0);

    while (it.hasNext()) {

      if (it.next().equals("java03")) {

         it.add("javaLast");

      }

    }

    System.out.println("集合：" + list);

    /*取List集合中1~3的元素，包含头不包含尾*/

    List list1=list.subList(1, 3);

    System.out.println("集合List1=：" + list1);

  }

 

}

结果：

集合：[java01, java02, java03]

集合：[java01, java00, java02, java03]

集合：[java01, java00, java02, java03, javaLast]

集合List1=：[java00, java02]

6、List子集

List集合子对象：ArrayList，LinkedList，Vector。
ArrayList底层使用的是数组结构，特点在于查询速度很快，但是增删稍慢。线程不同步
LinkedList使用的是链表结构。特点就是增删速度很快，查询很慢。
Vector：底层是数组数据结构，出现较早。1.0版本就出现了。线程不同步。无论增删还是查询都慢。被ArrayList取代了。

7、Vector

枚举就是Vector特有的取出方式。（迭代器、遍历、for循环、按角标索引）

因为枚举的名称和方法的名称都长，所以被迭代器取代了，枚举郁郁而终了。

public static void main(String[] args){

Vector v=new Vector();

v.add("java01");

v.add("java02");

v.add("java03");

Enumeration eunm=v.elements();

while(eunm.hasMoreElements())

{

System.out.println(eunm.nextElement());

}

} 

8、LinkedList

 addFirst()；addLast();

 getFirst();getLast(); 获取元素但是不删除元素

 removeFirst();removeLast();获取元素但是删除元素，如果不存在此元素，那么据会抛出异常

1.6版本后的新方法

pollFirst()；pollLast();获取并移除第一个元素或者最后一个元素，如果不存在，返回为null，不抛出异常。

offerFirst();offerlast();

peekFirst();peekLast();

例子： 

import java.util.LinkedList;

public class LinkedListDemo {

  public static void main(String[] args) {

    LinkedList list = new LinkedList();

    list.add("forward01");

    list.addFirst("forward00");

    list.addLast("forwardLast");

    System.out.println("集合：" + list);

    // list.get(3);// 此会报异常，原因是集合中没有此元素

    System.out.println("集合中的第一个元素：" + list.remove(0));// 移除并且能获得，但是如果没有此元素的话，那么就会报异常

    System.out.println("移除第一个元素后的集合：" + list);

    System.out.println("获取第一个元素：" +list.peekFirst());// 获取第一个元素，但是不移除，如果不存在，则是null

    System.out.println("获取第一个元素：" +list.peekLast());// 获取最后一个元素，但是不移除，如果不存在，则是null

  }

}

集合：[forward00, forward01, forwardLast]

集合中的第一个元素：forward00

移除第一个元素后的集合：[forward01, forwardLast]

获取第一个元素：forward01

获取第一个元素：forwardLast

9、LinkedList练习

需求：
使用LinkedList模拟一个堆栈或队列数据结构。
堆栈：先进后出，如同一个杯子；
队列：先进先出，如同一个水管。

class Queue {

private LinkedList link;

Queue(){

link = new LinkedList();

}

public void myAdd(Object obj) {

link.addFirst(obj);

}

 

public Object myGet() {

//注：此处用removeLast()而不是getLast()

 return link.removeLast();

}

public boolean isNull(){

return link.isEmpty();

}

}

class Zhan {

private LinkedList link;

Zhan(){

link = new LinkedList();

}

public void myAdd(Object obj) {

link.addFirst(obj);

}

public Object myGet() {

//注：此处用removeLast()而不是getLast()

 return link.removeFirst();

}

public boolean isNull(){

return link.isEmpty();

}

}

public class LinkedListTest {

public static void main(String[] args) {

System.out.println("队列打印：");

Queue q=new Queue();

q.myAdd("java01");

q.myAdd("java02");

q.myAdd("java03");

while(!q.isNull()){

System.out.println(q.myGet());

}

System.out.println("堆栈打印：");

Zhan z=new Zhan();

z.myAdd("java01");

z.myAdd("java02");

z.myAdd("java03");

while(!z.isNull()){

System.out.println(z.myGet());

}

}

}