java中集合的特点

java中集合的特点

集合的关系图

/**
 * 集合的特点
 * 1.用于存储对象的容器
 * 2.集合的长度 是可变 的
 * 3.集合中不可以存储 基本数据类型值
 *
 * 集合容器因为内部的数据结构不同，有多种具体容器，不断向上抽取，就形成了集合框架
 * 框架的顶层Collection接口
 *
 * Collection的常见方法
 *
 * 1.添加
 *    boolean add(E e)  确保此 collection 包含指定的元素（可选操作）。
 *    boolean addAll(Collection c)
 * 2.删除
 *    boolean remove()
 *    boolean removeAll()
 * 3.判断
 *    boolean contains()
 *    boolean containsAll()
 *    boolean isEmpty():判断集合中是否有元素
 * 4.获取
 *    int size():返回此Collection中的元素数
 *    Iterator  iterator:取出元素的方式 ：迭代器
 *    该对象必须依赖于具体的容器，因为每一个容器的数据结构都 不同
 *    所以该迭代器对象 是在容器中进行内部实现的
 *    对于使用容器者而言，具体的实现不重要，只要通过窗口获取到该实现的迭代器对象即可
 *    也就是iterator()方法
 * 5.其它
 *    boolean retainAll():取交集  将两个集合中的相同元素从调用removeAll的集合中移除
 *    Object[] toArray():将集合转成数组
 *
 *
 * -----------------------------------
 *  Collection
 *   两个最重要的子类
 *   1.List:有序（存入和取出的顺序一致），元素都 有索引，元素可以重复
 *   2.Set:元素不能重复，无序。
 *
 *   List:特有的常见方法，有一个共性特点就是都可以操作角标
 *       1.添加
 *          boolean add(int index, E element)在列表的指定位置插入指定元素（可选操作）。
 *       2.删除
 *          boolean remove(Object o)从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
 *       3.修改
 *          Object set(index,element)
 *       4.获取
 *           Object get(index)
 *           int indexOf(object)
 *           int lastIndexOf(object)
 *           List subList(int fromIndex, int toIndex)返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
 *
 *  List集合是可以完成对元素的增删改查的
 *
 *  List:
 *    ---Vector:内部是数组数据结构，是同步的（线程安全）。增删，查询都很慢。
 *    ---ArrayList:内部是数组结构，是不同步的。替代Vector.查询的速度快。
 *    ---LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。
 *
 *  LinkedList:
 *     addFirst();
 *     addLast();
 *
 *     getFirst();//获取但不移除，如果链表为空，抛出异常NoSuchElementException
 *     getLast();
 *     jdk1.6以后
 *     pollFirst();//获取但不移除，如果链表为空 ,返回null;
 *     pollLast();//
 *
 */

//Collection的demo

public class CollectionDemo {
    public static void main(String[]args){
        Collection collection = new ArrayList();
        show(collection);
    }

    private static void show(Collection collection) {
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("ddd");


        System.out.println(collection);
    }
}

//IteratorDemo

public class IteratorDemo {
    public static void main(String[]args){
        Collection collection = new ArrayList();
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("ddd");

        //使用了Collection中的iterator()方法。调用 集合中的迭代器，是为了获取集合中的迭代器对象

        //用法一
        Iterator iterator = collection.iterator();
//        while (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }

        //用法二
        for (Iterator iterator1 = collection.iterator();iterator1.hasNext();){
            System.out.println(iterator1.next());
        }
    }
}

//ListDemo

