java集合（一）

简单集合的体系结构

先来一张集合的体系结构图

在最顶层的父接口Collection中一定定义了所有子类集合的共同属性和方法,因此我们首先需要了解Collection中共性方法,然后再去针对每个子类集合学习它的特有方法

一个简单的集合的案例代码
import java.util.ArrayList;

/*
 *  ArrayList
 *  集合的体系结构：
 *      由于不同的数据结构（数据的组织，存储方式），所以Java为我们提供了不同的集合，
 *      但是不同的集合他们的功能都是相似，不断的向上提取，将共性抽取出来，这就是集合体系结构形成的原因
 *  
 *  体系结构：
 *          怎么学习?最顶层开始因为最顶层包含了所有的学习，共性
 *          怎么使用？使用最底层，因为最底层就是具体的实现
 *  
 *  Collection
 *  List
 *  ArrayList
 */
public class CollectionDemo {
    public static void main(String[] args) {        
        //创建集合对象
        ArrayList al = new ArrayList();
        //添加元素
        al.add("hello");
        al.add("world");
        al.add("java");
        //遍历集合
        for(int x = 0;x < al.size();x++) {
            System.out.println(al.get(x));
        }

    }
}

Collection中常用的方法

import java.util.ArrayList;
import java.util.Collection;

/*
 *  Collection  
 *          boolean add(E e)  
 *          void clear()  
 *          boolean contains(Object o)  
 *          boolean isEmpty() 
 *          boolean remove(Object o) 
 *          int size() 
 *          Object[] toArray() 
 * Iterator<E> iterator()  
 *      
 */
public class CollectionDemo2 {
    public static void main(String[] args) {        
        //创建集合对象
        //Collection c = new Collection();//Collection是接口，不能实例化
        Collection c = new ArrayList();//多态，父类引用指向子类对象  

        //boolean add(E e)  
        System.out.println(c.add("hello"));//永远可以添加成功，因为ArrayList他允许重复
        System.out.println(c.add("world"));

        //void clear()：清空集合
        //c.clear();

        //boolean contains(Object o)  :判断集合中是否包含指定元素
        //System.out.println(c.contains("java"));

        //boolean isEmpty() :是否为空
        //System.out.println(c.isEmpty());


        //boolean remove(Object o) :删除元素
        //System.out.println(c.remove("java"));

        //int size() :返回集合中的元素个数
        //System.out.println(c.size());

        //Object[] toArray()  :将集合转换成一个Object类型的数组
        Object[] objs = c.toArray();
        for (int i = 0; i < objs.length; i++) {
            System.out.println(objs[i]);
        }
        System.out.println(c);
    }
}

迭代器

迭代器是一种取出集合数据的通用的一种方式。
    Collection集合元素的通用获取方式：在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。而集合把这种取元素的方式描述在了Iterator中
    Iterator的常用方法如下
        hasNext（）方法：判断集合中是否有元素可以迭代
        next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。
    代码示例：
    import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
 * 集合的遍历方式：
 *      1.toArray(),可以把集合转换成数组，然后遍历数组即可
 *      2.iterator(),可以返回一个迭代器对象，我们可以通过迭代器对象来迭代集合
 *      3.foreach 高级for遍历
 * 
 * Iterator的方法：
 *  E next()  :返回下一个元素
 *  boolean hasNext()  ：判断是否有元素可以获取
 * 
 *  注意：Exception in thread "main" java.util.NoSuchElementException
 *      使用next方法获取下一个元素，如果没有元素可以获取，则出现NoSuchElementException

 */
public class IteratorDemo {
    public static void main(String[] args) {
        //method();
        //创建集合对象
        Collection c = new ArrayList();
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");

        //获取迭代器对象
        Iterator it = c.iterator();

        //Object next()  :返回下一个元素
        //boolean hasNext()  ：判断是否有元素可以获取

        /*if(it.hasNext())
            System.out.println(it.next());
        if(it.hasNext())
            System.out.println(it.next());
        if(it.hasNext())
            System.out.println(it.next());
        if(it.hasNext())
            System.out.println(it.next());*/

        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }

}

并发修改异常

当时用迭代器，进行集合的遍历的时候，使用了集合中的增删改方法，从而导致异常的产生

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/*
 * 需求：判断集合中是否包含元素java，如果有则添加元素android
 * Exception in thread "main" java.util.ConcurrentModificationException:并发修改异常
 * 迭代器是依赖于集合的，相当于集合的一个副本，当迭代器在操作的时候，如果发现和集合不一样，则抛出异常
 * 
 * 解决方案:
 *      你就别使用迭代器
 *      在使用迭代器进行遍历的时候使用迭代器来进行修改
 */
public class IteratorDemo3 {
    // 主方法使用了增删改方法，会抛出异常，而method中只是对集合进行判断和修改，因此不会抛出异常
    public static void main(String[] args) {
        //method();

        //创建集合对象
        //Collection c = new ArrayList();
        List c = new ArrayList();
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");

        //我们可以通过遍历来获取集合中的每一个元素，然后进行比较即可
        /*Iterator it = c.iterator();
        while(it.hasNext()) {
            String s = (String)it.next();
            if(s.equals("java")) {
                c.add("android");
            }
        }*/

        ListIterator lit = c.listIterator();
        while(lit.hasNext()) {
            String s = (String)lit.next();
            if(s.equals("java")) {
                lit.add("android");
            }
        }

        System.out.println(c);
    }

    private static void method() {
        //创建集合对象
        Collection c = new ArrayList();
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        //判断集合中是否包含元素java
        if(c.contains("java")) {
            c.add("android");
        }
        System.out.println(c);
    }

}

