黑马程序员---2015.6.20java基础笔记---集合类--ArrayList---LinkedList---HashSet

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1.为什么出现集合类？

            集合就是存储对象最常用得一种方式
2.数组和集合类同是容器，有何不同？
            数组虽然也可以存储对象，但是长度是固定的。集合长度是可变的。
            数组中可以存储基本类型，集合则能存储对象。
3.集合类的特点
            集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
4.集合框架
                            collection
            list                                           Set
ArryList  LinkedList  Vector      HashSet   TreeSet        
    为什么出现这么多的容器？
            因为每一个容器对数据的存储方式不同。这个存储方式称之为：数据结构        
5.add方法的参数类型是Object，以便于接收任意类型对象
    集合中存储的都是对象的引用(地址)
6. al1.retainAll()    //取al1和al2的交集，交集存储在al1当中，如果没有交集，则al1为空。
                                            //al2,始终没有变化
        al1.removeAll(al2)//把al1中的al2干掉
7.迭代器的两种写法
        方式一：
                for(Iterator it2 = al.iterator();it2.hasNext();)
                {
                    sop(it2.next());    //变量函数，使用完就释放内存，比较节约内存
                }    
        方式二：
                Iterator it = al.iterator();
                while(al.hasNext()){
                    sop(ai.next());
                }    
8.List集合特有的迭代器。ListIterator是Iterator的子接口。
    在迭代过程中不可以通过集合对象的方法，操作集合中的元素。
    因为会发生ConcurrentModificationException异常
    
    所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法时有限的
    只能对元素进行判断，取出，删除。
    如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator
    该接口只能通过List集合的ListIterator方法获取。

    简单来说：要在遍历List集合的过程中，操作元素，就只能用ListIterator
9.枚举就是Vector特有的取出方式
    和迭代器Iterator很像。
    其实枚举和迭代是一样的。
    
    因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。
    
    
10.ArryList示例
  

 import java.util.*;
/*
什么是迭代器呢？
    就是为了取出集合中元素的方式
    
*/
class CollectionDemo
{
    public static void main(String[] args)
    {
        method_get();
    }
    
    public static void sop(Object o)
    {
        System.out.println(o);    
    }
    
    /*
        取出集合元素
        使用迭代器iterator
    */
    public static void method_get()
    {
        ArrayList al = new ArrayList();
        
        al.add("hello 1");
        al.add("hello 2");
        al.add("hello 3");
        al.add("hello 4");
        sop("iterator1:");
        //获取集合al的迭代器,用于取出集合中的元素
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            sop(it.next());
        }
        sop("iterator2:");
        for(Iterator it2 = al.iterator();it2.hasNext();)
        {
            sop(it2.next());    
        }
    }
    
    public static void method_test()
    {
        //创建一个集合容器，使用Collection接口的子类，ArrayList
        ArrayList al = new ArrayList();
        
        //1.添加元素
        al.add("hello 1");
        al.add("hello 2");
        al.add("hello 3");
        al.add("hello 4");
        
        //打印集合
        sop("原来集合"+al);
        
        //2.获取集合长度
        sop(al.size());
        
        //3.删除元素
        al.remove("hello 2");
        sop(al.size());
        sop(al);
        //4.清空集合
        al.clear();
        //5.判断元素
        sop("是否存在hello 4"+al.contains("hello 4"));
        sop("集合是否为空？"+al.isEmpty());    
    }
}

11.ListDemo 示例

/*
    Collection
        ---List:元素有序，元素可以重复，因为该集合有索引
            ---ArryList:底层的数据结构使用的是数组结构。
                                    特点：在于查询元素快，但是增删稍慢。
                                    线程不同步。
                                    默认长度是10，超过此长度，在创建多于原先50%的数组，再将原数据copy到新数组当中
            ---LinkedList:底层使用的链表数据结构。
                                    特点：增删速度很快，查询速度慢
            ---Vector:底层是数组数据结构。出现在1.0的时代。被ArryList替代了                        
                                线程同步
                                100%加长
        ---Set：元素是无序，元素不可以重复
        
    List:
        特有方法，凡是可以可以操作角标的方法都是该体系特有的方法
    

*/
import java.util.*;
class ListDemo
{
    public static void main(String[] args)
    {
        //演示列表迭代器
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        sop(al);
        /*
            在迭代过程中，准备添加或者删除元素
            使用ListIterator
        */
        ListIterator it = al.listIterator();
        sop("------"+it.hasNext());
        sop("------"+it.hasPrevious());
        while(it.hasNext())
        {
            Object o = it.next();
            if(o.equals("java02"))
            {
                it.set("02java");
            }
            sop(o);//输出的还是原来的数据
        }
        sop(al);
        sop("------"+it.hasNext());
        sop("------"+it.hasPrevious());
    }
    
    public static void sop(Object o)
    {
        System.out.println(o);    
    }
    
    public static void method()
    {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        sop("原集合："+al);
        //指定位置添加元素
        al.add(1,"java09");
        sop("新集合："+al);
        //删除指定位置元素
        al.remove(1);
        sop("删除后:"+al);
        //修改元素
        al.set(2,"javahello");
        sop("修改元素"+al);
        //通过角标获取元素
        sop("获取一号元素"+al.get(1));
        //获取所有元素
        sop("获取所有元素");
        for(int x = 0;x<al.size();x++)
        {
            sop("al["+al.get(x)+"]");
        }
    
        //通过indexOf获取对象的位置
        sop("元素 javahello的位置："+al.indexOf("javahello"));
        //取子集
        sop("获取1到3的子集"+al.subList(1,3) );
    }
    
}

12.LinkedList 示例
 

  /*
    LinkedList：特有方法
    addFirst();
    addLast();
    
    getFirst();
    getLast();
    获取元素，但不删除元素，如果集合中没有元素，会出现NoSuchElementException
    
    removeFirst();
    removeLast();
    获取元素，但是元素被删除，如果集合中没有元素，会出现NoSuchElementException
    
    在JDK1.6出现了替代方法
    offerFirst();
    offerLast();
    
    peekFirst();
    peekLast();
    获取元素，但不删除，如果集合中没有元素，返回null
    
    pollFirst();
    获取元素，删除，如果集合中没有元素,返回null
    pollLast();
*/
import java.util.*;
class LinkedListDemo
{
    public static void main(String[] args)
    {
        LinkedList link = new LinkedList();
        link.addFirst("java01");
        link.addFirst("java02");
        link.addFirst("java03");
        link.addFirst("java04");
        sop(link);
        sop("首="+link.getFirst());
        sop("尾="+link.getLast());
        sop("size=="+link.size());
        //遍历元素
        while(!link.isEmpty())
        {
            //获取第一个元素，并移除。如果链表为空返回null
            sop(link.pollFirst());    
        }
        sop("size=="+link.size());
        //sop("删除头元素="+link.removeFirst());
        //sop("删除头元素="+link.removeFirst());
    }

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

13.    List集合判断元素是否相同，移除元素remove，依靠的是元素的equals方法。
14.Set集合的功能和Collection是一致的。
            HashSet:底层数据结构是哈希表
                    如何保证元素的唯一性呢？
                        是通过元素的两个方法，hashCode和equals来完成的
                        如果元素的hashCode值相同，才会判断equals是否为true
                        如果元素的hashCode值不相同，不会判断equals
                        
                        注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法
                        
15.使用HashSet存放自定义对象,一般都会自定义hashCode和equals方法。哈希值尽量唯一！        
        集合底层自己会调用这两个方法。