网络安全最全凯哥带你从零学大数据系列之Java篇---第十七章 集合(List)，2024年最新看完直呼内行

本人从事网路安全工作12年，曾在2个大厂工作过，安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过，对这个行业了解比较全面。

最近遍览了各种网络安全类的文章，内容参差不齐，其中不伐有大佬倾力教学，也有各种不良机构浑水摸鱼，在收到几条私信，发现大家对一套完整的系统的网络安全从学习路线到学习资料，甚至是工具有着不小的需求。

最后，我将这部分内容融会贯通成了一套282G的网络安全资料包，所有类目条理清晰，知识点层层递进，需要的小伙伴可以点击下方小卡片领取哦！下面就开始进入正题，如何从一个萌新一步一步进入网络安全行业。

学习路线图

其中最为瞩目也是最为基础的就是网络安全学习路线图，这里我给大家分享一份打磨了3个月，已经更新到4.0版本的网络安全学习路线图。

相比起繁琐的文字，还是生动的视频教程更加适合零基础的同学们学习，这里也是整理了一份与上述学习路线一一对应的网络安全视频教程。

网络安全工具箱

当然，当你入门之后，仅仅是视频教程已经不能满足你的需求了，你肯定需要学习各种工具的使用以及大量的实战项目，这里也分享一份我自己整理的网络安全入门工具以及使用教程和实战。

项目实战

最后就是项目实战，这里带来的是SRC资料&HW资料，毕竟实战是检验真理的唯一标准嘛~

面试题

归根结底，我们的最终目的都是为了就业，所以这份结合了多位朋友的亲身经验打磨的面试题合集你绝对不能错过！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

    list.add("Lily");
    list.add("Lucy");
    list.add("Polly");
    list.add("Jim");

    // 排序: 按照两个字符串的长度进行大小比较，升序排序
    list.sort((e1, e2) -> e1.length() - e2.length());
}

}

**17.5. List集合遍历**


由于List接口是继承自Collection接口的，因此在Collection部分的三种遍历方式，都可以用来遍历List集合。同时，在List集合中，还添加了两种用来遍历集合的其他方式。


#### **17.5.1. 下标遍历**


顾名思义， 类似于数组的下标遍历。 遍历集合中的所有的下标， 依次获取指定下标位的元素。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;

/**

• @Description List集合遍历
  /
  public class List1 {
  public static void main(String[] args) {
  // 1. 实例化一个List集合，存储若干数据
  List list = new ArrayList<>();
  Collections.addAll(list, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100);
  // 2. 遍历
  index(list);
  }
  /*
  • 下标遍历法
  • @param list 需要遍历的集合
    */
    private static void index(List list) {
    for (int i = 0; i < list.size(); i++) {
    // 获取每一个元素
    System.out.println(list.get(i));
    }
    }
    }

**17.5.2. 列表迭代器**


这种方式， 类似于迭代器。 在List集合中， 有一个方法 `listIterator()`， 可以获取到一个 `ListIterator` 接口的引用。 而`ListIterator`是`Iterator`的子接口。 因此在保留了传统的迭代器的迭代方法的基础上， 还添加了若干个其他的方法。



> 
>  使用ListIterator， 在遍历集合中的元素的同时， 可以向集合中添加元素、删除元素、修改元素。 
>    
>  但是， 这里对集合中的元素操作， 并不是使用 List 接口中的方法， 而是用 ListIterator 接口中的方法完成。 
> 

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;

/**

• @Description List集合遍历
  /
  public class List1 {
  public static void main(String[] args) {
  // 1. 实例化一个List集合，存储若干数据
  List list = new ArrayList<>();
  Collections.addAll(list, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100);
  // 2. 遍历
  listIterator(list);
  }
  /*
  • 使用列表迭代器完成遍历
  • @param list 需要遍历的集合
    */
    private static void listIterator(List list) {
    // 1. 获取到 ListIterator 对象
    ListIterator iterator = list.listIterator(4);
    // 2. 循环遍历
    while (iterator.hasNext()) {
    // 2.1. 获取迭代器当前指向的元素
    Integer ele = iterator.next();
    System.out.println(ele);
    // 2.2. 元素操作
    if (ele == 30) {
    // 添加：在迭代器当前指向的元素的下一位插入一个元素
    // 新增的元素，没有存在于迭代列表中，迭代器会直接指向原集合中的下一个元素
    // iterator.add(300);
    // 删除：删除迭代器当前指向的这一位元素
    // iterator.remove();
    // 修改：修改迭代器当前指向的这一位元素
    // iterator.set(300);
    }
    }
    System.out.println(list);
    }
    }

### **17.6. ArrayList与LinkedList**


* 相同点：
	+ 都是List集合的常用的实现类。
	+ 对集合中的元素操作的方法基本一致。
* 不同点：
	+ ArrayList底层实现是数组， 使用数组这种数据结构进行数据的存储。
	+ LinkedList底层实现是双链表， 使用双链表这种数据结构进行数据的存储。


**ArrayList与LinkedList的使用场景：**


* 如果对集合中的元素， 增删操作不怎么频繁， 查询操作比较频繁。 使用ArrayList。
* 如果对集合中的元素， 增删操作比较频繁， 查询操作不怎么频繁。 使用LinkedList。


### **17.7. 双链表数据结构**


#### **17.7.1. 链表简介**


链表， 其实是一种比较常见的数据结构。 增删效率比较高， 查询效率比较低。


