黑马程序员——java-集合框架

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

1
对象数组：就是数组里边存储的是一个一个的对象。
特点：数组一但定义，长度不能改变。

问题：在日常的开发中，用的比较多的是变化的。所以用数组存储就不是适合，针对此，java提供了新的容器——-集合
集合和数组的区别：

集合：
 A 长度可以改变
 B  只能存储引用类型
 C 可以存储任意类型的数据
数组：
 A  长度不可以改变
 B  可以存储基本类型，也可以存储引用类型
 C  只能存储统一种同一中类型的数据

2
Collection集合概述
Collection（接口）

  Collection继承体系结构图：
    Collection
        |--List（接口）
            |--ArrayList
            |--Vector
            |--LinkedList
        |--Set（接口）
            |--HashSet
            |--TreeSet

Collection集合的功能概述：

    A:添加功能
    boolean add(Object e):往集合中添加一个元素。
    boolean addAll(Collection c):往集合中添加一个集合的元素。

    B:删除功能      
    void clear():移除集合中的所有元素。
    boolean remove(Object o):移除集合中指定的一个元素。
    boolean removeAll(Collection c):移除集合中指定的一个集合的元素。

    C:判断功能
    boolean contains(Object o):判断集合中是否包含指定的元素。
    boolean containsAll(Collection c):判断集合中是否包含指定的一个集合的元素。
    boolean isEmpty():判断集合是否为空。

    D:迭代器   Iterator iterator()用于获取集合中的元素。

    E:长度功能
    int size():获取集合中元素的个数。

    F:交集功能
    boolean retainAll(Collection c)

    例如：集合A交集合B————A.retainAll(B);
          把集合A和集合B中相同的元素存放在集合A中，
          如果集合A发生过改变，就返回true，否则返回false

    G:转换为数组
    Object[] toArray():把集合转换为数组。

Collection集合的迭代器（Iterator）

    A:迭代器是集合的一种遍历方式。
    B:迭代器的使用步骤
        a:通过集合对象获取迭代器对象。
        b:通过迭代器对象判断是否有元素。
        c:通过迭代器对象获取元素，并移动到下一个位置。

    C:每种具体的集合的迭代器的具体实现是在每个具体集合类中。
      以内部类的方式实现的。

    介绍一下Iterator（接口） 
        A  是一个接口
        B  没有构造方法
        成员方法：
        --boolean hasNext()
        如果仍有元素可以迭代，则返回 true
        --Object next()返回迭代的下一个元素

public class Collection1
{
    public static void main(String[] args)
    {
        //创建集合对象，这里用到了多态
        Collection c=new ArrayList();
        //向集合中添加元素
        c.add("Hello");
        c.add("java");
        c.add("Hadoop");
        //获得集合对象迭代器
        Iterator it=c.iterator();
        //遍历集合对象
        while(it.hasNext())
        {
            System.out.println((String)it.next());
        }//Object next()此方法返回的是一个Object类型的对象，要想得到String类型的数据，就需要强转
//需要说明的是：因为collection集合中只有得到集合元素的个数的方法，没有得到对应索引出的元素的方法，所以不能使用普通for循环来遍历Collecion集合

    }

}

3
List集合（接口）

（1）List和Set集合都是Collection集合的字接口他们的区别是：
        List：该集合中的元素是有序的（存储和取出的顺序是一致的），可以重复
        Set：该集合中的元素是无序的，元素唯一不可以重复

---

（2）没构造方法
重要的功能方法：
    A:添加功能
        boolean add(int index,Object) 在指定的位置添加元素。
    B:删除功能
        Objiect remove(int index) 删除指定索引位置的元素，并返回该元素。
    C:修改功能
        Objict set(int index,Object obj) 用指定的元素修改指定位置的元素，并把修改前的元素返回。
    D:获取功能
        Objict get(int index) 根据给定的索引，获取元素。
    E:列表迭代器
    有两种迭代器：
        Iterator<E> iterator()（这是继承Collection集合的迭代器）
        ListIterator<E> listIterator()（这是本身特有的）

package Collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListIterator
{
    public static void main(String[] args)
    {
        //创建集对象
        List li=new ArrayList();
        //向集合中添加数据
        li.add("java");
        li.add("android");
        li.add("hello");



----------
方法一：获得collection的迭代器进行遍历


        //获得迭代器（collection的）
        Iterator it=li.iterator();
        while(it.hasNext())
        {
            System.out.println((String)it.next());
        }



----------
方法二：


        //因为List集合本身有E get(int index)和int size()所以可以使用普通for循环
        for (int i = 0; i < li.size(); i++)
        {
            String string=(String)li.get(i);
            System.out.println(string);
        }



----------
方法三：还可以使用ListIterator进行遍历（和Iterator一样）



    }
}

 （3）
 ListIterator的使用：
     A:可以逆向遍历，但是要先正向遍历，一般不用。
     --方法：E previous()返回列表中的前一个元素
     --方法：boolean hasPrevious()如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。（

public class ListIterator
{
    public static void main(String[] args)
    {
        //创建集对象
        List li=new ArrayList();
        //向集合中添加数据
        li.add("java");
        li.add("android");
        li.add("hello");
        //获得迭代器（首先需要正向遍历，才能用逆向遍历）（而且正向遍历的时候必须用ListIterator迭代器，用其他的迭代器或者普通for循环是不行的）
        ListIterator lit=li.listIterator();
        while(lit.hasNext())
        {
            System.out.println((String)lit.next());
        }

        System.out.println("--------------");
        //正向遍历结束后，才能逆向遍历
        while(lit.hasPrevious())
        {
            String string=(String) lit.previous();
            System.out.println(string);
        }
        System.out.println();

    }
}

  B：并发修改异常的问题：
  问题描述，在迭代器迭代的过程中，集合的元素是不能改变的，要是强制改变（向集合中添加元素），将出现并发修改异常
  在迭代器迭代的过程中，是不能通过集合来修改集合
  但是：有时候的我们的需要再迭代器迭代的时候修改集合中的数据

  这时候，ListIterator迭代器有特殊的方法
      --void add(E e)将指定的元素插入列表（可选操作
      --void set(E e)用指定元素替换 next 或 previous 返回的最后一个元素

   处理这个问题有两种方法：
       方法一：不用迭代器遍历集合，用集合本身来遍历集合
       方法二：用ListIterator进行遍历

package Collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
 * 需求：遍历给定的集合，是是否有张三这个元素，有，就向集合中添加另外一个元素李四
 */

public class ListIterator2
{
    public static void main(String[] args)
    {
        // 创建集合对象
        List li = new ArrayList();
        li.add("赵云");
        li.add("关羽");
        li.add("张三");
        li.add("伍六一");
        li.add("刘备");

        // 用集合本身遍历
        for (int i = 0; i < li.size(); i++)
        {
            String string = (String) li.get(i);
            if ((string).equals("张三"))
                ;
            {
                li.add("李四");
            }

        }
        System.out.println(li);

        // 用迭代器实现
        ListIterator listIterator = li.listIterator();
        while (listIterator.hasNext())
        {
            String string = (String) listIterator.next();
            if (string.equals("张三"))
            {
                listIterator.add("李四");
            }
        }

        System.out.println(li);

    }

}
需要：注意的是这两种方法都可以实现需求，但是得到的结果略有差别
用集合实现的：
    结果是：添加的元素（李四），一定在集合末尾
用迭代器实现：
    结果是：添加的元素（李四），在元素张三后边（紧挨着）

4
Lis接口的3个子类

  （1） ArrayList:
        底层数据结构是数组，查询快，增删慢。
        线程不安全，效率高。
    Vector: 
        底层数据结构是数组，查询快，增删慢。
        线程安全，效率低。
    LinkedList:
        底层数据结构是链表，查询慢，增删快。
        线程不安全，效率高。

---

      (2) 我们到底使用谁呢?
    看需求：
        要安全吗?
            要：Vector
            不要：ArrayList或者LinkedList
                查询多：ArrayList
                增删多：LinkedList

    什么都不知道，就用ArrayList。

---

   (3)   ArrayList的特有功能及案例：
           A:ArrayList存储字符串并遍历
           B:ArrayList存储自定义对象并遍历
           C:ArrayList存储字符串并遍历。要求去除重复值。
           D:ArrayList存储自定义对象并遍历。要求去除重复值。
           自定义对象：对象的成员变量值都相同，则为同一个对象。

package Collection;

import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;

import com.itheima.Persion;

