• 【Java】（机考常用）类集

    类集框架（集合框架）是一个用来代表和操纵集合的统一架构。所有的类集框架都包含如下内容：

    • 接口：是代表类集的抽象数据类型。之所以定义多个接口，是为了以不同的方式操作集合对象。

      例如：Collection、List、Set、Map、Queue等。

    • 实现（类）：是类集接口的具体实现。从本质上讲，它们是可重复使用的数据结构。

      例如：ArrayList、LinkedList、HashSet、HashMap。

    • 算法：是实现类集接口的对象里的方法执行的一些有用的计算。

      例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

    部分类集框架体系如图：

    类集的关系框架图：

    常用类集

    下面较为常用的方法我都用粗体标识了，希望大家注意。
    下面的类都是集合，即 一组数据，而不是单一的一个。

    Collection接口

    Collection：集合

    方法 返回类型 描述 备注
    add(E o) boolean 向集合中插入对象
    addAll(Collection<? extends E> c) boolean 将一个集合的内容插入进来
    clear() void 清除此集合中的所有元素
    contains(Object o) boolean 判断某一个对象是否在集合中存在
    containsAll(Collection<?> c) boolean 判断某一组对象是否在集合中存在
    equals(Object o) boolean 对象比较
    hashCode() int 哈希码
    isEmpty() boolean 集合是否为空
    iterator() Iterator<E> 为Iterator接口实例化
    remove(Object o) boolean 删除指定对象
    removeAll(Collection<?> c) boolean 删除一组对象
    retainAll(Collection<?> c) boolean 保存指定内容
    size() int 求出集合的大小
    toArray() Object[] 将一个集合变为对象数组
    toArray(E[] a) <E> E[] 指定好返回的对象数组类型

    在一般的开发中，往往很少直接使用Collection接口进行开发，基本思都是使用其子接口。

    子接口主要有：List、Set、Queue、SortedSet。

    List接口

    List：线性表

    方法 返回类型 描述 备注
    get(int index) E 返回指定位置的元素
    indexOf(Object o) int 查找指定元素的位置
    set(int index, E element) E 替换指定位置的元素
    remove(int index) E 按指定的位置删除元素
    add(int index, E element) void 在指定位置增加元素
    addAll(int index, Collection<? extends E> c) boolean 在指定位置增加一组元素
    lastIndexOf(Object o) int 从后往前查找指定元素的位置
    listIterator() ListIterator<E> 为ListIterator接口实例化
    subList(int fromIndex, int toIndex) List<E> 取出集合中的子集合

    ArrayList

    ArrayList：数组

    方法 返回类型 描述 备注
    get(int index) E 返回指定位置的元素
    indexOf(Object o) int 查找指定元素的位置
    set(int index, E element) E 替换指定位置的元素
    remove(int index) E 按指定的位置删除元素
    add(int index, E element) void 在指定位置增加元素
    addAll(int index, Collection<? extends E> c) boolean 在指定位置增加一组元素
    lastIndexOf(Object o) int 从后往前查找指定元素的位置
    listIterator() ListIterator<E> 为ListIterator接口实例化
    subList(int fromIndex, int toIndex) List<E> 取出集合中的子集合

    注意：一般用List接口实例化ArrayList类，即 List<String> all = new ArrayList<String>();

    原因：编程是要面向对象编程，针对抽象（接口），而非具体。List 是接口，ArrayList是实现。
    这是一种很好的设计模式.一个接口有多种实现，这种写法是java面向对象的一种思想，依赖倒置原则，即 依赖于抽象不依赖于实现（具体）。
    从Java语法上，这种方式是使用接口引用指向具体实现，这样大大提高了代码使用的灵活性。
    比如，你若希望用LinkedList的实现来替代ArrayList的话，只需改动一行即可。

    LinkedList

    LinkedList：链表

    方法 返回类型 描述 备注
    addFirst(E o) void 在链表开头增加元素
    addLast(E o) void 在链表结尾增加元素
    offer(E o) boolean 将指定元素增加到链表的结尾
    removeFirst() E 删除链表的第一个元素
    removeLast() E 删除链表的最后一个元素

    输出

    Iterator

    Iterator：迭代输出

    方法 返回类型 描述 备注
    hasNext() boolean 判断是否有下一个值 是否有下一个
    next() E 后移，取出当前元素 取出
    remove() void 移除当前元素 移除

    注意：Iterator是从头节点（无数据）开始的，而不是第一个有效节点，所以我们用hasNext()判断是否有值，next()来取值。

    例子：

    List<String> all = new ArrayList<String>(); //实例化List接口
all.add("hello");
all.add("_");
all.add("world");

Iterator<String> iter = all.iterator(); //直接实例化Iterator接口

while(iter.hasNext()) {
    System.out.print(iter.next() + "、");
}

    程序运行结果：

    hello、_、world、

    ListIterator

    ListIterator：双向迭代输出

    方法 返回类型 描述 备注
    remove() void 移除当前元素
    add(E o) void 将指定元素增加集合
    hasNext() boolean 判断是否有下一个值
    next() E 取出当前元素
    nextIndex() int 返回下一个元素的索引号
    hasPrevious() boolean 判断是否有上一个元素
    previous() E 取出当前元素
    previousIndex() int 返回上一个元素的索引号
    set(E o) void 替换元素

    例子：

    List<String> all = new ArrayList<String>();
all.add("hello");
all.add("_");
all.add("world");

ListIterator<String> iter = all.listIterator(); // 实例化ListIterator接口

System.out.print("由前向后输出：");
while(iter.hasNext()) {
    String s = iter.next();
    System.out.print(str + "、");
}

