黑马程序员---集合框架1（Collection的共性方法，迭代器，ArrayList，LinkedList，Vector）

2023-12-14 21:14:33

为什么会出现集合类？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就需要对多个对象进行存储，集合类就是方式之一。

那数组和集合均为容器，有什么不同呢？

<1>数组的长度是固定不变的，集合长度是可以变化的。

<2>数组定义时需要指定类型，只能存储同一类型的数据，而集合不限定类型。

<3>数组还可以存储其他的基本数据类型，而集合只能存储对象。

集合类的特点：

<1>集合只用于存储对象  <2>集合的长度是可变的  <3>集合可以用来存储不同类型的对象

Collection的共性方法（以ArrayList为例）：

ArrayList  al=new ArrayList(  );

<1>添加元素：add(对象)；add方法的参数类型为Object，以便于接收任意类型的对象，集合中存储的都是对象的引用（即地址）。

<2>获取集合的长度：al.size( );

<3>打印集合：System.out.println(al);打印出来的是集合里面的元素。

<4>删除元素：al.remove(对象);

        将集合清空：al.clear(  );

<5>判断元素： 

  1: 



  2: 		//判断是否包含某一元素，返回值类型为boolean型



  3:         System.out.println("java03是否存在："+al.contains("java03"));



  4: 		



  5: 		//判断集合是否为空



  6: 		System.out.println("集合是否为空："+al.isEmpty());



  7:
<6>取两个集合的交集： 

  1:              //取两个集合的交集，al1中只存放和al2中相同的元素



  2: 		al1.retainAll(al2);



  3: 



  4: 		//al1中只保留与al2中不同的元素，移走相同的元素



  5: 		al1.removeAll(al2);



  6:

迭代器（以ArrayList为例）：

获取迭代器，用于取出集合中的元素：

  1:     Iterator it=al.iterator();



  2:     //hasNext方法，如果还有下一个元素可以迭代，那么返回true



  3:     //next方法，取出下一个元素



  4:     while(it.hasNext())



  5:     {



  6:       System.out.println(it.next());



  7:     }

那么什么是迭代器呢？

其实就是集合的取出元素的方式。就把这些取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素，那么取出方式就被定义成了内部类。

而每一个容器的数据结构不一样，那么取出的动作细节也不一样，但是都是有同性的，例如判断和取出，那么就将共性内容抽取出来。

这样内部类符合一个规则，该规则是Iterator，如何获取集合的取出对象呢？通过一个对外提供的方法，iterator方法。

  1: for(Iterator it=al.iterator();it.hasNext();)



  2:     {



  3:       System.out.println(it.next());



  4:     }



  5:     //通过indexOf来获取对象的位置：



  6:     al.indexOf("对象名");



  7:     //获取al中的部分对象，包含头不包含尾



  8:     List sub=al.subList(1,3);



  9:

列表迭代器：

如果需要在迭代的过程中增加或者删除元素的话。

  1: Iterator it=al.iterator();



  2:     while(it.hasNext())



  3:     {



  4:       Object obj=it.next();



  5:       if(obj.equals("java02"))



  6:         al.add("java08");



  7:       System.out.println("obj="+obj);



  8:     }



  9: 



 10:     //运行时会出现ConcurrentModificationException,



 11:     //当方法检测到并发修改，但是不允许并发修改，会抛出此异常

此时就需要使用到ListIterator，列表迭代器。继承自Iterator。是List集合特有的迭代器。

在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException。因此在迭代时，只可以通过迭代器的方法操作元素。又因为Iterator的方法是有限的（判断，取出，移除）。需要其他操作则需要其子接口ListIterator。

  1: ListIterator li=al.listIterator();



  2:     while(li.hasNext())



  3:     {



  4:       Object obj=li.next();



  5:       if(obj.equals("java02"))



  6:         li.add("java09");//在java02后面加上java09



  7: 



  8:       //将java02置换成java006



  9:       li.set("java006");



 10:     }



 11: 



 12:     /*



 13:     boolean hasPrevious();逆向遍历列表，判断前面是否有元素，如果有，返回true



 14:     previous();返回列表的前一个元素



 15: 



 16:     */
黑马程序员---集合框架1（Collection的共性方法，迭代器，ArrayList，LinkedList，Vector）

List的方法：

特有方法，凡是可以操作角标的方法都是该体系特有的方法。

<1>增加：add(index,element);

                   addAll(index,Collection);从指定位置开始，将指定的Collection中的所有元素都插入到此列表中

<2>删除：remove(index);

<3>修改：set(index,element);

<4>查询：get(index);通过角标获取元素

                   subList(from,to);获取该列表的一部分，包含头不包含尾

                   iterator();

                   indexOf(obj);获取指定元素的位置

                   listIterator();

Vector：

  1: public static void main(String[] args)



  2: {



  3:   Vector v=new Vector();



  4:   v.add("java01");



  5:   v.add("java02");



  6:   v.add("java03");



  7:   v.add("java04");



  8: 



  9:   //枚举是Vector特有的取出方式，枚举和迭代的使用方法一样。



 10:   Enumeration en=v.elements();



 11:   while(en.hasMoreElements())



 12:   {



 13:     System.out.println(en.nextElement());



 14:   }



 15: }

