java中的集合

Java集合中的Set接口和List接口都是从Collection接口派生出来的。

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引来访问List中的无素，这类似于Java的数组。

HashSet采用哈希表存储结构，特点是查询速度快，但是其中元素无序排列。

TreeSet存的数据是无序号的，不能通过get的方法获得里面的数据。

Iterator接口可以遍历任何Collection接口的实现类，可以从一个Collection中使用iterator( )方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。

1. 集合和数组的比较

数组的长度是固定的，而集合的是动态的。
·从储存结构上来讲：数组是顺序储存结构 而集合有顺序储存结构的也有

链式储存结构的
·从两者储存的上讲：数组只能储存一类数据类型 而集合储存的数据类型

是Object的

2. 简述List、Set、Collection、Map的区别和联系。

Collection 接口的接口  对象的集合
·List  接口     按进入先后有序保存  可重复
·Set   子接口      仅接收一次，并做内部排序

Map      接口     键值对的集合

3. ArrayList和LinkedList的区别和联系。

 1. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表

的数据结构。
  2. 对于随机访问get和set，ArrayList觉得优于LinkedList，因为

LinkedList要移动指针。
  3. 对于新增和删除操作add和remove，LinedList比较占优势，因为

ArrayList要移动数据
ArrayList
优点;遍历元素和随机访问元素的效率比较高
缺点：添加和删除需要大量移动元素根据内容查找效率低
LinkedList
优点：插入、删除元素时效率高
缺点：遍历和随机访问元素效率低

4. HashSet采用了哈希表作为存储结构，请说明哈希表的特点和实现原理。

提示：结合Object类的hashCode()和equals()说明其原理

HashSet：equals返回true，hashCode返回相同的整数；哈希表；存储的

数据是无序的。成员可为任意Object子类的对象，但如果覆盖了equals方

法，同时注意修改hashCode方法。
HashMap键成员可为任意Object子类的对象，但如果覆盖了equals方法，

同时注意修改hashCode方法。
特点：
·访问速度快
·大小不受限制
·按键进行索引，没有重复对象
·用字符串(id:string)检索对象(object)
基本原理：我们使用一个下标范围比较大的数组来存储元素。可以设计一

个函数（哈希函数， 也叫做散列函数），使得每个元素的关键字都与一个

函数值（即数组下标）相对应，于是用这个数组单元来存储这个元素；也

可以简单的理解为，按照关键字为每一 个元素“分类”，然后将这个元素

存储在相应“类”所对应的地方。
但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可

能出现对于不同的元素，却计算出了相同的函数值，这样就产生了“冲突

”，换句话说，就是把不同的元素分在了相同的“类”之中。后面我们将

看到一种解决“冲突”的简便做法。

下面是一道例题

1. 使用HashSet和TreeSet存储多个商品信息，遍历并输出；其中商品属性：编号，名称，单价，出版社；要求向其中添加多个相同的商品，验证集合中元素的唯一性。

提示：向HashSet中添加自定义类的对象信息，需要重写hashCode和equals( )

 向TreeSet中添加自定义类的对象信息，需要实现Comparable接口，指定比较规则

package com.ArrayList;

public class Book implements Comparable<Book>{
    public int id;//编号
    public String name;//名称
    public double price;//单价
    public String press;//出版社
    public Book(){    
    }
    public Book(int id, String name, double price, String

press) {
        super();
        this.id = id;
        this.name = name;
        this.price = price;
        this.press = press;
    }
    
    @Override
    public int compareTo(Book o) {
        return this.id-o.id;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0

: name.hashCode());
        result = prime * result + ((press == null) ? 0

: press.hashCode());
        long temp;
        temp = Double.doubleToLongBits(price);
        result = prime * result + (int) (temp ^ (temp

>>> 32));
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (press == null) {
            if (other.press != null)
                return false;
        } else if (!press.equals(other.press))
            return false;
        if (Double.doubleToLongBits(price) != Double
                .doubleToLongBits

(other.price))
            return false;
        return true;
    }
    public String toString(){
        return "Book[编号："+id+"\t书名："+name+"\t出

版社："+press+"\t价格："+price+"]";    
    }
}


package com.ArrayList;

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class TestSet{
public static void main(String[] args) {
       Book b=new Book(1000,"b1",30,"bjsxt");
       Book b1=new Book(1001,"b1",40,"bjsxt");
       Book b2=new Book(1002,"b2",50,"bjsxt");
       Book b3=new Book(1003,"b3",60,"bjsxt");
       Book b4=new Book(1004,"b4",70,"bjsxt");
       Book b5=new Book(1005,"b5",80,"bjsxt");
       //使用HashSet存储图书并遍历
       Set<Book> hashSet=new HashSet<Book>();
       hashSet.add(b);
       hashSet.add(b1);
       hashSet.add(b2);
       hashSet.add(b3);
       hashSet.add(b4);
       hashSet.add(b5);
       System.out.println("遍历输出hashSet");
       System.out.println(hashSet.size());
       for(Book book:hashSet){
           System.out.println(book.toString());
       }
     //使用TreeSet存储图书并遍历
       Set<Book> treeSet=new TreeSet<Book>();
       treeSet.add(b);
       treeSet.add(b1);
       treeSet.add(b2);
       treeSet.add(b3);
       treeSet.add(b4);
       treeSet.add(b5);
       System.out.println("遍历输出treeSet");
       System.out.println(hashSet.size());
       for(Book book:treeSet){
           System.out.println(book.toString());
       }
   }
    
}

从结果可以看出不同