day14 集合框架--ArrayList容器 linkedlist

集合框架：Collection

为什么会出现这么多的容器呢？
因为每一个容器对数据的存储方式都有不同，
这个存储方式称之为：数据结构


CollectionDemo

创建一个集合容器。使用Collection接口的子类，ArrayList


/*
1,add方法的参数类型是Object。以便于接受任意类型对象。
    
2，集合中存储的都是对象的引用(地址)

*/

import java.util.*;

class CollectionDemo
{
    public static void main(String[] args)
    {
        base_method();
        
    }
    
    public static void base_method()
    {
        
        //ArrayList al = new ArrayList();
        
        //1,添加元素
        //al.add("java01");
        //al.add("java02");
        //al.add("java03");
        //al.add("java04");
        //打印原集合
        //sop("scr:"+al);
        //清空
        //al.clear();
        
        //al.remove("java02");
        //获取元素个数，集合长度。
        //sop("size:"+al.size());
        //System.out.println("");
        //判断元素是否存在
        //sop(al.contains("java03"));
        
        //sop(al.isEmpty());//集合是否为空。
        
        sop(al);
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        
        ArrayList all = new ArrayList();
        all.add("java05");
        all.add("java06");
        all.add("java01");
        all.add("java02");
        
        al.retainAll(all);//取交集，al中只会保存于all中相同的元素。
        
        sop("al:"+al);
        sop("all:"+all);
        
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

 Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。

什么是迭代器呢？
其实就是集合的取出元素的方式。

就把取出方式定义在集合的内部，
这样取出方式就可以直接访问集合内容的元素。

那么取出方式就被定义成了内部类。

而每一个容器的数据结构不同，所以取出的动作细节也不一样。
但是都有共性内容判断和取出。那么可以将写共性抽取。

那么这些内部类都符合一个规则。该规则是Iterator
如何获取集合的取出对象呢

通过一个对外提供的方法。Iterator()；

import java.util.*;

class ListDemo
{
    public static void main(String[] args)
    {
        base_method();
        
    }
    
    public static void base_method()
    {
        ArrayList al = new ArrayList();
        
        
        al.add("java01");
        al.add("java02");
        al.add("java03");
        //al.add(1,"java09");
        //sop(al);
        
        //al.remove(2);
        //sop(al);
        //al.set(2,"java007");
        //sop("get:"+al.get(1));
        //sop("index="+al.indexOf("java02"));
        //List sub = al.subList(1,3);
        //sop("sub="+sub);
        ListIterator it = al.listIterator();
        
        while(it.hasNext())
        {
            Object obj = it.next();
            
            if(obj.equals("java02"))
                it.add("java09");
            
            
        }
        sop(al);
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

Collection
    　 |--List;元素是有序的，元素可以重复，因为该集合体系有索引。
        |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快，增删比较慢。线程不同步
            
        |--LinkedList ：底层的数据结构使用的是链表数据结构。特点：增删速度快，查询比较慢
        |--Vector  ：底层是数组数据结构。线程同步 被ArrayList替代。
    |--Set ；元素是无序的，元素不可以重复。
        |--HashSet
        |--TreeSet
    

list：
    特有方法：凡是可以操作角标的方法都是该体系特有的方法。
增
    add(index,element)
    addAll(index,Collection)
删
    remove(index)
改
    set(index,element)
查
    get(index)
    subList(from,to)
    listIterator()
    
    
List集合特有的迭代器：ListIterator 是Iterator的子接口

在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。
所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的
只能对元素进行判断，取出，删除的操作，
如果想要其他的操作如添加修改等，就需要使用起子接口，ListIterator。

该接口这能通过list集合的listiterator方法获取。

=========================================

枚举就是Vector 特有的取出方式

发现枚举和迭代器很像。
其实枚举和迭代是一样的。

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

 
 import java.util.*;
 
 class VectorDemo
 {
     public static void main(String[] args)
     {
         Vertor v = new Vector();
         
         v.add("java01");
         v.add("java02");
         v.add("java03");
         v.add("java04");
         
         Enumeration en = v.elements();
         
         while(en.hasMoreElements())
         {
             System.out.println(en.nextElement());
         }
         
         
     }
 } 

Linklist

LinkedList：特有方法：
=====================
addFirst()
addLast()
=====================
获取元素
getFirst()
getLast()
=====================
获取元素但是元素被删除，如果集合中没有元素，会返回NoSuchElementException
removeFirst()
removeLast()

在JDK1.6出现了替代方法，如果集合中没有元素，会返回NoSuchElementException

offerFirst()
offerLast()

peekFirst()
peekLast()
获取元素但是元素被删除,如果集合中没有元素，会返回null
pollFirst()
pollLast();
获取元素但是元素被删除,如果集合中没有元素，会返回null

 
 import java.util.*;
 
 class LinkedListDemo
 {
     public static void main(String[] args)
     {
         LinkedList v = new LinkedList();
         
         v.addFirst("java01");
         v.addFirst("java02");
         v.addFirst("java03");
         v.add-First("java04");
         
         
         sop(v);
     
     }
     public static void sop(Object obj)
    {
        System.out.println(obj);    
    }
         
 } 

练习：使用linkedlist模拟一个堆栈或队列数据结构

     
     import java.util.*;
     
     class LinkedListDemo
     {
         public static void main(String[] args)
         {
            duilie dl = new duilie();
            dl.myadd("java01");
            dl.myadd("java02");
            dl.myadd("java03");
            dl.myadd("java04");
         
            System.out.println(dl.myget());
         }
         public static void sop(Object obj)
        {
            System.out.println(obj);    
        }
             
     } 
    
    class duilie
    {
        private LinkedList link;
        duilie()
        {
            link = new LinkedList();
        }
        public void myadd(Object obj)
        {
            link.addFirst(obj);
        }
        public Object myget()
        {
            return link.removeLast();
        }
        public boolean isNull()
        {
            return link.isEmpty();
        }
    }

 练习：
去除arraylist集合中的重复元素。

     
     import java.util.*;
     
     class ArrayListTest
     {
         public static void main(String[] args)
         {
            ArrayList dl = new ArrayList();
            dl.add("java01");
            dl.add("java02");
            dl.add("java02");
            dl.add("java04");
         
            sop(dl);
            dl = singleElement(dl);
            
            sop(dl);
         }
         public static void sop(Object obj)
        {
            System.out.println(obj);    
        }
        public static ArrayList singleElement(ArrayList al)
        {
            ArrayList newal = new ArrayList();
            
            Iterator it = al.iterator();
            
            while(it.hasNext())
            {
                Object obj = it.next();
                if(!newal.contains(obj))
                    newal.add(obj);
            }
            return newal;
        }
             
     } 
    
    

练习：
将自定义对象作为元素存到ArrayList集合中，并去除相同元素。
比如 ：存人

同姓名同年龄是为同一个人。为同一个人。

list集合判断元素是否相同，调用contains函数，这函数依据的元素的equals方法。

     
     import java.util.*;
     
      
     class person
     {
         private  String name ;
         private  int age;
         
         person(String name,int age)
         {
             this.name=name;
             this.age=age;
         }
         
         
         public String getname()
         {
             return name;
         }
         public int getage()
         {
             return age;
         }
         public boolean equals(Object obj)
         {
             if(!(obj instanceof person))
                 return false;
             person p  =(person)obj;
             
             return this.name.equals(p.name)&&this.age == p.age;
         }
         
     }
    
    
     class ArrayListTest
     {
         public static void main(String[] args)
         {
            ArrayList dl = new ArrayList();
            dl.add(new person("lisi01",30));
            dl.add(new person("lisi02",32));
            dl.add(new person("lisi02",32));
            dl.add(new person("lisi03",33));
            dl.add(new person("lisi04",35));
            dl.add(new person("lisi04",35));
            
            dl=singleElement(dl);
            
            Iterator it = dl.iterator();
            
            while(it.hasNext())
            {
                person p = (person) it.next();//Object obj = it.next(); person p = (person) obj;
                sop(p.getname()+":...:"+p.getage());
            }
         }
         public static void sop(Object obj)
        {
            System.out.println(obj);    
        }
        public static ArrayList singleElement(ArrayList al)
        {
            ArrayList newal = new ArrayList();
            
            Iterator it = al.iterator();
            
            while(it.hasNext())
            {
                Object obj = it.next();
                if(!newal.contains(obj))
                    newal.add(obj);
            }
            return newal;
        }
             
     } 
    
    

 
|--Set ；元素是无序的(存入和取出的顺序不一定一致)，元素不可以重复。
        |--HashSet：底层数据结构是哈希表
            HashSet是如何保证元素唯一性呢
            是通过元素的两个方法，hashCode和equals来完成的
            如果元素的HashCode值相同，才会判断equals是否为true
            如果元素的hashcode值不同，不会调用equals
            
            注意，对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法
            
        |--TreeSet
        
Set集合的功能和Collection是一致的。

往hashset集合中存入自定义对象
姓名和年龄相同为同一个，重复元素。
      set练习：

import java.util.*;



     class person
     {
         private  String name ;
         private  int age;
         
         person(String name,int age)
         {
             this.name=name;
             this.age=age;
         }
         public int hashCode()
        {
            return 30;
        }
         
         public String getname()
         {
             return name;
         }
         public int getage()
         {
             return age;
         }
         public boolean equals(Object obj)
         {
             if(!(obj instanceof person))
                 return false;
             person p  =(person)obj;
             
             return this.name.equals(p.name)&&this.age == p.age;
         }
         
     }            
class HashSetDemo
{
    
    public static void main(String[] args)
    {
        HashSet hs = new HashSet();
        hs.add(new person("java01",11));
        hs.add(new person("java02",12));
        hs.add(new person("java02",12));
        hs.add(new person("java03",13));
        hs.add(new person("java04",14));
        
        Iterator it = hs.iterator();
        
        while(it.hasNext())
        {
            person p = (person)it.next();
            sop(p.getname()+"::"+p.getage());
        }
    }
    
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}