LinkedList：

  1: 



  2: public static void main(String[] args)



  3: {



  4:   LinkedList link=new LinkedList();



  5:   link.add("java01");



  6:   link.add("java02");



  7:   link.add("java03");



  8:   link.add("java04");



  9: 



 10:   //将对象添加到链表头部



 11:   link.addFirst("java00");



 12:   //将对象添加到链表尾部



 13:   link.addLast("java05");



 14: 



 15:   /*获取链表头部和链表尾部getFirst()，getLast(),只获取，不删除



 16: 



 17:   删除链表头部和链表尾部removeFirst()，removeLast()，获取且删除



 18:   如果该链表为空，使用removeFirst和removeLast方法会发出NoSuchElementException,无此元素异常



 19: 



 20:   pollFirst()和pollLast()获取并移除列表的第一个元素，最后一个元素



 21:   如果链表为空，则返回null



 22: 



 23:   offerFirst()和offerLast()在链表的开头或者结尾插入指定的元素



 24: 



 25:   peekFirst()和peekLast()获取但是不移除元素，如果集合中没有元素，则返回null



 26: 



 27: 



 28:   */



 29: }

使用LinkedList模拟一个堆栈或者队列数据结构，堆栈是先进后出，队列是先进先出

  1: class DuiLie



  2: {



  3:   private LinkedList link;



  4:   DuiLie()



  5:   {



  6:     link=new LinkedList();



  7:   }



  8: 



  9:   public void myAdd(Object obj)



 10:   {



 11:     link.addFirst(obj);



 12:   }



 13: 



 14:   public Object myGet()



 15:   {



 16:     return link.removeLast();



 17:   }



 18:   



 19:   public boolean isNull()



 20:   {



 21:     return link.isEmpty();



 22:   }



 23: 



 24: }

练习：去掉ArrayList中的重复元素：

  1: /*



  2: 去除ArrayList中的重复元素。



  3: */



  4: 



  5: import java.util.*;



  6: 



  7: class ArrayListDemo



  8: {



  9:   private ArrayList al1;



 10:   ArrayListDemo()



 11:   {



 12:     al1=new ArrayList();



 13:   }



 14:   public ArrayList newAl(ArrayList al)



 15:   {



 16:     for(Iterator it=al.iterator();it.hasNext();)



 17:     {



 18:       Object obj=new Object();



 19:       obj=it.next();



 20:       if(!al1.contains(obj))



 21:       {



 22:         al1.add(obj);



 23:       }



 24:     }



 25: 



 26:     return al1;



 27:   }



 28:         



 29: }



 30: 



 31: class  ArrayListDemo2



 32: {



 33:   public static void main(String[] args) 



 34:   {



 35:     ArrayList al=new ArrayList();



 36:     al.add("java01");



 37:     al.add("java02");



 38:     al.add("java03");



 39:     al.add("java02");



 40:     al.add("java01");



 41: 



 42:     ArrayListDemo ald=new ArrayListDemo();



 43:     



 44: 



 45:     System.out.println(ald.newAl(al));



 46:   }



 47: }



 48:

在ArrayList集合中存入人对象，而且根据姓名和年龄判断是否包含相同的元素

  1: import java.util.*;



  2: 



  3: class Person



  4: {



  5:   private String name;



  6:   private int age;



  7:   Person(String name,int age)



  8:   {



  9:     this.name=name;



 10:     this.age=age;



 11:   }



 12: 



 13: 



 14:   public String getName()



 15:   {



 16:     return name;



 17:   }



 18:   public int getAge()



 19:   {



 20:     return age;



 21:   }



 22: 



 23:   //list集合判断元素是否相同，依据是元素的equals方法，重写该方法，以自己的标准来进行判断



 24:   public boolean equals(Object obj)



 25:   {



 26:     if(!(obj instanceof Person))



 27:       return false;



 28:     Person p=(Person)obj;



 29:     return this.name.equals(p.name)&&this.age==p.age;



 30:   }



 31: 



 32: 



 33: }



 34: 



 35: class ArrayListDemo



 36: {



 37:   private ArrayList al1;



 38:   ArrayListDemo()



 39:   {



 40:     al1=new ArrayList();



 41:   }



 42:   public ArrayList newAl(ArrayList al)



 43:   {



 44:     for(Iterator it=al.iterator();it.hasNext();)



 45:     {



 46:       Object obj=it.next();



 47:       



 48: 



 49:       if(!al1.contains(obj))



 50:       {



 51:         al1.add(obj);



 52:       }



 53:     }



 54: 



 55:     return al1;



 56:   }



 57:         



 58: }



 59: 



 60: 



 61: class  ArrayListTest



 62: {



 63:   public static void main(String[] args) 



 64:   {



 65:     ArrayList al=new ArrayList();



 66:     al.add(new Person("lisi1",20));



 67:     al.add(new Person("lisi2",20));



 68:     al.add(new Person("lisi3",30));



 69:     al.add(new Person("lisi3",30));



 70:     



 71:         ArrayListDemo ald=new ArrayListDemo();



 72:     



 73:     al=ald.newAl(al);



 74:     for(Iterator it=al.iterator();it.hasNext();)



 75:     {



 76:       Object obj=it.next();



 77:       Person p=(Person)obj;



 78: 



 79:       System.out.println(p.getName()+"......."+p.getAge());



 80: 



 81:     }



 82: 



 83:   }



 84: }



 85:

黑马程序员---集合框架1（Collection的共性方法，迭代器，ArrayList，LinkedList，Vector）

上一篇：Poj 3261 Milk Patterns(后缀数组+二分答案)


下一篇：POJ 1226 Substrings（后缀数组+二分答案）