------
Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
集合框架
一、集合类概述
1、为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象 最常用的一中方式。
2、数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但是长度是固定的；集合长度是可变的，数组中可以存储基本数据类型，集合只能存储对象。
3、集合的特点
集合用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
4、集合框架
Collection
|--List
|--ArrayList
|--LinkedList
|--Vector
|--Set
|--HashSet
|--TreeSet
为什么出现这么多的容器呢？
因为每一个容器对数据的存储方式都不同。
这个存储方式称之为：数据结构
5、迭代器
其实就是集合的取出元素的方式。
因为是操作集合的元素，所以就把这种方式定义在集合内部，这样取出方式就可以直接访问集合内容的元素。那么取出方 式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容：判断和取出。那么可以将这些共性抽 取。
那么这些内部类都符合一个规则。该规则就是Iterator。
如何获取集合的取出对象呢？
通过一个对外提供的方法。iterator();
共性方法演示：
<span style="font-size:18px;">import java.util.*; /* 1.add方法的参数类型是Object，以便于接收任意类型对象。 2.集合中存储的都是对象的引用（地址） */ class CollectionDemo { public static void main(String[] args) { method_get(); } public static void method_get() { ArrayList al = new ArrayList(); al.add("java01");//add(Object obj); al.add("java02"); al.add("java03"); al.add("java04"); /* Iterator it = al.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("java01");//add(Object obj); al1.add("java02"); al1.add("java03"); al1.add("java04"); ArrayList al2 = new ArrayList(); al2.add("java03");//add(Object obj); al2.add("java04"); al2.add("java05"); al2.add("java06"); //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("java01");//add(Object obj); al.add("java02"); al.add("java03"); al.add("java04"); //打印集合 sop("原集合："+al); //3.删除元素。 //al.remove("java02"); //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); } }</span>
二、List
Collection
|--List:元素是有序的，元素可以重复，因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的数组结构。特点：查询速度很快，但增删很慢，线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删的速度很快，查询很慢
|--Vector:底层是数组数据结构。特点：线程同步。被ArrayList替代了。
|--Set：元素是无序的，元素不可以重复，该集合没有索引。
List:
特有方法，凡事可以操作角标的方法都是该体系特有的方法。
1、增
add(index,element)在列表的指定位置插入指定元素（可选操作）。
addAll(index,Collection)将指定 Collection 中的所有元素都插入到列表中的指定位置（可选操作）。
2、删
remove(index)移除列表中指定位置的元素（可选操作）。
3、改
set(index,element) 用指定元素替换列表中指定位置的元素（可选操作）。
4、查
get(index)返回列表中指定位置的元素。
subList(from,to)回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
listIterator();返回此列表元素的列表迭代器（按适当顺序）。
5、List集合特有的迭代器。ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。
所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的。只能对元素进行判断、取出、删除的操 作。如果想要其他的操作如：添加、修改等。就需要使用其子接口ListIterator。
该接口只能通过List集合的ListIterator方法获取。
演示：
import java.util.*; class ListDemo { 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,"java007"); //通过角标获取元素 sop("get(1):"+al.get(1)); //遍历获取所有元素 for(int x=0;x<al.size();x++) { System.out.println("al("+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); sop(al); } public static void main(String[] args) { //演示列表迭代器。 ArrayList al = new ArrayList(); //添加元素 al.add("java01"); al.add("java02"); al.add("java03"); sop(al); ListIterator li = al.listIterator(); //sop("hasPrevious():"+li.hasPrevious()); while(li.hasNext()) { Object obj = li.next(); if(obj.equals("java02")) //li.add("java009"); li.set("java006"); } //逆向遍历集合元素 while(li.hasPrevious()) { sop("hasPrevious():"+li.hasPrevious()); } sop(al); /* //在迭代过程中，准备添加或者删除元素。 Iterator it = al.iterator(); while(it.hasNext()) { //sop("next:"+it.next()); Object obj = it.next(); if(obj.equals("java02")) //al.add("java008"); it.remove();//将java02的引用从集合中删除了。 sop("obj="+obj); } sop("hasNext():"+li.hasNext()); sop(al); */ } public static void sop(Object obj) { System.out.println(obj); } }
三、Vector特有的方法
枚举就是Vector特有的取出方式。发现枚举跟迭代器很像。
其实枚举跟迭代是一样的。因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。枚举郁郁而终了。
演示：
class VectorDemo { public static void main(String[] args) { Vector v = new Vector(); v.add("java01"); v.add("java02"); v.add("java03"); v.add("java04"); <span style="white-space:pre"> </span>//枚举 Enumeration en = v.elements(); while(en.hasMoreElements()) { sop(en.nextElement()); } } public static void sop(Object obj) { System.out.println(obj); } }
四、LinkedList
1、LinkedList:特有方法
addFirst();将指定元素插入此列表的开头。
addLast();将指定元素添加到此列表的结尾。
————————————————————
getFirst();返回此列表的第一个元素。
getLast();返回此列表的最后一个元素。
获取元素，但不删除元素。
————————————————————
removeFirst();移除并返回此列表的第一个元素。
removeLast(); 移除并返回此列表的最后一个元素。
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();在此列表的开头插入指定的元素。
offerLast();在此列表末尾插入指定的元素。
peekFirst();获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
peekLast(); 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
获取元素，但不删除元素。如果集合中没有元素，会返回null
pollFirst();获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
pollLast();获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
获取元素，但是元素被删除。如果集合中没有元素，会返回null
示例：
class LinkedListDemo { 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("size="+link.size()); //sop(link.removeFirst()); //sop("size="+link.size()); //sop(link); while(!link.isEmpty()) { sop(link.removeFirst()); } } public static void sop(Object obj) { System.out.println(obj); } }
练习：
/* 使用Linkedlist模拟一个堆栈或者队列数据结构。 堆栈：先进后出 如同一个杯子 队列：先进先出 如同一个水管。 */ import java.util.*; class DuiLie { private LinkedList link; DuiLie() { link = new LinkedList(); } public void myAdd(Object obj) { link.addFirst(obj); } public Object myGet() { //队列 return link.removeLast(); //堆栈 return link.removeFirst(); } public boolean isNull() { return link.isEmpty(); } } 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()); } } public static void sop(Object obj) { System.out.println(obj); } }
五、ArrayList集合练习
练习1:
import java.util.*; /* 去除ArrayList集合中的重复元素。 */ 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); sop(singleElement(al)); } public static ArrayList singleElement(ArrayList al) {<span style="white-space:pre"> </span> ArrayList newAl = new ArrayList(); Iterator it = al.iterator(); while(it.hasNext()) { Object obj = it.next(); if(!newAl.contains(obj)) newAl.add(obj); } return newAl; } public static void sop(Object obj) { System.out.println(obj); } }
练习2:
import java.util.*; /* 将自定义对象作为元素存到ArrayList集合中，并去除重复元素。 比如：存人对象。同姓名同年龄，视为同一个人，为重复元素。 思路： 1.对人描述，将数据封装进入对象。 2.定义容器，将人存入 3.取出。 List集合判断元素是否相同，依据的是元素的equals方法。 */ class Person { private String name; private int age; Person(String name,int age) { this.name = name; this.age = age; } public boolean equals(Object obj) { if(!(obj instanceof Person)) return false; Person p = (Person)obj; return this.name.equals(p.name) && this.age==p.age; } public String getName() { return name; } public int getAge() { return age; } } class ArrayListTest2 { public static void main(String[] args) { ArrayList al = new ArrayList(); <span style="white-space:pre"> </span>//al.add(Object obj);//Object obj = new Person(); al.add(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); Iterator it = al.iterator(); while(it.hasNext()) { //Object obj = it.next(); //Person p = (Person)obj; //getName()与getAge()是Person类中的方法，所以要向下转型。 Person p = (Person)it.next(); sop(p.getName()+"::"+p.getAge()); } } public static ArrayList singleElement(ArrayList al) { ArrayList newAl = new ArrayList(); Iterator it = al.iterator(); while(it.hasNext()) { Object obj = it.next(); //自动调用equals方法 if(!newAl.contains(obj)) newAl.add(obj); } return newAl; } public static void sop(Object obj) { System.out.println(obj); } }
六、Set集合
|--Set:元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。
|--HashSet:底层数据结构是哈希表。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成的。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashCode值不同，不会调用equals。
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法
|--TreeSet
Set集合的功能和Collection是一致的。
class HashSetDemo { public static void main(String[] args) { HashSet hs = new HashSet(); hs.add("java01"); hs.add("java01"); hs.add("java02"); hs.add("java03"); hs.add("java03"); hs.add("java04"); Iterator it = hs.iterator(); while(it.hasNext()) { sop(it.next()); } } public static void sop(Object obj) { System.out.println(obj); } }
练习：
import java.util.*; /* 往HashSet集合中存入自定义对象。 姓名和年龄相同为同一个人，重复元素。 */ class HashSetTest { 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("a2",12)); hs.add(new Person("a3",13)); // hs.add(new Person("a4",14)); //先判断哈希值，再判断equals //sop("a1:"+hs.contains(new Person("a1",11))); hs.remove(new Person("a3",13)); Iterator it = hs.iterator(); while(it.hasNext()) { Person p = (Person)it.next(); sop(p.getName()+"::"+p.getAge()); } } public static void sop(Object obj) { System.out.println(obj); } } 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"); //产生独有的hashCode,*39是为了避免重复 return name.hashCode()+age*39; } public boolean equals(Object obj) { if(!(obj instanceof Person)) return false; Person p = (Person)obj; System.out.println(this.name+"...equals.."+p.name); return this.name.equals(p.name) && this.age==p.age; } public String getName() { return name; } public int getAge() { return age; } }
七、TreeSet
Set集合常用子类对比：
|--HashSet:数据结构是哈希表，线程是非同步的。
保证元素唯一性的原理：判断元素的hashCode值是否相同。
如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet:可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据compareTo方法return 0.元素相同
1、TreeSet排序的第一种方式，让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法。这种方式称为元素的自然排序，或者叫做默认排序
需求： 往TreeSet集合中存储自定义对象学生。 想按照学生的年龄进行排序。 记住：排序时，当主要条件相同时，一定要判断次要条件。 */ class TreeSetDemo { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Student("lisi02",22)); ts.add(new Student("lisi007",20)); ts.add(new Student("lisi09",19)); ts.add(new Student("lisi08",19)); Iterator it = ts.iterator(); while(it.hasNext()) { Student stu = (Student)it.next(); System.out.println(stu.getName()+"...."+stu.getAge()); } } public static void sop(Object obj) { System.out.println(obj); } } class Student implements Comparable//让接口强制让给学生具备比较性。 { private String name; private int age; Student(String name,int age) { this.name = name; this.age = age; } public int compareTo(Object obj) { if(!(obj instanceof Student)) throw new RuntimeException("不是学生对象"); Student s = (Student)obj; System.out.println(this.name+"..compareto..."+s.name); if(this.age>s.age) return 1; if(this.age==s.age) { return this.name.compareTo(s.name); } return -1; } public String getName() { return name; } public int getAge() { return age; } }
2、TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。在集合初始化时，就有 了比较方式。就定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
TreeSet(Comparator<? super E> comparator)
构造一个新的空 TreeSet，它根据指定比较器进行排序。
当两种排序都存在时，以比较器为主。
定义一个类，实现comparator接口，覆盖compare方法。
示例：
import java.util.*; class Student implements Comparable//让接口强制让给学生具备比较性。 { private String name; private int age; Student(String name,int age) { this.name = name; this.age = age; } public int compareTo(Object obj) { if(!(obj instanceof Student)) throw new RuntimeException("不是学生对象"); Student s = (Student)obj; System.out.println(this.name+"..compareto..."+s.name); if(this.age>s.age) return 1; if(this.age==s.age) { return this.name.compareTo(s.name); } return -1; } public String getName() { return name; } public int getAge() { return age; } } class TreeSetDemo2 { public static void main(String[] args) { TreeSet ts = new TreeSet(new MyCompare()); ts.add(new Student("lisi02",22)); ts.add(new Student("lisi007",20)); ts.add(new Student("lisi09",19)); ts.add(new Student("lisi08",19)); ts.add(new Student("lisi007",29)); Iterator it = ts.iterator(); while(it.hasNext()) { Student stu = (Student)it.next(); System.out.println(stu.getName()+"...."+stu.getAge()); } } public static void sop(Object obj) { System.out.println(obj); } } //比较器 class MyCompare implements Comparator { public int compare(Object o1,Object o2) { Student s1 = (Student)o1; Student s2 = (Student)o2; int num = s1.getName().compareTo(s2.getName()); if(num==0) { //将年龄封装成对象 return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); /*if(s1.getAge()>s2.getAge()) return 1; if(s1.getAge()==s2.getAge()) return 0; return -1;*/ } return num; } }
1397
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
