java简单的集合框架(一)

首先让我们看一下简单的集合框架的继承层次

collection

list(有序的容器 元素可以重复) Queue(队列)
set(无序的容器就是元素不可重复)

linkedList ArrayList Vector Deque PriorityQueue EnumSet
SortedSet HashSet

TreeSet

Collection(接口)是集合容器中非映射关系的容器类的根类。其中list和set 接口是最常用的接口。其中list有序指的遍历的结果与插入的顺序相同,set无序指的是插入的顺序与遍历的顺序不一定相同(因为在插入的时候，它会按照元素中ComparaTo()方法去完成排序,同时容器中的元素会按照某种关系将元素映射到一个HashMap中，这样可以实现快速遍历。)

1.ArrayList和Vector 的底层实现都是数组，可以通过下标索引来访问，这样可以提高查询效率，但是增删效率低。同时ArrayList的默认容量为10个元素，而且它的扩充容量为原来容量的（1.5倍+1）程序中的源代码为 int newCapacity = (oldCapacity * 3)/2 + 1;Vector的底层也为数组。它的默认容量也为10，但是在自动增长的时候，如果在构造函数中指定了增长的容量，则在增长的时候，它的容量会变成原来数组的容量+增长量，如果没有指定增长量，则会按照系统规定的2倍进行。所以在开发的过程当中，如果我们能估计容器中大约能盛放多少元素，我们应该在初始化的时候给他一个容量的大小。同时ArrayList是线程不安全的，Vector是线程安全的,但是ArrayList的性能比Vector的性能高。

2.LinkedList的底层实现为单链表,它查询效率低，但是增删效率高。

3.一般的遍历方式为用Iterator这个迭代器进行，这样遍历的时候效率是高的因为这样和遍历数组差不多，它是通过索引来实现的。

4.容器一般用来盛放对象的，在判断一个容器中是否包含某个对象以及在通过Equals()方法比较两个容器是否相同时，这时是根据容器中的对象元素来比较的。也就是放入容器中的对象必须实现equals()方法。

这是存放到容器中的对象定义，并且重写了Equals()方法。