泛型

由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在转换的时候出现类型转换异常，所以java为了解决这个问题，给我们提供了一种机制，叫做泛型

测试代码如下：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class GenericDemo {
    public static void main(String[] args) {
        //创建集合对象
        Collection  c = new ArrayList();
        //创建元素对象
        Student s = new Student("zhangsan",18);
        Student s2 = new Student("lisi",19);
        //添加元素对象
        c.add(s);
        c.add(s2);
        //遍历集合对象

        Iterator  it = c.iterator();
        while(it.hasNext()) {
            // 集合中存储的是student，转换的是字符串，因此会抛出类型转换异常
             String str = (String)it.next();
             System.out.println(str);
        }
    }
}


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

出现异常的原因：
    原因就是String str = (String)it.next() ,存入集合的是Student,而强转为String,String与Student之间没有任何子父关系不能强转,未使用泛型前有可能发声强制转换异常的问题

添加泛型之后的代码：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
 * 使用集合存储自定义对象并遍历
 * 
 * 泛型：是一种广泛的类型，把明确数据类型的工作提前到了编译时期，借鉴了数组的特点
 * 泛型好处：
 *          避免了类型转换的问题
 *          可以减少黄色警告线
 *          可以简化我们代码的书写
 * 
 * 什么时候可以使用泛型？
 *      问API，当我们看到<E>，就可以使用泛型了
 *          
 */
public class GenericDemo {
    public static void main(String[] args) {
        //创建集合对象
        Collection<Student> c = new ArrayList<Student>();
        //创建元素对象
        Student s = new Student("zhangsan",18);
        Student s2 = new Student("lisi",19);
        //添加元素对象
        c.add(s);
        c.add(s2);
        //遍历集合对象

        Iterator<Student> it = c.iterator();
        while(it.hasNext()) {
            //String str = (String)it.next();
            //System.out.println(str);

            Student stu = it.next();
            System.out.println(stu.name);
        }
    }
}

class Student {
    String name;
    int age;

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

增强for

格式：
    for(元素的数据类型  变量 : Collection集合or数组){ }
它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

实例代码：

import java.util.ArrayList;
import java.util.Collection;

/*
 * foreach:增强for循环，一般用于遍历集合或者数组
 * 格式：
 *      for(元素的类型 变量 : 集合或者数组对象) {
 *          可以直接使用变量;
 *      }
 *  注意：在增强for循环中不能修改集合，否则会出现并发修改异常。
 */
public class ForEachDemo {
    public static void main(String[] args) {
         //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");

        //增强for循环遍历集合
        /*for(Object obj : c) {
            System.out.println(obj);
        }*/


        /*for(String s : c) {
            System.out.println(s.toUpperCase());
        }*/

        for (String string : c) {
            c.add("android");
            System.out.println(string);
        }
    }
}

List子体系

ArrayList

.1List子体系特点
    A:有序的（存储和读取的顺序是一致的） 
    B:有整数索引 
    C:允许重复的
代码示例：

import java.util.ArrayList;
import java.util.List;
/*
 * List:
 *      有序的（存储和读取的顺序是一致的）
 *      有整数索引
 *      允许重复的
 * 
 * List的特有功能：
 *          void add(int index, E element)  
 *          E get(int index)  
 *          E remove(int index)  
 *          E set(int index, E element)
 *  
 *   增删改查
 *   
 */
public class ListDemo {
    public static void main(String[] args) {
        //创建的列表对象
        List list = new ArrayList();

        //void add(int index, E element)  : 在指定索引位置添加指定元素
        list.add(0, "hello");
        list.add(0, "world");
        list.add(1, "java");

        //E get(int index)  :根据索引返回元素
        /*System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));*/
        //System.out.println(list.get(3));

        /*for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }*/

        //E remove(int index)  : 删除指定元素并返回

        //System.out.println(list.remove(5));

        //E set(int index, E element) : 将指定索引位置的元素替换为指定元素，并将原先的元素返回
        System.out.println(list.set(0, "android"));

        System.out.println(list);
    }
}

LinkedList

代码示例


import java.util.LinkedList;

/*
 * List的常用子类：
 *      ArrayList
 *          底层是数组结构，查询快，增删慢
 *      LinkedList
 *          底层结构是链表，查询慢，增删快
 * 
 * 如何选择使用不同的集合？
 *      如果查询多，增删少，则使用ArrayList
 *      如果查询少，增删多，则使用LinkedList
 *      如果你不知道使用什么，则使用ArrayList
 * 
 * LinkedList的特有功能：
 *          void addFirst(E e)  
 *          void addLast(E e) 
 *          E getFirst()  
 *          E getLast()  
 *          E removeFirst() 
 *          E removeLast() 
 *              
 */
public class LinkedListDemo {
    public static void main(String[] args) {
            LinkedList list = new LinkedList();
            list.add("hello");
            list.add("world");

            //void addFirst(E e)  :将元素添加到索引为0的位置
            //void addLast(E e) ：将元素添加到索引为size()-1的位置
            list.addFirst("java");
            list.addLast("android");

            //E getFirst()  :获取索引为0的元素
            //E getLast()  ：获取索引为size()-1的元素
            //System.out.println(list.getFirst());
            //System.out.println(list.getLast());

            //E removeFirst() :删除索引为0的元素并返回
            //E removeLast() ：删除索引为size()-1的元素并返回
            System.out.println(list.removeFirst());
            System.out.println(list.removeLast());


            System.out.println(list);
    }
}