2024年网络安全最全凯哥带你从零学大数据系列之Java篇---第十七章集合(List)(3)，网络安全模块化面向接口编程

2401_84281648

已于 2024-05-06 23:39:43 修改

阅读量767

点赞数 10

分类专栏：程序员文章标签： java list 开发语言

于 2024-05-06 23:39:41 首次发布

本文链接：https://blog.csdn.net/2401_84281648/article/details/138512556

版权

程序员专栏收录该内容

166 篇文章 0 订阅

订阅专栏

学习路线：

这个方向初期比较容易入门一些，掌握一些基本技术，拿起各种现成的工具就可以开黑了。不过，要想从脚本小子变成黑客大神，这个方向越往后，需要学习和掌握的东西就会越来越多以下是网络渗透需要学习的内容：
在这里插入图片描述

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

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

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

 * @param list 需要遍历的集合
 */
private static void index(List<Integer> 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;
  }
/**
- 将链表中指定下标位的元素，修改成新的元素
- @param index 要修改元素的下标
- @param element 新的元素
- @return 被覆盖的，修改之前的数据
  */
  public E set(int index, E element) {
  // 1. 通过下标获取指定的节点
  Node node = getNode(index);
  // 2. 备份一次原来的元素
  E ele = node.element;
  // 3. 设置这个节点新的元素
  node.element = element;
  // 4. 返回覆盖之前的数据
  return ele;
  }
/**
- 获取链表中指定下标位的元素
- @param index 下标位
- @return 指定的元素
  */
  public E get(int index) {
  // 1. 获取指定的节点
  Node node = getNode(index);
  // 2. 返回这个节点的数据
  return node.element;
  }
public int size() {
return count;
}

/**
- 判断一个链表中是否包含指定的元素
- @param element 查询的元素
- @return 是否包含
  */
  public boolean contains(E element) {
  return indexOf(element) != -1;
  }