黑马程序员——java学习8（166-179）——集合，Collection,List

1、集合

存储对象的方式

1.1、区别于数组

（1）集合长度可变，数组长度固定

（2）集合只能存对象，数组存储基本数据类型

同：存的都是地址，

1.2、CPUD

1.3、迭代器（内部类比作抓娃娃机，迭代过程比作爪子,爪子各不相同，功能有共性，都在机器内部）

 

集合取出元素的方式

import java.util.*;
class  CollectionDemo
{
    public static void main(String[] args) 
    {
        
        method_get();


    }
    public static void method_get()
    {
        ArrayList al=new ArrayList();
        al.add("java1");
        al.add("java2");
        al.add("java3");
        al.add("java4");

        /*
        Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素    接口不能创建对象，通过集合的iterator方法，返回迭代器。
        while(it.hasNext())
        {
            sop(it.next);
        }
        */
        for(Iterator it=al.iterator();it.hasNext();)
        {
            sop(it.next());
        }

    }
    public static void method_2()
    {
        ArrayList al1=new ArrayList();
        al1.add("java1");
        al1.add("java2");
        al1.add("java3");
        al1.add("java4");

        ArrayList al2=new ArrayList();
        al2.add("java1");
        al2.add("java2");
        al2.add("java5");
        al2.add("java6");
        
        //al1.retainAll(al2);//取交集，al1中只保留和al2中相同的元素
        al1.removeAll(al2);//去掉相同，留不同
        
        sop("al1:"+al1);
        sop("al2:"+al2);
    }
    public static void base_method()
    {
        //创建一个集合容器，使用Collection接口的子类，ArrayList
        ArrayList al=new ArrayList();

        //1、添加元素
        al.add("java1");//add(Object obj)
        al.add("java2");
        al.add("java3");
        al.add("java4");

        //打印原集合
        sop("原集合"+al);
        //3、删除元素
        //al.remove("java2");
        //al.clear();清空

        //4、判断元素
        sop("java03是否存在："+al.contains("java03"));
        sop("集合是否为空？"+al.isEmpty());
        //2、获取个数，集合长度
        sop("size:"+al.size());
        //打印改变后的集合
        sop(al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

Collection

　　|--List:元素有序，可以重复，因为该集合体有索引（下标）

　　　　|--ArrayList:底层的数据结构是数组结构，特点：查询速度快，增删慢，线程不同步

　　　　|--LinkedList:底层使用的是链表数据结构，特点：增删速度快，查询慢

　　　　|--Vector:底层是数组数据结构，线程同步，被ArrayList替代

　　|--Set:元素无序，元素不可以重复。

1.4、List

　　特有方法，凡是可以操作角标的方法都是该体系特有的方法

增

　　add(index,element);

　　addAll(index, Collection);

删

　　remove(index);

改

　　set(index,element)

查

　　get(index);　　　　

　　subList(from,to);

　　listIterator();

package learn;

 import java.util.*;
class  ListDemo
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void method()
    {
        ArrayList al=new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        
        
        sop("原集合是"+al);
        //在指定位置添加元素
        al.add(1,"java09");

        //删除指定位置元素
        //al.remove(2);
    
        //修改元素
        //al.set(2,"java07");

        //通过角标获取元素        
        //sop(al.get(1));
        //获取所有元素
        for(int x=0;x<al.size();x++)
        {
            sop("al("+x+")="+al.get(x));
        }
        Iterator it=al.iterator();
        while(it.hasNext())
        {
            sop("next:"+it.next());
        }
        //通过indexOf获取对象的位置
        sop("index="+al.indexOf("java02"));
        List sub=al.subList(1,3);
        sop("sub="+sub);
    }
    public static void main(String[] args) 
    {
        //演示列表迭代器
        ArrayList al=new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
    
        ListIterator li=al.listIterator();
        
        while(li.hasNext())
        {
            Object obj=li.next();
            if(obj.equals("java02"))
//                li.add("java09");
                li.set("java006");
        }
        while(li.hasPrevious())
        {
            sop("pre: "+li.previous());//逆向遍历
        }
//        sop("hasNext: "+li.hasNext());
//        sop("hasPrevious: "+li.hasPrevious());
        sop(al);
//        Iterator it=al.iterator();
//        
//        //在迭代过程中，准备添加或者删除元素
//        while(it.hasNext())
//        {
//            Object obj=it.next();
//            if(obj.equals("java02"))
////                al.add("java008");    //异常，有两个方法并发
//                it.remove();    //元素还是内存中，只是从集合中移除了地址
//            sop("obj="+obj);
//                
//        }
//        sop(al);
    }
}

1.4.1、ListIterator

 List集合特有迭代器 ListIterator是Iterator的子接口

在迭代时，不可通过集合对象的方法，操作集合中的元素，

因为会发生并发修改异常
ConcurrentModificationException异常

Iterator: 判断，取出，删除

ListIterator: 添加，修改

1.4.2、枚举

package learn;
import java.util.*;
/*
 * 枚举就是Vector特有的取出方式
 * 发现枚举和迭代器很像，因为枚举的名称以及方法的名称都过长
 * 所以被迭代器取代了
 * IO中会用到
 * */
public class VectorDemo {
    public static void main(String[] args) {
        Vector 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());
        }
        
    }
}

 LinkedList练习

package learn;

import java.util.LinkedList;

