集合框架（02）List

List的类型和特点：

 

  ArrayList：底层的数据结构使用的是数组结构。特点：查询的速度很快，但是增删稍慢 线程不同步

  LinKedList：底层使用的链表数据结构。特点：增删的速度很快，查询稍慢

  Vector：底层是数组数据结构，线程同步，被ArrayList替代.特点：枚举是Vector特有的取出方式

枚举

.其实枚举和迭代是一样的，因为枚举的名称以及方法都过长，所以被迭代器取代了，枚举郁郁而终了

LinkedList：

LinkedList:特有的方法  addFirst(),addLast(), getFirst(), getLast(),. removeFirst(), removeLast()

removeFirst():移除并返回第一个元素，如果此列表为空则抛出NoSuchElementException异常

poolFirst()：获取并移除此列表的第一个元素，如果此列表为空，则返回null，不抛异常

在JDK1.6出现了替代方法。

 

offerFirst() , offerLast() , peekFirst() ,peekLast() , pollFirst () , pollLast()

LinkedList方法代码：

package sxy.List;

import java.util.LinkedList;

public class LinkedListDemo {

    public static void main(String[] args){
        
        LinkedList link1= new LinkedList();
        link1.addFirst("apple1");
        link1.addFirst("apple2");
        link1.addFirst("apple3");
        link1.addFirst("apple4");
        
        sop(link1);
        
        //“遍历”
        while(!link1.isEmpty()){
            System.out.println(link1.removeFirst());
        }
    }
    
    public static void sop(Object obj){
        System.out.println(obj);
    }

}

 

使用LinkedList模拟一个堆栈或者队列的数据结构。

堆栈：先进后出

队列：先进先出  First In First Out FIFO

典型例子（熟记）：

package sxy.List;

import java.util.LinkedList;

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 LinkedListDemo2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        DuiLie dl = new DuiLie();
        dl.myAdd("apple1");
        dl.myAdd("apple2");
        dl.myAdd("apple3");
        dl.myAdd("apple4");
        
        while(!dl.isNull()){
            System.out.println(dl.myGet());
        }
        

    }
    

}

 去掉ArrayList的中重复的元素：

package sxy.List;

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

public class TestArrayList {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    
        //去除ArrayList中的重复元素
        ArrayList al = new ArrayList();
        al.add("apple1");
        al.add("apple2");
        al.add("apple3");
        al.add("apple3");
        al.add("apple3");
        al.add("apple4");
        //打印原集合
        sop(al);
        //打印去重之后的集合
        al = SingleElement(al);
        sop(al);

    }
    public static  void sop(Object obj){
        System.out.println(obj);
    }
    
    public static ArrayList SingleElement(ArrayList al){
        ArrayList al2 = new ArrayList();
        Iterator it = al.iterator();
        
        while(it.hasNext()){
            Object obj = it.next();
            if(!al2.contains(obj)){
                al2.add(obj);
            }
        }
        return al2;
    }

}

 去除ArrayList中重复自定义对象：

将自定义对象作为元素存到ArrayList集合中，并除去重复元素

比如：存人对象。同姓名同年龄，视为同一个人。为重复元素

思路：

1. 对人描述，将数据封装进人对象
2. 定义容器，将人存入。
3. 取出 、

package CollectionTest;

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

class Person{
    private String name;
    private int 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;
    }
    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    Person(){
        
    }
    
    @Override
    public boolean equals(Object obj) {//重写equals方法
        Person per = (Person) obj;
        if (per.getName().equals(this.name) && per.getAge() == this.age) {
            return true;
        }
        return false;
    }
}

public class ArrayListDemo2 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<Person> al = new ArrayList();
        al.add(new Person("lisi1",10));
        al.add(new Person("lisi2",20));
        al.add(new Person("lisi2",20));
        al.add(new Person("lisi3",30));
        al.add(new Person("lisi4",40));
        al.add(new Person("lisi4",40));
        
        al=SingleElement(al);
        Iterator it = al.iterator();
        while(it.hasNext()){
            //向下转型
             Person p = (Person) it.next();
             System.out.println(p.getName()+"::"+p.getAge());
        }

    }
    public static ArrayList SingleElement(ArrayList al){
        ArrayList arrNew = new ArrayList();
        Iterator it = al.iterator();
        while(it.hasNext()){
            Object obj = it.next();
            //在调用contains方法的时候调用equals方法
            if(!arrNew.contains(obj)){
                arrNew.add(obj);
            }
        }
        return arrNew;
    }

}

equals和contains方法的区别：

最近用到了equals和contains两个方法，两个都有对比的意思，但区别呢？在网上找了些资料，似乎大概能分清了。
首先是文档上的内容：

public boolean equals(Object ob指示其他某个对象是否与此对象“相等”。

equals 方法在非空对象引用上实现相等关系：
  ● 自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
  ● 对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。
  ● 传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回true。
  ● 一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。
  ● 对于任何非空引用值 x，x.equals(null) 都应返回 false。
Object 类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。
注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
参数：
obj - 要与之比较的引用对象。
返回：
如果此对象与 obj 参数相同，则返回 true；否则返回 false。
contains
public boolean contains(CharSequence s)
当且仅当此字符串包含指定的 char 值序列时，返回 true。
参数：
s - 要搜索的序列
返回：
如果此字符串包含 s，则返回 true，否则返回 false
抛出：
NullPointerException - 如果 s 为 null
似乎有些难懂，尤其是equals的解释，下面是网友的解释内容：
equals是比较两个东西是否等同，这个适用于任何类别的对象
contains是是否包含的意思，那肯定.左边的对象是一个容器了
String现在也有一个contains，那是因为String是一个字符的容器
equals只能判断两个变量的值是否相等。
contains常用与集合中判断某个对象是否含有这个元素

 l

List集合判断元素是否相同，依据的元素的equals方法

频繁的增删操作是LinkedList

Set:元素师无序的（存入和取出的顺序不一定一致），元素不可以重复

Set集合的功能和Collection是一致的

 ------HashSet:底层数据结构是哈希表

            是如何保证元素的唯一性的呢？

            是通过元素的两个方法，hashCode和equals来完成。如果元素的HashCode值相同，才会判断equals是否为true，如果元素的HashCode的值不相同，不会调用equals

 ------TreeSet：