public class ListDemo{
        public static void main(String[]args){
            List list = new ArrayList();
            list.add("aaa");
            list.add("bbb");
            list.add("ccc");
            list.add("ddd");
            list.add("eee");
            System.out.println(list);
            //插入元素
//            list.add(1,"fff");
//            System.out.println(list);
            //删除元素
//            System.out.println(list.remove(1));
            //修改元素
//            System.out.println(list.set(3,"iii"));
            //获取元素
//            System.out.println(list.get(4));
            //获取子元素
            System.out.println(list.subList(2,4));

            System.out.println(list);
        }

//ListDemo2

public class ListDemo2 {
    public static void main(String[]args){
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        System.out.println(list);

        ListIterator listIterator = list.listIterator();
        //它可以实现在迭代过程 中完成 对元素的增删改查
        //注意，只有list列表具备些功能
        while (listIterator.hasNext()){
            Object ob = listIterator.next();
            if (ob.equals("bbb")){
                listIterator.add("ggg");
            }
        }
        System.out.println(list);

        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
        System.out.println(list);
/*
        Iterator iterator=list.iterator();
        while (iterator.hasNext()){
            //如果这样写，会报错,在迭代过程中，不要使用集合操作元素，容易抛出异常
            //java.util.ConcurrentModificationException
            //当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常
            //可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作
            Object ob = iterator.next();
            if (ob.equals("bbb")){
                list.add("ggg");
            }
        }
        System.out.println(list);
    */
    }
}

//VectorDemo

public class VectorDemo {
    public static void main(String[]args){
        Vector vector = new Vector();
        vector.addElement("aaa");
        vector.addElement("bbb");
        vector.addElement("ccc");
       Enumeration enumeration =  vector.elements();
        while (enumeration.hasMoreElements()){
            System.out.println(enumeration.nextElement());
        }
    }
}

//LinkListDemo

/**
 * 请使用LinkedList来模拟一个堆栈或者队列数据结构
 * <p>
 * 堆栈：
 * 栈的特点：先进后出
 * <p>
 * 队列：先进先出
 */

class DuiLie {
    private LinkedList list;

    public DuiLie() {
        list = new LinkedList();
    }

    public void add(Object o) {
        list.addLast(o);
    }

    public Object getList() {
        return list.removeFirst();
    }

    public boolean isEmpty() {
        return list.isEmpty();
    }
}

public class LinkedListTest {
    public static void main(String[] args) {
        DuiLie duiLie = new DuiLie();
        duiLie.add("aaa");
        duiLie.add("bbb");
        duiLie.add("ccc");
        duiLie.add("ddd");
        while (!duiLie.isEmpty()) {
            System.out.println(duiLie.getList());
        }
    }
}

// 利用arrayList去除集合中的重复元素

public class Person {

    private String name;
    private int age;

    public Person(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
    public int hashCode() {//判断hash值是否相同

//        System.out.println(this+"......hashcode...");
        return name.hashCode() + age;
    }
    @Override
    public boolean equals(Object obj) {//判断内容是否相同
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof Person)) {
            throw new ClassCastException("类型转换错误");
        }
//        System.out.println(this + "......equals...." + obj);
        Person person = (Person) obj;
        return this.name.equals(person.name) && this.age == person.age;
    }

    @Override
    public String toString() {
        return name+":"+age;
    }
}

public class ArrayListTest {
    public static void main(String[] args){
        test();
        test2();
    }

    //存自定义对象
    //注意：//arrayList判断元素是否相同 remove(),contains(),的依据是equals()方法，
             //HashSet的依据是hashCode()和equals()方法,该元素是否有和该容器中的元素相同
             //所以对于自定义对象，一定要重写equals()方法，
    private static void test2() {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Person("aaa", 10));
        arrayList.add(new Person("bbb", 20));
        arrayList.add(new Person("ccc", 30));
        arrayList.add(new Person("bbb", 20));
        arrayList.add(new Person("ccc", 30));

        System.out.println(arrayList);

        arrayList = singletest(arrayList);

        System.out.println(arrayList);
    }

    //存字符串
    private static void test() {
        ArrayList arrayList = new ArrayList();
        arrayList.add("aaa");
        arrayList.add("bbb");
        arrayList.add("ccc");
        arrayList.add("ccc");
        arrayList.add("ddd");
        arrayList.add("ddd");
        arrayList.add("ddd");

        System.out.println(arrayList);

        arrayList = singletest(arrayList);
        System.out.println(arrayList);
    }


    public static ArrayList singletest(ArrayList list){
        //1,定义一个集合的迭代器
        Iterator iterator = list.iterator();
        //2，创建一个新的list集合
        ArrayList arrayList1 = new ArrayList();
        //3，迭代list集合
        while (iterator.hasNext()){
            //4.定义 一个对象接收集合中的元素
            Object object = iterator.next();
            //5.判断新集合中是否有相同的元素，如果没有，则存进新的集合
            if (!arrayList1.contains(object)){
                arrayList1.add(object);
            }
        }
        return arrayList1;
    }
}