对象用于封装特有数据,对象多了需要存储,如果对象的个数不确定。就使用集合容器进行存储。
集合容器因为内部的数据结构不同,有多种具体容器。
不断的向上抽取,就形成了集合框架。
Collection框架图:
Collection
|--List: 可以存放有序的对象,并且对象可以重复
|--ArrayList: 底层实现是数组,查询效率要高(因为有索引下标),线程不安全,jdk1.2, 增长是50%(即如果越界,则底层数组增加原来的50%)
|--vector: 底层实现也是数组,线程安全,所以查询效率要比ArrayList要低,jdk1.0 出现
使用ArrayList来对我们的vector进行了升级,所以建议大家使用ArrayList; 100%增长(即如果越界,则底层数组增加原来的100%)
|--LinkedList: 底层实现是链表,查询效率要比ArrayList低
ArrayList: 查询快,增删慢
LinkedList: 查询慢,增删快
Vector: 两个都慢
|--Set: 存放的元素是没有顺序的,元素不能重复
List:
代码示例:
import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class MyArrayListDemo { public static void main(String[] args) { List list = new ArrayList(); //创建一个ArrayList对象list list.add("zhangsan"); //往list内添加元素 list.add("lisi"); list.add("wangwu"); printList(list); } public static void printList(List list) { Iterator itr = list.iterator(); //使用list的迭代器进行list内元素的遍历 while (itr.hasNext()) { //判断迭代器中是否还有元素 System.out.println(itr.next()); //如果迭代器有元素,则取出这个元素并打印 } } }
代码示例:
import java.util.Iterator; import java.util.LinkedList; import java.util.List; public class MyArrayListDemo { public static void main(String[] args) { LinkedList list = new LinkedList(); //创建一个LinkedList对象 list.add("zhangsan"); //往list内添加元素 list.add("lisi"); list.add("wangwu"); printList(list); } public static void printList(List list) { Iterator itr = list.iterator(); //使用list的迭代器进行list内元素的遍历 while (itr.hasNext()) { //判断迭代器中是否还有元素 System.out.println(itr.next()); //如果迭代器有元素,则取出这个元素并打印 } } }
代码示例:
import java.util.Enumeration; import java.util.Vector; public class MyArrayListDemo { public static void main(String[] args) { Vector vector = new Vector(); //创建Vector对象vector vector.addElement("zhangsan"); //往vector中添加对象 vector.addElement("lisi"); vector.addElement("wangwu"); printVector(vector); } /** * 这是Vector中特有的遍历方式。当然,也可以使用之前的迭代器方法遍历 * @param vector */ public static void printVector(Vector vector) { Enumeration elems = vector.elements(); //获取vector中所有元素 while (elems.hasMoreElements()) { //判断vector中是否还有元素 System.out.println(elems.nextElement()); //如果有,则打印这个元素 } } }
Set:
代码示例:
import java.util.Collection; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class MyArrayListDemo { public static void main(String[] args) { Set hashSet = new HashSet();//创建HashSet对象hashSet hashSet.add("java01");//往hashSet中添加对象 hashSet.add("java02"); hashSet.add("java02"); hashSet.add("java03"); sop(hashSet); } /** * set:set集合中的数据没有顺序(存入的顺序和取出后的顺序没有关系),没有重复的元素 * 只能使用Iterator的方式来遍历其中的元素 * |--HashSet:底层是有哈希表hash表来维护, */ public static void sop(Collection col) { Iterator it = col.iterator(); //使用col的迭代器 while(it.hasNext()) { //判断是否还有元素 System.out.println(it.next()); //如果有元素则取出打印 } } }
由于Set集合中数据没有顺序 ,所以打印结果不确定。
代码示例:
import java.util.Collection; import java.util.Iterator; import java.util.TreeSet; public class MyArrayListDemo { public static void main(String[] args) { TreeSet treeset = new TreeSet(); //初始化一个TreeSet对象treeset treeset.add("java03"); //往treeset中添加元素 treeset.add("java02"); treeset.add("java04"); treeset.add("java01"); sop(treeset); } /** * |--TreeSet:可以对我们Set集合进行排序。 * 用String做例子,我们发现,这种排序是对字符串进行的自然排序 */ public static void sop(Collection col) { Iterator it = col.iterator(); //使用col的迭代器 while(it.hasNext()) {//判断是否还有元素 System.out.println(it.next());//如果有元素则取出打印 } } }
打印结果为:
java01
java02
java03
java04
List比较两个元素相等,实际上比较的是元素的hashCode()和equals()方法。remove()/contains()都比较的是hashCode()和equals()方法。比较时程序会先比较hashCode(),若不同,则两个对象不同,若hashCode()相同,则继续比较equals()方法。
我们可以通过重写hashCode()和equals()方法,实现List判断是否存在相同的对象,例如Person(name,age)。
代码示例:
@Override public int hashCode() {//hashCode值定义为相同的值 System.out.println(this.name + "---------"); return name.hashCode() + age * 31; } @Override /** * obj : 要比较的对象 */ public boolean equals(Object obj) { if (obj == null) { return false; } if (!(obj instanceof Person)) { return false; } Person p = (Person) obj; return this.name.equalsIgnoreCase(p.name) && this.age == p.age; }
TreeSet中可以使用Comparable和Comparator来实现Set集合的排序。
Comparable和Comparator区别:
在jdk的位置:
使用场景:
import java.util.Collection; import java.util.Iterator; import java.util.TreeSet; public class MyArrayListDemo { public static void main(String[] args) { TreeSet tst = new TreeSet(); //初始化TreeSet对象tst tst.add(new Employee("zs06", 18)); //往tst中添加元素 tst.add(new Employee("zs02", 17)); tst.add(new Employee("zs03", 48)); tst.add(new Employee("zs01", 18)); tst.add(new Employee("zs02", 28)); tst.add(new Employee("zs01", 28)); sop(tst); } //打印集合内的元素 public static void sop(Collection col) { Iterator it = col.iterator(); while (it.hasNext()) { Employee p = (Employee) it.next(); System.out.println(p.getAge() + "\t" + p.getName()); } } } /** * 创建一个实现了Comparable接口比较器方法的Employee类 */ class Employee implements Comparable { private String name; private int age; public Employee() { } public Employee(String name, int age) { 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 //重写Comparable接口中的ComparaTo方法,使得Employee对象能够相互比较 public int compareTo(Object obj) { if (obj == null) { throw new RuntimeException("没有对象"); } if (!(obj instanceof Employee)) { throw new RuntimeException("不是同一种类型"); } Employee employee = (Employee) obj; int num = this.age - employee.age; //先按照年龄进行排序,如果相等,就再按照name的字典顺序排序 if (num == 0) { num = this.name.compareTo(employee.name); } return num; } }
import java.util.Collection; import java.util.Comparator; import java.util.Iterator; import java.util.TreeSet; public class MyArrayListDemo { public static void main(String[] args) { TreeSet tst = new TreeSet(new MyComParator()); //初始化TreeSet对象tst tst.add(new Employee("zs06", 18)); //往tst中添加元素 tst.add(new Employee("zs02", 17)); tst.add(new Employee("zs03", 48)); tst.add(new Employee("zs01", 18)); tst.add(new Employee("zs02", 28)); tst.add(new Employee("zs01", 28)); sop(tst); } public static void sop(Collection col) { Iterator it = col.iterator(); //通过使用迭代器打印出集合中的元素 while (it.hasNext()) { Employee employee = (Employee) it.next(); System.out.println(employee.getAge() + "\t" + employee.getName()); } } } class Employee { private String name; private int age; public Employee() { } public Employee(String name, int age) { 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; } } //通过实现Comparator接口构造一个比较器MyComparator class MyComParator implements Comparator { @Override public int compare(Object o1, Object o2) { Employee em1 = (Employee) o1; Employee em2 = (Employee) o2; int result = new Integer(em1.getAge()).compareTo(new Integer(em2.getAge())); //先比较年龄,如果年龄相同,则比较姓名 if (result == 0) { result = em1.getName().compareTo(em2.getName()); } return result; } }
/** * 使用LinkedList实现堆栈 */ class MyStack { private LinkedList list; //初始化堆栈 public MyStack() { list = new LinkedList(); } //存入数据 public void myPush(Object obj) { list.addLast(obj); } //取出数据 public Object myPop() { return list.removeLast(); //此处若改为list.removeFirst() ,则为队列结构 } //判断堆栈是否为空 public boolean isNull() { return list.isEmpty(); } }
框架的顶层Collection接口:
1,添加。
boolean add(Object obj): boolean addAll(Collection coll):
2,删除。
boolean remove(object obj): boolean removeAll(Collection coll); void clear();
3,判断:
boolean contains(object obj): boolean containsAll(Colllection coll); boolean isEmpty(): //判断集合中是否有元素。
4,获取:
int size(): Iterator iterator(): //取出元素的方式:迭代器。
该对象必须依赖于具体容器,因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言,具体的实现不重要,只要通过容器获取到该实现的迭代器的 对象即可,也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
5,其他:
boolean retainAll(Collection coll);//取交集。 Object[] toArray(): //将集合转成数组。
Collection
|--List:有序(存入和取出的顺序一致),元素都有索引(角标),元素可以重复。
|--Set:元素不能重复,无序。
有一个共性特点就是都可以操作角标。
1,添加
void add(index,element); void add(index,collection);
2,删除;
Object remove(index):
3,修改:
Object set(index,element);
4,获取:
Object get(index); int indexOf(object); int lastIndexOf(object); List subList(from,to);
1,添加: jdk1.6以后
addFirst(); offerFirst(); addLast(); offerLast();
2,获取: jdk1.6以后
getFirst(): peekFirst(); getLast(); peekLast();获取元素,集合的长度不改变。
如果集合中没有元素,那么该方法会发生异常NoSuchElementException
如果集合元素没有,该方法不会抛出异常,而是返回null。
3,删除: jdk1.6以后
removeFirst(): pollFirst(); removeLast(); pollLast();获取元素,但是该元素会被删除出集合,集合的长度会改变。
如果集合中没有元素,那么该方法会发生异常NoSuchElementException
如果集合元素没有,该方法不会抛出异常,而是返回null。
Vector已经不常用了,我们就说里面的一个方法,Elements方法。这个方法的返回值是枚举接口,里面有两个方法,判断和获取。
Vector中提供了一个独特的取出方式,就是枚举Enumeration。此接口Enumeration的功能与 Iterator 接口的功能是重复的。
Enumeration的名称和方法的名称过程,书写很麻烦。所以被Iterator所取代。
List:
2:数组和链表的区别
当向数组中插入一个元素的时候,插入位置后面的元素都要往后移一位。元素越多越慢。
如果是链表的话,插入一个新元素,只需要让插入的元素记住前一个元素的位置,后一个元素记住插入元素的位置即可,非常简单快速。
删除也特别简单,只需要让后一个元素记住前一个元素的位置即可。中间的元素就删掉了。
总结:
元素不可以重复,是无序。
Set接口中的方法和Collection一致。
注意:set集合取出元素的方法只有迭代器。
|--HashSet: 内部数据结构是哈希表 ,是不同步的。
如何保证该集合的元素唯一性:
记住:如果元素要存储到HashSet集合中,必须覆盖hashCode方法和equals方法。
一般情况下,如果定义的类会产生很多对象,比如人,学生,书,通常都需要覆盖 equals,hashCode方法。
建立对象判断是否相同的依据。
Set常用的子类是HashSet和TreeSet
应用场景:假设要存储的元素必须是唯一的,这个时候就可以使用set集合。