类集框架

Author Avatar
Roojay 6月 16, 2017
  • 在其它设备中阅读本文章

  • 类集框架是一组类和接口；

  • 位于java.until包当中；

  • 主要用于存储盒管理对象；

  • 主要分为三大类：集合(Set)、列表(List)和映射(Map)。

    类集框架的主体结构

    • Collection为单列集合，Map为双列集合。

Collection接口中的方法

方法 功能
boolean add（Object o） 向集合中加入一个对象。
void clear（） 删除集合当中的所有对象。
boolean isEmpty（） 判断集合是否为空，如果为空返回true。
remove（Object o） 从集合中删除一个对象的引用。
int size（） 返回集合中元素的数目。

Iterator接口

  • 主要用于迭代访问（即遍历）整个Collection中的元素，因此Iterator对象也被称为迭代器。
方法 作用
hasNet() 判断当前迭代器中是否还有下一个元素，返回值为boolean值。
next() 返回当前迭代器下一个元素。

示例：


import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
public class TestIterator{
    public static void main(String args[]){
        Set<String> set = new HashSet<String>();
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("e");
        //调用Set对象的Iterator方法生成一个迭代器对象，该对象遍历整个Set
        Iterator<String> it = set.iterator();
          //判断Set集合中是否存在下一个元素
        while(it.hasNext()){
              //取出Set集合中的元素
            String s = it.next();
            System.out.println(s);
        }
    }
}

ListIterator接口

  • 可以按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。
方法 功能
void add(Object o) 将指定的元素插入列表。
boolean hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回true。
Object previous() 返回列表中的前一个元素。
void remove() 从列表中移除由next或previous返回的最后一个元素。

示例：

import java.util.*;
public class Test{
    public static void main(String args[]) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("Monday");
        list.add("Tuesday");
        list.add("Wednesday");
        list.add("Thursday");
        System.out.println(list);
        //生成一个ListIterator对象
        ListIterator it = list.listIterator(list.size());
          //调用hasPrevious()方法判断是否存在元素
        while(it.hasPrevious()){
              //调用previous()方法返回元素
            Object obj = it.previous();
            System.out.println(obj);
        }
    }
}

集合（Set）

  • 集合中的对象不按特定方式排序，并且没有重复对象。

HashSet集合

  • HashSet是Set接口的一个实现类，它所储存的元素时不可重复且无序的。根据对象的哈希值来确定元素在集合中的储存位置，因此具有良好的存取和查找性能。

示例：

import java.util.Set;
import java.util.HashSet;
public class TestSet{
    public static void main(String args[]){
        //生成HashSet对象并向上转型为Set
        Set<String> set =new HashSet<String>();
        //定义一个boolean型变量b1接受 isEmpty（）方法返回值
        boolean b1 = set.isEmpty();
        System.out.println(b1);
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("e");
        set.add("f");

        boolean b2 =set.isEmpty();
        System.out.println(b2);

        //调用size（）方法获取集合长度
        int i =set.size();
        System.out.println("初始状态set集合中元素的数目" + i);

        //调用remove（）方法移除对象d
        set.remove("d");

        int j = set.size();
        System.out.println("处理之后set集合中元素的数目" + j);
    }
}

TreeSet集合

  • 它内部采用自平衡点排序二叉树来储存元素，这样的结构保证TreeSet集合没有重复的元素，并且可以对元素进行排序。

二叉树

  • 二叉树是指每个节点最多有两个子节点的有序树，每个节点及其子节点组成的树称为子树，通常左侧的节点称为“左子树”，右侧的的子节点称为“右子树”。

示例：

import java.util.*;
public class Test01{
    public static void main(String args[]){
        //创建TreeSet集合
        TreeSet<String> ts = new TreeSet<String>();
        ts.add("10");
        ts.add("50");
        ts.add("20");
        ts.add("40");
        ts.add("30");
        //获取Iterator对象
        Iterator it = ts.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

结果：

列表（List）

  • 集合中对象按照索引位置排序，即元素的存入和取出顺序一致，可以有重复对象。

ArrayList

  • ArrayList的底层是使用一个数组来保存元素，当增加或删除指定位置的元素时，会创建新的数组，效率较低，因此不适合做大量的增删操作。但是这种数组的结构允许程序通过索引的方式来访问元素，因此使用ArryList集合查找元素很便捷。

示例：

import java.util.List;
import java.util.ArrayList;
public class Test{
    public static void main(String args[]){
        ArrayList<String> arrayList = new ArrayList<String>();
        //向ArrayList中存入数据
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("d");

        //移除这个对象
        arrayList.remove(2);

        //从ArrayList中取数据
        for(int i = 0; i < arrayList.size(); i++){
            String s = arrayList.get(i);
            System.out.println(s);
        }
    }
}

LinkedList

  • 内部维护了一个双向循环链表，链表中的每一个元素都使用引用的方式来记住它的前一个元素和后一个元素，插入一个新元素，只需修改元素之间的这种引用关系即可。

示例：

import java.util.List;
import java.util.LinkedList;
public class Test01{
    public static void main(String args[]){
        //创建LinkedList集合
        LinkedList<String> link = new LinkedList<String>();
            //向集合中添加元素
            link.add("One");
            link.add("Two");
            link.add("Three");
            link.add("Four");
            //取出并打印该集合中的所有元素
            System.out.println(link.toString());
            //向指定位置插入元素
            link.add(2,"插个队");
            System.out.println(link);
            //移除指定位置的元素
            link.remove(2);
            System.out.println(link);
    }
}

映射（Map）

  • 集合中的每一个元素包含一个键对象和一个值对象，键不可重复，值可以重复。
键对象 值对象
key1 value1
key2 value2
key3 value3

Map接口中的方法

方法 作用
void clear() 从此映射中移除所有映射关系（可选操作）。
boolean containsKey（Object Key） 如果此映射包含指定键的映射关系，则返回 true。
boolean equals（Object o） 比较指定的对象与此映射是否相等。
get（Object key） 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null。
boolean isEmpty（） 如果此映射未包含键-值映射关系，则返回 true。
put（） 将指定的值与此映射中的指定键关联。
remove（Object key） 如果存在一个键的映射关系，则将其从此映射中移除。
int size（） 返回此Map中的键值对数目。

Map与HashMap

示例：

import java.util.Map;
import java.util.HashMap;
public class Test{
    public static void main(String args[]){
        //生成HashMap对象并向上转型为Map
        Map<String,String> map = new HashMap<String,String>();
        //向map中添加键值对
        map.put("1","One");
        map.put("2","Two");
        map.put("3","Three");
        //调用get（Object key）方法，返回指定键所映射的值；
        //如果对于该键来说，此映射不包含任何映射关系，则返回 null。
        String s = map.get("2");
        System.out.println(s);
    }
}

The MIT License (MIT)
Copyright (c) 2019, Roojay.
本文链接：https://roojay.com/pages/85b5073b/