花几千上万学习Java，真没必要！（三十二）

沐风听雨_A

已于 2024-07-28 16:12:59 修改

阅读量295

点赞数 5

文章标签：学习 java windows

于 2024-07-28 11:09:48 首次发布

本文链接：https://blog.csdn.net/wehpd/article/details/140747980

版权

链表（LinkedList）的结构和特性：

链表（LinkedList）和队列（Queue）是数据结构中两种常见的类型，它们各有特点和应用场景，主要区别体现在结构、功能和操作方式上。

链表（LinkedList）
结构：链表是一种通过节点（Node）来存储数据元素的数据结构，每个节点包含数据部分和指向列表中下一个节点的链接（即指针或引用）。链表可以是单向的，也可以是双向的。在单向链表中，每个节点包含一个数据元素和一个指向列表中下一个节点的指针；在双向链表中，每个节点还包含一个指向前一个节点的指针。
功能：链表的主要功能包括添加元素、删除元素、查找元素等。由于其动态分配内存的特性，链表特别适合于那些数据集合大小经常变化的情况。
操作方式：链表的操作（如插入和删除）通常涉及修改指针的指向，而不需要移动数据元素本身，这使得链表在某些操作上的效率高于数组。
队列（Queue）
结构：队列是一种先进先出（FIFO, First In First Out）的数据结构。它有两个主要操作：入队（Enqueue）和出队（Dequeue）。在队列中，元素的添加发生在队列的一端（称为队尾），而元素的移除则发生在另一端（称为队首）。队列可以用数组或链表来实现。
功能：队列的主要功能是提供数据的排队处理，确保数据按照它们被加入的顺序被处理。这种特性使得队列成为解决多种问题（如任务调度、缓冲区管理等）的理想选择。
操作方式：队列的操作主要是入队（在队尾添加元素）和出队（从队首移除元素）。这些操作保证了队列的先进先出特性。
区别总结
结构和功能：链表是一种基础的数据结构，其主要功能是通过节点来存储数据，支持各种操作（如添加、删除、查找）。而队列则是一种特定的数据结构，它实现了先进先出的数据处理方式，主要用于数据的排队处理。
操作方式：链表的操作更加灵活，包括在链表中的任何位置添加或删除节点。而队列的操作则受限于其先进先出的特性，只能在队尾添加元素和在队首移除元素。
应用场景：链表因其动态分配内存的特性，适用于数据集合大小经常变化的情况。而队列则因其先进先出的特性，适用于需要按特定顺序处理数据的场景，如任务调度、缓冲区管理等。

测试代码1：

package listtest.com;
import java.util.LinkedList;  
import java.util.List;  
  
public class HashCodeLinkedList {  
    public static void main(String[] args) {  
        // 创建LinkedList并添加元素  
        List<String> linkedList = new LinkedList<>();  
        linkedList.add("Afwe");  
        linkedList.add("Bfds");  
        linkedList.add("Ccx");  
  
        // 遍历LinkedList并打印每个元素的哈希码和值  
        for (String item : linkedList) {  
            // 打印哈希码和值  
            System.out.println("Hash Code: " + item.hashCode() + ", Value: " + item);  
        }  
 
    }  
}

运行结果如下：

测试代码2：

package listtest.com;
import java.util.LinkedList;  

public class LinkedListExample {  
    public static void main(String[] args) {  
        // 创建LinkedList实例  
        LinkedList<Integer> list = new LinkedList<>();  
  
        // 在链表开头添加元素  
        list.addFirst(1);  
        list.addFirst(0);  
  
        // 在链表末尾添加元素  
        list.addLast(2);  
        list.addLast(3);  
  
        // 查看并打印链表中的第一个和最后一个元素  
        System.out.println("First element: " + list.peekFirst());  
        System.out.println("Last element: " + list.peekLast()); 
  
        // 删除并打印链表中的第一个和最后一个元素  
        System.out.println("Removed First: " + list.removeFirst());   
        System.out.println("Removed Last: " + list.removeLast()); 
  
        // 再次查看并打印链表中的第一个和最后一个元素  
        System.out.println("First element after removal: " + list.peekFirst());  
        System.out.println("Last element after removal: " + list.peekLast());   
  
        // 遍历链表并打印每个元素  
        System.out.println("Remaining elements:");  
        for (Integer num : list) {  
            System.out.println(num);  
        }  
    }  
}

运行结果如下：

测试代码3：

package listtest.com;
import java.util.LinkedList;  

