Java语言程序设计——篇十一（2）

集合框架

• 集合框架是java以类库的形式提供了用户开发程序时可直接使用的各种数据结构。
• 数据结构：以某种形式将数据组织在一起，不仅支持存储数据，还支持访问和处理数据。
• 在面向对象思想里，一种数据结构被认为是一个容器（集合）。
• java集合框架提供了一些现成的数据结构可供使用，这些数据结构是可以存储对象的集合，在这里对象也称为元素。
• java集合框架由两种类型构成：
      1️⃣collection，用于存放一组对象。
      2️⃣map ，用于存放一组“关键字/值”的对象。
  

1. 基本操作
   boolean add(e e)：向集合中添加元素e
   boolean remove(object o)：从集合中删除指定的元素o
   boolean contains(object o)：返回集合中是否包含指定元素
   boolean isempty()：判空
   int size()：返回集合中所包含元素的个数
   iterator iterator()：返回包含所有元素的迭代器对象
2. 批量操作
   boolean addall(collection<? extends e> c) 功能：将集合c中的所有元素添加到当前集合中 boolean removeall(collection<?> c)
   功能：从当前集合中删除集合c中的所有元素
   default boolean removeif(predicate<? super e> filter)
   功能：从当前集合中删除满足谓词的所有元素
3. 数组操作
   object[] toarray() ：用来返回包含集合中所有元素的object型数组
   eg: object[] a = c.toarray();
   t[] toarray(t[] a)：用来返回包含集合中所有元素的指定类型的数组
   eg: string[] a = c.toarray(new string[0]);
4. 流（stream）操作
   default stream stream()
   功能：以当前集合作为源返回一个顺序stream对象
   default stream parallelstream()
   功能：以当前集合作为源返回一个并行stream对象

list接口及实现类

• 列表接口list是collection的子接口，它是一种包含有序元素的线性表，其中的元素可重复，也可以是空值null。
• 存放在list中的元素有一个下标（从0开始），可通过下标访问list中的元素。
• 

list的操作

• 因为list接口为collection的子接口，所以list接口拥有collection接口提供的所有常用方法。
• list是列表类型，它还提供了一些适合于自身的常用方法，如下页表所示。

arraylist类

• list接口的常用实现类有arraylist和linkedlist，在使用线性表时，通常情况下声明为list类型，实例化时根据实际情况的需要，实例化为arraylist或linkedlist。
• 例如：

// 利用arraylist类实例化list
list<string> list1 = new arraylist<string>();  
// 利用linkedlist类实例化list
list<string> list2 = new linkedlist<string>(); 

• arraylist类是通过数组实现的集合对象，它实际上实现了一个变长的对象数组，元素可以动态的增加和删除。
• 数组结构的优点是便于对列表进行快速的随机访问， 如果经常需要根据索引位置访问集合中的对象，使用arraylist类实现的列表的效率较高。
• 数组结构的缺点是向指定索引位置插入对象、删除指定索引位置对象的速度较慢。
• 当在指定索引位置插入对象时，会将指定索引位置及其后的所有元素相应地向后移动一位，如下图所示:
  
• 当删除指定索引位置的对象时，会将指定索引位置之后的所有元素相应地向前移动一位，如下图所示:
• 进行插入、删除操作时，如果在指定的索引位置之后有大量的对象，将严重影响对集合的操作效率。
• arraylist类的构造方法

public arraylist()：创建初始容量为10的空数组列表
public arraylist(int i)：创建初始容量为i的空数组列表
public arraylist(collection c)：创建包含容器c中所有元素的数组列表

实战演练

例：testarraylist.java

import java.util.arraylist;
public class testarraylist {
public static void main(string[] args) {
   arraylist<string> citylist = new arraylist<>();
   //add some cities in the list
   citylist.add("beijing");
   //citylist now contains[beijing]
   citylist.add("london");
   //citylist now contains[beijing,london]
   citylist.add("shanghai");
   //citylist now contains[beijing,london,shanghai]
   citylist.add(" beijing");
   //citylist now contains[beijing,london,shanghai, beijing]
   citylist.add("taiyuan");
   //citylist now contains[beijing,london,shanghai, beijing,taiyuan]
   system.out.println("list size="+citylist.size());
   system.out.println("is taiyuan in the list?"+citylist.contains("taiyuan"));
   system.out.println("the location of shanghai in the list?"+citylist.indexof("shanghai"));
   system.out.println("is the list empty?"+citylist.isempty());
   citylist.add(2, "xian");  // [beijing,london,xian,shanghai, beijing,taiyuan]
   citylist.remove(“shanghai"); // [beijing,london,xian,beijing,taiyuan]
   citylist.remove(1); // [beijing,xian,beijing,taiyuan]
   system.out.println(citylist.tostring());  
   for(int i=citylist.size()-1;i>=0;i--)
	system.out.print(citylist.get(i)+" ");
   }
}

遍历集合元素

• 对集合中元素访问时，经常需要按某种次序对每一个元素访问且仅访问一次，这就是遍历，也称迭代。
• 对集合元素遍历有如下4种方式：
  a.简单的for循环