数据在链表中存储， 是以节点为单位进行存储的。 节点之间在内存上是不连续的。 双向链表中的每一个节点， 除了记录了当前节点存储的元素之外， 还记录了上一个节点和下一个节点的地址。


#### **17.7.2. 示例代码**

/**

• @Description 使用链表数据结构实现一个自定义的集合(模拟LinkedList)
  */
  public class MyLinkedList {
  // 链表中，元素是以节点的形式存储的
  // 内部类，表示一个节点
  private class Node {
  E element; // 表示这个节点需要存储的元素
  Node previous; // 上一个节点的地址
  Node next; // 下一个节点的地址
  Node(E element) {
  this.element = element;
  }
  }

  private Node first; // 描述链表中的首节点
  private Node last; // 描述链表中的尾结点
  private int count; // 描述链表中节点数量

  /**

  • 在当前集合中添加一个元素
  • @param element 要添加的元素
    */
    public void add(E element) {
    // 1. 实例化一个节点，用来存储这个节点要存储的元素
    Node node = new Node(element);
    // 2. 判断当前的链表是否是空链表
    if (count == 0) {
    // 说明当前链表是一个空链表
    this.first = node;
    }
    else {
    // 说明当前链表不是一个空链表
    // 需要把当前节点挂在尾结点的后面
    this.last.next = node;
    node.previous = this.last;
    }
    this.last = node; // 新增的这个节点，就是当前链表中的新的尾结点
    count++; // 节点数量+1
    }

  /**

  • 在链表中，指定的下标位置插入一个元素
  • @param index 指定的下标位
  • @param element 需要插入的元素
    */
    public void add(int index, E element) {
    // 1. 实例化一个新的节点
    Node node = new Node(element);
    // 2. 节点关联
    if (index == 0) {
    // 说明在首位插入一个新的节点
    this.first.previous = node;
    node.next = this.first;
    // 这个节点就是新的首节点
    this.first = node;
    }
    else if (index == count) {
    // 说明在尾结点插入一个新的节点
    this.last.next = node;
    node.previous = this.last;
    // 这个新的节点就是新的尾结点
    this.last = node;
    }
    else {
    // 说明在中间节点插入一个元素
    // 1. 获取指定下标的节点
    Node target = getNode(index);
    // 节点关联
    node.next = target;
    node.previous = target.previous;
    target.previous.next = node;
    // 这个节点设置需要在后面
    target.previous = node;
    }
    count++;
    }

  /**

  • 删除指定下标位的元素

  • @param index 指定的下标位

  • @return 刚刚被删除的元素
    */
    public E remove(int index) {
    // 1. 获取需要被删除的这个节点
    Node node = getNode(index);
    // 2. 删除节点
    removeNode(node);

    return node.element;
    }

  /**

  • 删除一个节点
  • @param node 需要被删除的节点
    */
    private void removeNode(Node node) {
    // 当一个链表中有且只有一个节点的情况
    if (count == 1) {
    this.first = null;
    this.last = null;
    count–;
    return;
    }
    // 判断是否删除的是首节点
    if (node == this.first) {
    this.first = this.first.next; // 设置新的首节点
    // 取消新的首节点与上一个节点的关联
    this.first.previous.next = null;
    this.first.previous = null;
    }
    else if (node == this.last) {
    // 设置新的尾结点
    this.last = this.last.previous;
    // 取消新的尾结点与下一个节点的关联
    this.last.next.previous = null;
    this.last.next = null;
    }
    else {
    // 删除的是中间节点
    node.previous.next = node.next;
    node.next.previous = node.previous;
    node.previous = null;
    node.next = null;
    }
    count–;
    }

  /**

  • 通过下标获取指定的节点
  • @param index 指定的下标
  • @return 下标对应的节点
    */
    private Node getNode(int index) {
    // 1. 判断下标的合法性
    if (index < 0 || index >= count) {
    throw new IndexOutOfBoundsException("size() = " + count + ", index = " + index);
    }
    // 2. 循环向下查找指定的节点
    Node node = this.first;
    for (int i = 0; i < index; i++) {
    node = node.next;
    }
    return node;
    }

  /**

  • 删除链表中指定的元素
  • @param element 要删除的元素
  • @return 删除的结果(是否删除，如果删除了数据，返回true)
    */
    public boolean remove(E element) {
    // 1. 通过元素获取指定的节点
    Node node = getNode(element);
    // 2. 判断这个节点是否存在
    if (node == null) {
    // 说明这个节点不存在
    return false;
    }
    // 3. 删除节点
    removeNode(node);
    return true;
    }

  /**

  • 通过元素获取节点
  • @param element 元素
  • @return 节点
    */
    private Node getNode(E element) {
    Node node = this.first;
    while (node != null) {
    if (node.element.equals(element)) {
    return node;
    }
    node = node.next;
    }
    // 如果找不到这个元素
    return null;
    }

  /**

  • 清空链表中的所有的数据
    */
    public void clear() {
    this.first = null;
    this.last = null;
    count = 0;

给大家的福利

零基础入门

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

同时每个成长路线对应的板块都有配套的视频提供：

因篇幅有限，仅展示部分资料

网络安全面试题

绿盟护网行动

还有大家最喜欢的黑客技术

网络安全源码合集+工具包

所有资料共282G，朋友们如果有需要全套《网络安全入门+黑客进阶学习资源包》，可以扫描下方二维码领取（如遇扫码问题，可以在评论区留言领取哦）~

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！