System.out.print("由后向前输出：");
while(iter.hasPrevious()) {
    String s = iter.previous();
    System.out.print(str + "、");
}

    程序运行结果：

    由前向后输出：hello、_、world、
由后向前输出：world、_、hello、

    foreach

    格式：用对象遍历集合数组

    for(类 对象: 集合数组) {
    //操作
}

    例子：

    List<String> all = new ArrayList<String>();
all.add("hello");
all.add("_");
all.add("world");

for(String s: all) {
    System.out.print(s + "、");
}

    程序运行结果：

    hello、_、world、

    Stack

    Stack：栈

    方法 返回类型 描述 备注
    empty() boolean 测试栈是否为空 检查是否空
    push(E item) E 入栈 入栈
    pop() E 出栈，同时删除 出栈
    peek() E 查看栈顶，但不删除 栈顶
    search(Object o) int 在栈中查找 查找

    例子：

    Stack<String> s = new Stack<String>();
s.push("A");
s.push("B");
s.push("C");

System.out.print(s.pop + '、');
System.out.print(s.pop + '、');
System.out.print(s.pop + '、');

    程序运行结果：

    C、B、A、

    Queue

    Queue：队列
    作为一个接口，它没有实现任何具体功能（都是抽象方法），所以我们只能用其他的类来实现Queue接口。

    LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。
    Queue<String> queue = new LinkedList<String>();

    队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。

    方法 返回类型 描述 备注
    offer(E o) boolean 将指定元素增加到队尾 如果队列已满，则返回false
    poll() E 找到并删除队头 （获取）如果队列为空，则返回null
    peek() E 找到但不删除队头 （读取）如果队列为空，则返回null
    add(E o) void 将指定元素增加到队尾 如果队列已满，则抛出一个IIIegaISlabEepeplian异常
    remove() E 找到并移除队头 （移除本应有的）如果队列为空，则抛出一个NoSuchElementException异常
    element() E 找到队头 （找到本应有的元素）如果队列为空，则抛出一个NoSuchElementException异常
    • offer，add 区别：
      一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。
      这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。
    • poll，remove 区别：
      remove() 和 poll() 方法都是从队列中删除第一个元素。remove() 的行为与 Collection 接口的版本相似， 但是新的 poll() 方法在用空集合调用时不是抛出异常，只是返回 null。因此新的方法更适合容易出现异常条件的情况。
    • peek，element区别：
      element() 和 peek() 用于在队列的头部查询元素。与 remove() 方法类似，在队列为空时， element() 抛出一个异常，而 peek() 返回 null。

    注意：add()和remove()是继承于Collection类的，所以我们尽量用前三个方法来操作队列。

    例子：

    注意：Queue接口是用LinkedList类实现的，Queue<String> queue = new LinkedList<String>();）

    Queue<String> queue=new LinkedList<String>();
queue.offer("Hello");
queue.offer("World!");
queue.offer("你好！");

System.out.println(queue.size());

for(String str: queue){
    System.out.printf(str + " ");
}
System.out.printf("
");

System.out.println(queue.size());
String str;

while((str=queue.poll()) != null) {
    System.out.printf(str + " ");
}
System.out.println();
System.out.println(queue.size());

    程序运行结果：

    3
Hello World! 你好！
3
Hello World! 你好！
0

    Set

    Set：集合（无序、不重复）

    Set可以用于去掉重复元素，遇到重复元素不准加入。

    方法 返回类型 描述 备注
    add(E o) boolean 向集合中插入对象
    addAll(Collection<? extends E> c) boolean 将一个集合的内容插入进来
    clear() void 清除此集合中的所有元素
    contains(Object o) boolean 判断某一个对象是否在集合中存在
    containsAll(Collection<?> c) boolean 判断某一组对象是否在集合中存在
    equals(Object o) boolean 对象比较
    hashCode() int 哈希码
    isEmpty() boolean 集合是否为空
    iterator() Iterator<E> 为Iterator接口实例化
    remove(Object o) boolean 删除指定对象
    removeAll(Collection<?> c) boolean 删除一组对象
    retainAll(Collection<?> c) boolean 保存指定内容
    size() int 求出集合的大小
    toArray() Object[] 将一个集合变为对象数组
    toArray(E[] a) <E> E[] 指定好返回的对象数组类型

    Set和List的区别：

    1. Set 接口实例存储的是无序的，不重复的数据。
      List 接口实例存储的是有序的，可以重复的元素。
    2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
    3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector>。

    Map

    Map：映射（键值对表）（一组键值对，不是单一的一个）

    Map接口定义的集合又称为查找表，用于存储所谓“key-value"映射对。
    Key可以看成是Value的索引，作为key的对象在集合中不可重复。

    注意：是集合，查找表，即 一组键值对，不是单一的一个。

    与Collection类似，如果想要使用Map接口也必须依靠其子类实例化。Map 接口中常用的子类介绍如下：

    • HashMap：无序存放的，是新的操作类，key不允许重复。（常用）
    • Hashtable：无序存放的，是旧的操作类，key不允许重复。
    • TreeMap：可以排序的Map集合，按集合中的key排序，不允许key重复。
    • WeakHashMap：弱引用的Map集合，当集合中的某些内容不再使用时清除掉无用的数据，使用gc进行回收。
    • IdentityHashMap：key可以重复的Map集合。
  • 相关阅读:
    node基础
    jade模板引擎
    体验nodejs有感
    JavaScript创建对象、原型与继承
    JavaScript变量作用域和内存问题(js高级程序设计总结)
    HIbernate 延迟加载和级联删除
    git的简单使用
    Java集合类（一） HashMap、Map、LinkedHashMap、TreeMap
    VMware的网络配置
    密码学基础
  • 原文地址：https://www.cnblogs.com/blknemo/p/12469580.html
Copyright © 2020-2023  润新知