public class ArrayList1
{
    /*
     * 需求：ArrayList存储自定义对象并遍历。要求去除重复值。思路：从给定的集合中，依次拿到元素，和新集合中的元素比较，如果新集合中没有此元素，
     * 就把此元素添加到新集合中，这样就去除了给定集合中的重复的元素
     */
    public static void main(String[] args)
    {
        // 给定集合自己创建(在集合中添加Student对象)
        Student P1 = new Student("赵云", 20);
        Student P2 = new Student("伍六一", 22);
        Student P3 = new Student("森马", 26);
        Student P4 = new Student("中泰", 21);
        Student P5 = new Student("赵云", 20);

        // 创建集合，并向集合中添加元素
        List oldArray = new ArrayList();
        oldArray.add(P1);
        oldArray.add(P2);
        oldArray.add(P3);
        oldArray.add(P4);
        oldArray.add(P5);

        // 创建新集合(存储旧集合的元素)
        List newList = new ArrayList();

        // 遍历旧集合

        for (int i = 0; i < oldArray.size(); i++)
        {
            if (!newList.contains(oldArray.get(i)))
            {
                newList.add(oldArray.get(i));
            }
        }

        // 遍历新集合

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

    }

}

---

package Collection;

public class Student
{
    private String name;
    private int age;

    public Student(String name, int age)
    {
        this.name = name;
        this.age = age;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    @Override//重写toString方法
    public String toString()
    {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    @Override//重写equals方法，如果不重写。测试类中contains方法用的是父类（Object）的equals方法，父类的此方法默认比较的是地址值
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null)
        {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

}

  （4）Vector（类）
      构造方法---public Vector()构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。 
     特有的方法：
         添加元素：public void addElement(E obj)
         遍历元素：
            普通for循环
             得到元素：public Object elementAt(int index)
             得到元素的个数：public int size()
            迭代器实现：
                public Enumeration<E> elements()
                Enumeration（接口中的方法
                    --boolean hasMoreElements()测试此枚举是否包含更多的元素。
                    --Object nextElement()如果此枚举对至少还有一个可提供的元素，则返回此枚举的下一个元素。 

---

package Collection;

import java.util.Enumeration;
import java.util.Vector;

public class VectorText
{
    public static void main(String[] args)
    {
        // 创建Vector集合（）
        Vector v = new Vector();
        // 向集合中添加元素

        v.addElement("zhansan");
        v.addElement("lisi");
        v.addElement("nihao");

        // 遍历集合
        // 方法一（普通for循环）
        for (int i = 0; i < v.size(); i++)
        {
            System.out.println((String) v.elementAt(i));
        }
        System.out.println("----------");
        // 方法二（用迭代器）

        Enumeration e = v.elements();
        while (e.hasMoreElements())
        {
            System.out.println(e.nextElement());
        }
    }
}

（5）
LinkedList的特有功能及案例：
    A:特有功能
        a:添加功能
            void addFirst()
            void addLast()
        b:删除功能
            object removeFirst()移除并返回此列表的第一个元素。
            Object removeLast()移除并返回此列表的最后一个元素。
        c:获取功能
            object getFirst()--添加到集合开头
            object getLast()--添加到集合末尾
    B:LinkedList存储字符串并遍历
         ---普通for循环
                 使用int size()和public E get(int index)方法 
         ---使用Iterator 
                  boolean hasNext() 和E next() 方法
  存在并发修改的错误
         使用 ListIterator的boolean add(Object c);方法解决，
              或者用集合自身的遍历
         ---增强for循环

    C:LinkedList存储自定义对象并遍历

---

package Collection;

public class LinkedListText
{
    /*
     * 需求：请用LinkedList模拟栈数据结构的集合，并测试。 思路：题目的意思是需要自己定义一个集合类
     * 该自定义的类中，可以有一个LinkedList类可以使用
     */
    public static void main(String[] args)
    {
         //创建自己定义的集合对象
        MyStack stack = new MyStack();

        // 向集合中添加元素
        stack.add("赵云");
        stack.add("哈哈");
        stack.add("朗天");
        stack.add("袁郎");

        while (!stack.isempty())
        {
            System.out.println(stack.get());
        }

    }

}

---

package Collection;

import java.util.LinkedList;

public class MyStack
{
    private LinkedList linkdeList;

    public MyStack()
    {
        linkdeList = new LinkedList();
    }

    public void add(Object e)
    {
        linkdeList.addFirst(e);
    }

    public Object get()
    {
        // return linkdeList.getFirst();//如用这个，将是死循环，并且只有一个元素
        return linkdeList.removeFirst();// 删除第一个元素，并发返回这个元素
    }

    public boolean isempty()
    {
        return linkdeList.isEmpty();
    }

}

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