public class LinkedListDemo {  
    public static void main(String[] args) {  
        // 创建LinkedList实例  
        LinkedList<String> list = new LinkedList<>();  
  
        // 向链表中添加元素  
        list.add("A");  
        list.add("B");  
        list.add("C");  
  
        // 遍历链表（单向遍历）  
        // 使用增强的for循环，内部实际上是通过迭代器实现的，只遍历一次。
        System.out.print("遍历链表（单向）: ");  
        for (String item : list) {  
            System.out.print(item + " -> ");  
        }  
        System.out.println("null"); // 链表末尾的null  
  
        // 使用显式的迭代器来遍历链表 
        System.out.print("再次遍历链表（使用迭代器，单向）: ");  
        java.util.Iterator<String> iterator = list.iterator();  
        while (iterator.hasNext()) {  
            System.out.print(iterator.next() + " -> ");  
        }  
        System.out.println("null"); // 链表末尾的null  
      }  
}

运行结果如下：

测试代码4：

package listtest.com;
import java.util.LinkedList;  
import java.util.Iterator;  
  
public class BidirectionalLinkedList {  
    public static void main(String[] args) {  
        // 创建LinkedList实例  
        LinkedList<Integer> list = new LinkedList<>();  
  
        // 向链表中添加元素  
        list.add(1);  
        list.add(2);  
        list.add(3);  
  
        // 使用正向迭代器遍历链表  
        System.out.print("正向遍历链表: ");  
        Iterator<Integer> forwardIterator = list.iterator();  
        while (forwardIterator.hasNext()) {  
            System.out.print(forwardIterator.next() + " -> ");  
        }  
        System.out.println("null");  
  
        // 使用反向迭代器遍历链表，体现双向链表的特性  
        System.out.print("反向遍历链表（体现双向性）: ");  
        Iterator<Integer> reverseIterator = list.descendingIterator();  
        while (reverseIterator.hasNext()) {  
            System.out.print(reverseIterator.next() + " <- ");  
        }  
        System.out.println("null"); 
     }  
}

运行结果如下：

测试代码5：

创建一个服装类：

package listtest.com;

public class Clothing {  
    private String brand;  
    private String name;  
    private String size;  
    private double price;  
  
    // 构造方法
    public Clothing(String brand, String name, String size, double price) {  
        this.brand = brand;  
        this.name = name;  
        this.size = size;  
        this.price = price;  
    }  
  

    public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSize() {
		return size;
	}

	public void setSize(String size) {
		this.size = size;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public String getBrand() {  
        return brand;  
    }  

    public void setBrand(String brand) {  
        this.brand = brand;  
    }  
  
    // toString方法用于打印服装信息  
    @Override  
    public String toString() {  
        return "Clothing{" +  
                "brand='" + brand + '\'' +  
                ", name='" + name + '\'' +  
                ", size='" + size + '\'' +  
                ", price=" + price +  
                '}';  
    }  
}

创建一个服装管理类：

package listtest.com;
import java.util.LinkedList;  
import java.util.ListIterator;  
  
public class ClothingManager {  
    private LinkedList<Clothing> clothingList;  
  
    // 构造函数  
    public ClothingManager() {  
        this.clothingList = new LinkedList<>();  
    }  
  
    // 添加服装  
    public void addClothing(Clothing clothing) {  
        clothingList.add(clothing);  
    }  
  
    // 显示所有服装  
    public void displayAllClothing() {  
        System.out.println("当前所有服装：");  
        for (Clothing clothing : clothingList) {  
            System.out.println(clothing);  
        }  
    }  
  
    // 按名称搜索服装  
    public Clothing searchClothingByName(String name) {  
        ListIterator<Clothing> iterator = clothingList.listIterator();  
        while (iterator.hasNext()) {  
            Clothing clothing = iterator.next();  
            if (clothing.getName().equals(name)) {  
                return clothing;  
            }  
        }  
        return null; // 如果没有找到，则返回null  
    }  
}

测试代码：

package listtest.com;
public class TestList {  
    public static void main(String[] args) {  
        ClothingManager manager = new ClothingManager();  
  
        // 添加服装  
        manager.addClothing(new Clothing("Nike", "T-Shirt", "M", 29.99));  
        manager.addClothing(new Clothing("Adidas", "Hoodie", "L", 49.99));  
        manager.addClothing(new Clothing("Puma", "Pants", "S", 34.99));  
  
        // 显示所有服装  
        manager.displayAllClothing();  
  
        // 搜索并显示特定服装  
        Clothing found = manager.searchClothingByName("Hoodie");  
        if (found != null) {  
            System.out.println("找到的服装：" + found);  
        } else {  
            System.out.println("没有找到指定的服装。");  
        }  
    }  
}

运行结果如下：