|
集合框架2
集合框架2是相对于集合框架概述而且的，内容上前后衔接。
1.迭代器
迭代器：集合的取出元素的方法。
注意：打印只能看到元素，并不能操作集合中的元素。
集合吧取出方式定义在集合的内部，这样取出方式就定义成了内部类。每一个容器的数据结构不同，所取出的动作细节也不一样。但是都有共性内容：判断和取出。那么可以将内容进行共性抽取。
这些内部类都符合一个规则。该规则是Iterator。如何获取集合中对外取出的对象呢？
通过一个对外提供的方法iterator()。
2.List
元素是有序的，元素可以重复，因为该集合体系有索引。
凡是可以操作角标的方法都是该体系特有的方法。
Iterator在迭代式，一般能移除集合中元素，但不可以通过集合对象的方法操作集合中的元素，因为胡出现并发修改异常（注意，是集合的方法，要和迭代器的方法区分开来）
List有自己特有的迭代器ListIterator，可以进行添、删、修改元素，（注意是ListIterator的方法）
这里Collection的一般方法就不演示了。
package CSDN.review;
import java.util.*;
public class IteratorDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("sdfe");
list.add("jxofi");
for(Iterator<String> it=list.iterator();it.hasNext();){
System.out.println(it.next());
}
System.out.println("________________");
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
//list的特有方法
list.add(1, "bc");
List<String> list2=list.subList(0, 3);
//包含头不包含尾
System.out.println(list2);
//特有迭代器
ListIterator<String> li= list.listIterator();
//产生迭代器时，指针指向第一个元素
while(li.hasNext()){
System.out.println("特有迭代器"+li.next());
}
// while(li.hasNext()){
// System.out.println("特有迭代器"+li.next());
// }再跌打一次，因为指针已经指向结尾所以不会打印
while(li.hasPrevious()){
System.out.println("逆向迭代"+li.previous()); //注意指针指向
}
//li的修改操作
for(;li.hasNext();){
Object obj= li.next();
if("bc".equals(obj))
li.add("添加");
System.out.println("同步操作"+obj);//注意：在obj后面添加
}
System.out.println(li);
System.out.println(list);
}
}
注意：迭代器迭代过程中，每执行一次.next()方法，指针向后移一位，对应的元素相应发生改变，如集合中["1","2","3"],it.next()等于“1”后，再出现一次it。next()，值就等于“2‘了 3.List的三个实现类的子类的特点
（1）ArrayList：底层为数组结构 查询快，增删慢，线程不同步； 底层为元素10个的数组，超过时，每次扩容50%，第一次为15个元素； ArrayList的应用：将ArrayList中重复的元素去掉
package CSDN.review;
import java.util.*;
public class ArrayListTest {
/**
* 将ArrayList中重复的元素去掉
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<String> list = new ArrayList<String>();
list.add("singleElement1");
list.add("singleElement2");
list.add("singleElement1");
list.add("singleElement2");
list.add("singleElement3");
list.add("singleElement1");
System.out.println(list);
System.out.println(singleElement(list));;
}
public static ArrayList singleElement(ArrayList list){
ArrayList newList= new ArrayList();
ListIterator li= list.listIterator();
while(li.hasNext()){
Object obj= li.next();
if(!newList.contains(obj))
newList.add(obj);
}
return newList;
}
}
将普通类的实例存入ArrayList中，相同属性的实例不能存入（比较有实际意义）
package CSDN.review;
import java.util.*;
public class ArrayListTest2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list = new ArrayList();
list.add(new Person("zhangsan",18));
list.add(new Person("zhangsan",18));
list.add(new Person("zhangsan1",19));
list.add(new Person("zhangsan1",19));
list.add(new Person("zhangsan2",20));
System.out.println(list);
System.out.println(singleElement(list));
}
public static List singleElement(ArrayList list){
ArrayList newList= new ArrayList();
ListIterator li= list.listIterator();
while(li.hasNext()){
Object obj=li.next();
if(!newList.contains(obj))
newList.add(obj);
}
return newList ;
}
}
class Person{
private String name;
private int age;
Person(){}
Person(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
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;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
（2）LinkedList：
底层使用的是链表数据结构；
增删快，查询慢，线程不同步；
特有方法：
ackage CSDN.review;
import java.util.*;
public class LinkedListDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
LinkedList<String> list= new LinkedList<String>();
list.add("LinkedList1");
list.add("LinkedList2");
list.add("LinkedList3");
list.add("LinkedList4");
System.out.println(list.getFirst());//获取第一个元素，如果集合为空，返回异常
System.out.println(list.removeFirst());//获取第一个元素，并删除，集合为空返回异常
list.addFirst("LinkedList1");
//独有的迭代方式
// while(!list.isEmpty()){
// System.out.println(list.removeFirst());
// }
//逆向获取
// while(!list.isEmpty()){
// System.out.println(list.removeLast());
// }
System.out.println(list.peekFirst());//获取第一个元素，没有返回null
System.out.println(list.pollFirst());//获取第一个元素，并移除，没有返回null
list.offerFirst("LinkedList1");
System.out.println(list);
}
}
实例应用：
package CSDN.review;
import java.util.*;
public class LinkedListDemo2 {
/**
* 使用LinkedList 模拟一个堆内存或者队列数据结构
* 栈内存：先进后出
* 队列：先进先出：FIFO
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
DuiLie dl =new DuiLie();
dl.add("object1");
dl.add("object2");
dl.add("object3");
dl.add("object4");
while(!dl.isNull()){
System.out.println(dl.get());
}
}
}
class DuiLie
{
private LinkedList<Object> list;
DuiLie(){
list = new LinkedList<Object>();
}
public void add(Object obj){
list.add(obj);
}
public Object get(){
return list.removeFirst();//先进先出
// return list.removeLast(); 先进后出
}
public boolean isNull(){
return list.isEmpty();
}
}
（3）Vector
底层是数组的数据结构
线程同步，（一般线程同步是安全的，线程不同步是不安全的），局部被ArrayList替代了；
底层为10个元素的数组，每次扩容增加100%，比较浪费内存。
package CSDN.review;
import java.util.*;
public class VectorDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Vector<String> v= new Vector<String>();
v.add("vector1");
v.add("vector2");
v.add("vector3");
v.add("vector4");
Enumeration<String> en = v.elements();
//Vector特有的迭代方式
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
技术加强：List集合中判断元素是否相同，依据的是元素的equals方法。
基础阶段，list差不多就这些内容了。
| 
转播