   for(int i=0; i<array.size(); i++) string o = array.get(i);

b.增强的for循环

    for(string elm：array)  system.out.println(elm)

c.iterator迭代器对象
d.listiterator迭代器对象

c.iterator迭代器对象

• 每个实现collection接口的容器对象都可调用iterator()方法返回一个iterator对象，称为迭代器对象。
• 接口iterator支持对list对象的从前向后的遍历，该接口定义了3个方法。
• 1）boolean hasnext()：返回迭代器是否有下一个元素
  2）e next()： 返回下一个元素
  3）void remove()：删除迭代器中的当前元素

iterator iterator = array.iterator(); //得到迭代器对象
while(iterator.hasnext())
      system.out.println(iterator.next());

for(iterator iterator = array.iterator(); iterator.hasnext();)
      system.out.println(iterator.next());

d.listiterator迭代器对象

• 通过list接口提供的listiterator()方法可以返回listiterator对象，它支持对线性表双向遍历。
• listiterator是iterator的子接口，不但继承了iterator接口中的方法，还定义了多个方法。

boolean hasnext() ：返回是否还有下一个元素
boolean hasprevious() ：返回是否还有前一个元素
e next()：返回下一个元素
e previous()：返回前一个元素
int nextindex()：返回下一个元素的索引
int previousindex()：返回前一个元素的索引
void add(e o)：当前位置插入一个元素
void remove()：删除当前元素
void set(e o)：修改当前元素

实战演练

例：使用listiterator对象实现反向输出线性表中的元素。

import java.util.*;
public class iteratordemo{
    public static void main(string[] args) {
         list<string> mylist = new arraylist<string>();
     mylist.add("one");
     mylist.add("two");
     mylist.add("three");
     mylist.add("four");
     listiterator<string> iterator = mylist.listiterator();
      // 将迭代器指针移动到线性表末尾
     while(iterator.hasnext()){
                   iterator.next();
              }
              // 从后向前访问线性表的每个元素
              while (iterator.hasprevious())
                   system.out.println(iterator.previous());
     }
}

数组转换为list对象

• java.util.arrays类提供了一个aslist()方法，它将数组转换成list对象，定义如下：

public static <t> list<t> aslist(t… a)参数可以为数组，可以是数组元素
string[] str = {"one", "two", "three"};
list<string> list = arrays.aslist(str);
list<string> list = arrays.aslist("one", "two", "three");

• arrays.aslist()方法返回的list对象不可变。若要对该list对象进行添加、删除等操作，可以将其作为参数传递给另一个list的构造方法。

list<string> list1 = new arraylist<>(list);

综合实例

编写程序，实现一个对象栈类mystack，要求使用arraylist类实现该栈，该栈类的uml图如下所示。

import java.util.arraylist;  
import java.util.list;  
  
public class mystack<t> {  
    private list<t> list;  
  
    // 构造函数  
    public mystack() {  
        list = new arraylist<>();  
    }  
  
    // 判断栈是否为空  
    public boolean isempty() {  
        return list.isempty();  
    }  
  
    // 返回栈的大小  
    public int getsize() {  
        return list.size();  
    }  
  
    // 返回栈顶元素但不移除  
    public t peek() {  
        if (isempty()) {  
            throw new illegalstateexception("stack is empty");  
        }  
        return list.get(list.size() - 1);  
    }  
  
    // 弹出栈顶元素  
    public t pop() {  
        if (isempty()) {  
            throw new illegalstateexception("stack is empty");  
        }  
        return list.remove(list.size() - 1);  
    }  
  
    // 元素入栈  
    public void push(t t) {  
        list.add(t);  
    }  
  
    // 元素查找方法，返回元素在栈中的位置（从栈底开始计数，即第一个元素位置为0），如果未找到则返回-1  
    public int search(t t) {  
        for (int i = 0; i < list.size(); i++) {  
            if (list.get(i).equals(t)) {  
                return i; // 注意这里返回的是从栈底开始的位置  
            }  
        }  
        return -1; // 未找到  
    }  
  
    // 可选：打印栈内容（用于调试）  
    public void printstack() {  
        system.out.println("stack content (bottom to top):");  
        for (int i = 0; i < list.size(); i++) {  
            system.out.println(list.get(i));  
        }  
    }  
  
    // 主函数，用于测试mystack类  
    public static void main(string[] args) {  
        mystack<integer> stack = new mystack<>();  
        stack.push(1);  
        stack.push(2);  
        stack.push(3);  
  
        system.out.println("stack size: " + stack.getsize());  
        system.out.println("top element: " + stack.peek());  
        system.out.println("popped element: " + stack.pop());  
        system.out.println("element 2 position: " + stack.search(2));  
  
        stack.printstack();  
    }  
}

博主用心写，读者点关注，互动传真情，知识不迷路。