public class Pet {

private String name;

private String color;

private int age;

public Pet(String name, String color, int age) {

this.name = name;

this.color = color;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getColor() {

return color;

}

public void setColor(String color) {

this.color = color;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

// TODO Auto-generated method stub

return "姓名:"+getName()+"颜色:"+getColor()+"年龄:"+getAge();

}

@Override

public boolean equals(Object obj) {

// TODO Auto-generated method stub

if(this==obj)

return true;

if((!(obj instanceof Pet)))

return false;

Pet pet=(Pet)obj;

if(this.age==pet.getAge()&&this.color.equals(pet.getColor())

&&this.name.equals(pet.getName()))

return true;

return false;

}

}

在主函数中的代码：

public class TestVector {

public static void main(String[] args) {

Pet pet0=new Pet("小白","红色",12);

Pet pet1=new Pet("小白","红色",13);

Pet pet2=new Pet("小白","红色",14);

Pet pet3=new Pet("小白","红色",16);

Pet pet4=new Pet("小白","红色",12);

ArrayList<Pet>arrayList=new ArrayList<Pet>();

arrayList.add(pet1);

arrayList.add(pet2);

arrayList.add(pet3);

arrayList.add(pet4);

boolean flag;

flag=arrayList.contains(pet0);

System.out.println("flag="+flag); //如果Pet重写了Equals()方法这时返回的是true，如果没有则会为false.因为Pet没有重写Equals()方法则会调用Object的Equals()方法。因为在比较的时候

//如果Pet没有重写Equals()则比较的是存放在数组中的地址，如果实现了则比较的是数组中元素的内容。

}

3.总结一下TreeSet 集合。

放入Treeset中的元素对象要么实现Comparable接口，要么不实现Comparable接口，在生成Treeset 容器的时候，在构造器中加入比较器。比较器相当于裁判，来实现排序作用的。TreeSet集合中元素的排序，

判断是否包含某个元素，等都是通过比较器来实现的。它的底层实现为二叉树。

下面的例子为插入到树结构的对象，是按照薪资大小，如果薪资大小一样则是按工龄大小来实现的排序。

public class Employee1 implements Comparable<Employee1>{

private int workAge;

private double salary;

public Employee1(int workAge, double salary) {

super();

this.workAge = workAge;

this.salary = salary;

}

public int getWorkAge() {

return workAge;

}

public void setWorkAge(int workAge) {

this.workAge = workAge;

}

public double getSalary() {

return salary;

}

public void setSalary(double salary) {

this.salary = salary;

}

@Override

public String toString() {

return "Employee [workAge=" + workAge + ", salary=" + salary + "]";

}

@Override

public int compareTo(Employee1 o) {

// TODO Auto-generated method stub

if(this.salary==o.getSalary()){

return

this.getWorkAge()-o.getWorkAge();

}else{

if(this.getSalary()>o.getSalary()){

return 1;

}else {

return -1;

}

}

}

}

public class TestTreeSet {

public static void main(String[] args) {

TreeSet employeeSet=new TreeSet();

employeeSet.add(new Employee1(34,20000.0));

employeeSet.add(new Employee1(35,20000.0));

employeeSet.add(new Employee1(35, 20000.2));

employeeSet.add(new Employee1(35,30000.0));

Iterator iterator=employeeSet.iterator();

Object obj=null;

while(iterator.hasNext()){

obj=iterator.next();

System.out.println(obj);

}

}

}

运行的结果为：

Employee [workAge=34, salary=20000.0]

Employee [workAge=35, salary=20000.0]

Employee [workAge=35, salary=20000.2]

Employee [workAge=35, salary=30000.0]

4.总结一下HashSet集合

HashSet的底层实现为HashMap,也就是说，放入集合中的元素，作为HashMap的键。由于键是唯一的，所以对应的HashSet集合也是唯一的，并且，HashMap的键值允许为空，所以集合中可以放入空元素。放入HashSet集合中的对象元素

一般重写hashCode()方法和equals()方法。重写hashCode()方法，比如在Student 类中，我们的hashCode()重写为

int hashCode()

{

return age;

}

这也就是说，年龄相同的对象元素放在同一个通中。在遍历输出的时候，在同一个桶中的元素会顺序遍历出来。就是年龄相同的对象顺序遍历出来。

public class Student {

private String name;

private int age;

public Student(String name, int age) {

super();

this.name = name;

this.age = 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;

}

@Override

public int hashCode() {

return age;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Student other = (Student) obj;

if (age != other.age)

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

@Override

public String toString() {

return "Student [name=" + name + ", age=" + age + "]";

}

}

public class testHashSet {

public static void main(String[] args) {

Student s1=new Student("徐才厚",18);

Student s2=new Student("徐财厚", 18);

Student s3=new Student("旺财", 18);

Student s4=new Student("徐才厚",19);

Student s5=new Student("徐财厚", 19);

Student s6=new Student("旺财", 19);

Student s7=new Student("徐才厚",20);

Student s8=new Student("徐财厚", 20);

Student s9=new Student("旺财", 20);

Student s0=null;

HashSet<Student>hashset=new HashSet<Student>();

hashset.add(s1);

hashset.add(s2);

hashset.add(s3);

hashset.add(s4);

hashset.add(s5);

hashset.add(s6);

hashset.add(s7);

hashset.add(s8);

hashset.add(s9);

hashset.add(s0);

Iterator<Student> set=hashset.iterator();

while(set.hasNext()){

Student st=set.next();

System.out.println(st);

}

}

}

输出结果：

null

Student [name=旺财, age=19]

Student [name=徐财厚, age=19]

Student [name=徐才厚, age=19]

Student [name=旺财, age=18]

Student [name=徐财厚, age=18]

Student [name=徐才厚, age=18]

Student [name=旺财, age=20]

Student [name=徐财厚, age=20]

Student [name=徐才厚, age=20]

总结： equals方法和hashcode方法

在容器中如果调用remove,contains等方法时，这会设计到对象类型的equals（）和hashcode()方法，对于自定义的类型，需要重写equals()方法和hashcode()方法,以实现自定的对象相等的规则。在Java中，俩个内容相同的对象应该具有相同的hashcode.所以如果两个对象的hashcode不相等，则两个对象的内容肯定不相等，这样就不用一个一个去比较属性值了，从而提高对象的比较速度。

有可能重写equals()方法和hashcode()方法的情况

1.要将我们自定义的对象放入HashSet中处理

2,。要将我们自定义的对象作为hashMap 的key处理。

3.放入Collection容器中的自定义对象后，可能会调用remove,contains等方法时。