/*
 * 使用LinkedList模拟一个堆栈或者队列数据结构
 * 堆栈：先进后出，杯子
 * 队列：先进先出， first in first out FIFO,水管
 * */
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();
    }
    
    
}
public class LinkedListTest {
    public static void main(String[] args) {
        Duilie dl=new Duilie();
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");
        while(!dl.isNull())
        {
            System.out.println(dl.myGet());
        }
    }
}

package learn;

import java.util.LinkedList;
/*
 * LinkedList特有方法
 * addFirst()
 * addLast() ----offer
 * getFirst()
 * getLast()----peak   jdk1.6  没有则返回null
 * 获取元素，不删除
 * removeFirst()
 * removeLast()----poll
 * 获取元素，删除,若集合没元素会出现NoSuchElementException
 * */
public class LinkListDemo {
    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(link.removeFirst());
//        sop("size="+link.size());
        while(!link.isEmpty())
        {
            sop(link.removeLast());
        }
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

去除ArrayList集合中的重复元素

package learn;

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

/*
 * 去除ArrayList集合中的重复元素 
 * */
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList al=new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java01");
//        al.add("java03");
        /*
         * 在迭代器循环中next调用一次，就要hasNext判断一次
        Iterator it=al.iterator();
        while(it.hasNext())
        {
            sop(it.next()+"..."+it.next());
        }
        */
        sop(al);
        al=singleElement(al);
        sop(al);
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
        
    }
    public static ArrayList singleElement(ArrayList al)
    {
        ArrayList newal=new ArrayList();
        Iterator it=al.iterator();     //根据传递进来的arraylist创建迭代器，存放如全新的newal
        while(it.hasNext())
        {
            Object obj=it.next();
            if(!newal.contains(obj))
            {
                newal.add(obj);
            }
            
        }
        return newal;
    }
}

package learn;

/*
 *将自定义对象作为元素存到ArrayList集合中，并去除重复元素
 *比如:存入对象，同姓名，同年龄，视为同一个人，为重复元素 
 * */
import java.util.ArrayList;
import java.util.Iterator;

class Person{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    //Person的字符串方法
    public boolean equals(Object obj)
    {
        
        if(!(obj instanceof Person))
            return false;
        Person p =(Person)obj;
        System.out.println(this.name+"..."+p.name);
        //字符串的equals方法
        return this.name.equals(p.name)&& this.age==p.age;
        
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}


public class ArrayListTest2 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        
    
        ArrayList al=new ArrayList();
        al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj=new Person("lisi01",30);
        al.add(new Person("lisi02",32));
        al.add(new Person("lisi02",32));
        al.add(new Person("lisi03",33));
        al.add(new Person("lisi04",35));
        al.add(new Person("lisi04",35));
        
        al=singleElement(al);
        sop("remover 03:"+al.remove(new Person("lisi03",33)));
        Iterator it=al.iterator();
        while(it.hasNext())
        {
//            Object obj=it.next();
//            Person p=(Person)obj;
            Person p=(Person)it.next();
            sop(p.getName()+"..."+p.getAge());
        }
        
    }
    public static ArrayList singleElement(ArrayList al)
    {
        //定义一个临时容器
        ArrayList newal=new ArrayList();
        Iterator it=al.iterator();     //根据传递进来的arraylist创建迭代器，存放如全新的newal
        while(it.hasNext())
        {
            Object obj=it.next();
            if(!newal.contains(obj))//contains中含有equals
            {
                newal.add(obj);
            }
            
        }
        return newal;
    }
}

1.5、Set

1.5.1、HashSet

package learn;

import java.util.HashSet;
import java.util.Iterator;

//|--Set：无序(存入、取出顺序不一致)，元素不可重复
//        |--HashSet：底层数据结构是哈希表
//        |--HashSet是如何保证元素唯一性
            //通过元素的hashCode和equals
            //若元素HashCode值相同，才会判断equals是否为true
            //不同则不调
//注意，对于判断元素是否存在，以及删除操作，依赖的方法是，元素的hashcode（先）和equals方法
//set集合的功能时和Collection一致的
public class HashSetDemo {
    public static void sop(Object obj){
        System.out.println(obj);
    }
    public static void main(String[] args) {
        //按照地址存进去的
        HashSet hs = new HashSet();
        
        //添加失败
        sop(hs.add("java01"));    
        sop(hs.add("java01"));    
        hs.add("java01");
        hs.add("java01");
        hs.add("java02");
        hs.add("java03");
        hs.add("java04");
        Iterator it=hs.iterator();
        while(it.hasNext())
        {
            sop(it.next());
        }
    }
}

package Test;
import java.util.HashSet;
import java.util.Iterator;
/*
 * 往HashSet集合中存入自定义对象，姓名年龄相同视为重复对象
 * */
class Person{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public int hashCode()
    {
        System.out.println(this.name+"...hashCode");
        return name.hashCode()+age*39;//防止相加后的哈希值相同
    }
    //Person的字符串方法
    public boolean equals(Object obj)
    {
        
        if(!(obj instanceof Person))
            return false;
        Person p =(Person)obj;
        System.out.println(this.name+"...equals..."+p.name);
        //字符串的equals方法
        return this.name.equals(p.name)&& this.age==p.age;
        
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

public class HashSetTest {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        HashSet hs=new HashSet();
        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        hs.add(new Person("a2",12));
//        hs.add(new Person("a4",14));
        Iterator it=hs.iterator();
        while(it.hasNext())
        {
            Person p=(Person)it.next();
            sop(p.getName()+"..."+p.getAge());
        }
    }
}