java链表常用方法
hashmap java8 链式写法
Hashmap是Java中常用的数据结构，用于存储键值对。
在Java8中，引入了一种新的链式写法，使得使用Hashmap更加灵活和便捷。
本文将介绍Hashmap的基本原理，以及在Java8中如何使用链式写法进行操作。
一、Hashmap的基本原理1.1 Hashmap的存储结构在Hashmap中，数据是以键值对的形式存储的。
在内部，Hashmap 通过一个数组来存储实际的数据。
当我们往Hashmap中添加新的键值对时，Hashmap会根据键的hash值来确定该键值对在数组中的位置，然后将该键值对存储在数组的对应位置中。
如果多个键的hash值相同，那么它们会被存储在同一个数组位置的链表中。
这种设计使得Hashmap能够以常数时间复杂度进行插入、查找和删除操作。
1.2 Hashmap的原理分析Hashmap的存储结构决定了它在插入、查找和删除操作上的高效性。
当我们要进行这些操作时，Hashmap会先计算键的hash值，然后根据hash值找到键值对所在的数组位置，最后在该位置上进行相应的操作。
由于hash值的计算和数组位置的查找都是常数时间复杂度的操作，因此插入、查找和删除操作在平均情况下的时间复杂度均为O(1)。
二、Java8中的链式写法2.1 传统的写法在Java8之前，我们通常使用put()方法往Hashmap中添加新的键值对，使用get()方法来获取指定键对应的值，使用remove()方法来删除指定键值对。
这种写法比较繁琐，需要多次调用Hashmap的方法才能完成一次操作。
2.2 链式写法的优势在Java8中，Hashmap引入了一种链式写法，使得操作Hashmap更加灵活和便捷。
链式写法基于一种函数式的风格，通过流式调用方法来完成对Hashmap的操作。
这种写法可以使代码更加简洁、易读，而且易于理解和维护。
2.3 链式写法的示例下面是一个使用链式写法操作Hashmap的示例代码：```javaMap<String, Integer> map = new HashMap<>();map.put("A", 1);map.put("B", 2);map.put("C", 3);map.entrySet().stream().filter(entry -> entry.getValue() > 1).forEach(entry -> System.out.println(entry.getKey() + " : " + entry.getValue()));```在上面的代码中，我们首先创建了一个Hashmap并向其中添加了三组键值对。
java遍历方式
java遍历方式Java中遍历的方式有很多种，这里列举一些常见的遍历方法：1. 遍历数组：```javafor (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}```2. 遍历链表：```javafor (Node<String> node : list) {System.out.println(node.data);}```3. 遍历树：public void traverseTree(TreeNode<String> node) {if (node == null) {return;}System.out.println(node.data);traverseTree(node.left);traverseTree(node.right);}```4. 遍历HashMap：```javafor (Map.Entry<String, String> entry : map.entrySet()) {System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());}```5. 遍历Set：for (String item : set) {System.out.println(item);}```6. 遍历文件系统：```javaimport java.io.File;for (File file : directory.listFiles()) {if (file.isDirectory()) {System.out.println("Directory: " + file.getName());traverseDirectory(file);} else {System.out.println("File: " + file.getName());}}```这些只是Java中遍历方式的一部分，根据实际需求和数据结构，还有其他更多的遍历方法可供选择。
java linkedlist 方法
Java LinkedList 类提供了许多方法，用于操作链表。
以下是一些常用的LinkedList 方法：1. add(E e)：在链表末尾添加元素e。
2. add(int index, E element)：在指定位置index 插入元素element。
3. addFirst(E e)：在链表头部添加元素e。
4. addLast(E e)：在链表尾部添加元素e。
5. clear()：移除链表中的所有元素。
6. contains(Object o)：判断链表中是否包含元素o。
7. containsAll(Collection<?> c)：判断链表中是否包含集合c 中的所有元素。
8. get(int index)：获取链表中指定位置index 的元素。
9. getFirst()：获取链表头部的元素。
10. getLast()：获取链表尾部的元素。
11. remove(Object o)：移除链表中第一个出现的指定元素o。
12. remove(int index)：移除链表中指定位置index 的元素。
13. removeFirst()：移除链表头部的元素。
14. removeLast()：移除链表尾部的元素。
15. size()：返回链表中元素的个数。
16. isEmpty()：判断链表是否为空。
17. isSingleton()：判断链表是否只有一个元素。
18. poll()：移除并返回链表头部的元素，如果链表为空则返回null。
19. pop()：移除并返回链表尾部的元素，如果链表为空则抛出NoSuchElementException 异常。
20. peek()：返回链表头部的元素，但不移除，如果链表为空则返回null。
21. push(E e)：将元素e 添加到链表头部。
22. offer(E e)：将元素e 添加到链表尾部，如果成功则返回true，否则返回false。
23. removeFirstOccurrence(Object o)：移除链表中第一个出现的指定元素o。
Java常见的七种查找算法
Java常见的七种查找算法1. 基本查找也叫做顺序查找，说明：顺序查找适合于存储结构为数组或者链表。
基本思想：顺序查找也称为线形查找，属于无序查找算法。
从数据结构线的一端开始，顺序扫描，依次将遍历到的结点与要查找的值相比较，若相等则表示查找成功；若遍历结束仍没有找到相同的，表示查找失败。
示例代码：public class A01_BasicSearchDemo1 {public static void main(String[] args){//基本查找/顺序查找//核心：//从0索引开始挨个往后查找//需求：定义一个方法利用基本查找，查询某个元素是否存在//数据如下：{131, 127, 147, 81, 103, 23, 7, 79}int[] arr ={131,127,147,81,103,23,7,79};int number =82;System.out.println(basicSearch(arr, number));}//参数：//一：数组//二：要查找的元素//返回值：//元素是否存在public static boolean basicSearch(int[] arr,int number){//利用基本查找来查找number在数组中是否存在for(int i =0; i < arr.length; i++){if(arr[i]== number){return true;}}return false;}}2. 二分查找也叫做折半查找，说明：元素必须是有序的，从小到大，或者从大到小都是可以的。
如果是无序的，也可以先进行排序。
但是排序之后，会改变原有数据的顺序，查找出来元素位置跟原来的元素可能是不一样的，所以排序之后再查找只能判断当前数据是否在容器当中，返回的索引无实际的意义。
基本思想：也称为是折半查找，属于有序查找算法。
用给定值先与中间结点比较。
比较完之后有三种情况：•相等说明找到了•要查找的数据比中间节点小说明要查找的数字在中间节点左边•要查找的数据比中间节点大说明要查找的数字在中间节点右边代码示例：package com.itheima.search;public class A02_BinarySearchDemo1 {public static void main(String[] args){//二分查找/折半查找//核心：//每次排除一半的查找范围//需求：定义一个方法利用二分查找，查询某个元素在数组中的索引//数据如下：{7, 23, 79, 81, 103, 127, 131, 147}int[] arr ={7,23,79,81,103,127,131,147};System.out.println(binarySearch(arr,150));}public static int binarySearch(int[] arr,int number){//1.定义两个变量记录要查找的范围int min =0;int max = arr.length-1;//2.利用循环不断的去找要查找的数据while(true){if(min > max){return-1;}//3.找到min和max的中间位置int mid =(min + max)/2;//4.拿着mid指向的元素跟要查找的元素进行比较if(arr[mid]> number){//4.1 number在mid的左边//min不变，max = mid - 1；max = mid -1;}else if(arr[mid]< number){//4.2 number在mid的右边//max不变，min = mid + 1;min = mid +1;}else{//4.3 number跟mid指向的元素一样//找到了return mid;}}}}3. 插值查找在介绍插值查找之前，先考虑一个问题：为什么二分查找算法一定要是折半，而不是折四分之一或者折更多呢？其实就是因为方便，简单，但是如果我能在二分查找的基础上，让中间的mid点，尽可能靠近想要查找的元素，那不就能提高查找的效率了吗？二分查找中查找点计算如下：mid=(low+high)/2, 即mid=low+1/2*(high-low);我们可以将查找的点改进为如下：mid=low+(key-a[low])/(a[high]-a[low])*(high-low)，这样，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。
JAVA数据结构——单链表的操作
单链表的操作方法一：package ch02;(1)建立结点类Node.javapublic class Node {public Object data;//存放结点数据值public Node next;//存放后继结点//无参构造函数public Node(){ this(null,null);}//只有结点值的构造函数public Node(Object data){ this(data,null);}//带有节点值和后继结点的构造函数public Node(Object data,Node next){ this.data=data;this.next=next;}}(2)建立链表及操作LinkList.javapackage ch02;import java.util.Scanner;public class LinkList implements IList{public Node head;//单链表的头指针//构造函数初始化头结点public LinkList(){head=new Node();}//构造函数构造长度为n的单链表public LinkList(int n,boolean Order) throws Exception{ this();if(Order)create1(n); //头插法顺序建立单链表elsecreate2(n); //尾插法逆序建立单链表}//头插法顺序建立单链表public void create1(int n) throws Exception{Scanner sc=new Scanner(System.in);System.out.println("请输入结点的数据(头插法)：”)；for(int i=0;i<n;i++){insert(0,sc.next());}}//尾插法逆序建立单链表public void create2(int n) throws Exception{Scanner sc=new Scanner(System.in);System. out.println("请输入结点的数据(尾插法)：");for(int i=0;i<n;i++){insert(length(),sc.next());}}//将链表置空public void clear(){head.data=null;head.next=null;}//判断链表是否为空public boolean isEmpty(){return head.next==null;}//返回链表长度public int length(){Node p=head.next;int length=0;while(p!=null){p=p.next;length++;//返回P不空长度length加1}return length;}//读取并返回第i个位置的数据元素public Object get(int i) throws Exception {Node p=head.next;int j;//从首结点开始向后查找，直到9指向第i个结点或者p为nullfor(j=0;j<i&&p!=null;j++){ p=p.next;}if(j>i||p==null)//i不合法时抛出异常throw new Exception("第"+i+”个数据元素不存在”)；return p.data;}//插入乂作为第i个元素public void insert(int i, Object x) throws Exception{ Node p=head;int j=-1;//寻找第i个结点的前驱i-1while(p!=null&&j<i-1){p=p.next;j++;}if(j>i-l||p==null)//i不合法时抛出异常throw new Exception("插入位置不合法”)；Node s=new Node(x);s.next=p.next;p.next=s;}//删除第i个元素public void remove(int i) throws Exception{ Node p=head;int j=-1;while(p!=null&&j<i-1){//寻找第i-1 个节点p=p.next;j++;}if(j>i-1||p.next==null)throw new Exception("删除位置不合法”)；p.next=p.next.next;}//返回元素x首次出现的位序号public int indexOf(Object x) {Node p=head.next;int j=0;while(p!=null&&!p.data.equals(x)){p=p.next;j++;if(p!=null)return j;elsereturn -1;}public void display(){Node p=head.next;while(p!=null){if(p.next==null)System.out.print(p.data);elseSystem.out.print(p.data+"f );p=p.next;}}}(3)建立测试类Test.javappublic class test {public static void main(String[] args) throws Exception { // TODO Auto-generated method stubScanner sc=new Scanner(System.in);boolean or;int xz,xx;System.out.println("请选择插入的方法：0、头插法，1、尾插法");xz=sc.nextInt();if(xz!=0)or=true;elseor=false;System. out.println("请插入的结点的个数：”)；xx=sc.nextInt();LinkList L=new LinkList(xx,or);System.out.println("建立的链表为：");L.display();System.out.println();System.out.println("链表的长度："+L.length());System. out.println(”请输入查找的结点的数据：”)；Object x=sc.next();int position=L.indexOf(x);System.out.println("结点的数据为："+x+"的位置为："+position); System. out.println("请输入删除的结点的位置：”)；int sr=sc.nextInt();L.remove(sr);L.display();System.out.println();System.out.println("链表的长度："+L.length()); }品P rob I em & J a vs d oc / Declaration Q Error Log 里Con sole-M、、■=：termin8ted> test [3] [Java Application] C U &ert\Ad im i n i st rat o r\Ap p Data\L o cs I请选择插入.的方法：0、头插法，lv星插法请插入的特点的个数：请愉入结点的颓据(尾插法)：A B C E D F建立的旌表为；A+B T C+E T D+F链表的长度：6请输入查找的结点的数据:结点的数据为：E的位置为：3请输入删除的结点的位置,R+B T E+DW道表的长度：S方法二(引入get和set方法)Package sy;import java.util.Scanner;//单链表的结点类public class Node {private Object data; //存放结点值private Node next; //后继结点的引用public Node() { //无参数时的构造函数this(null, null);}public Node(Object data) { // 构造值为data 的结点this(data, null);}public Node(Object data, Node next) {//构造值为data 和next 的结点构造函数this.data = data;this.next = next;}public Object getData() { return data;}public void setData(Object data) {this.data = data;}public Node getNext() { return next;public void setNext(Node next) { this.next = next;}}//实现链表的基本操作类public class LinkList {Node head=new Node();//生成一个带头结点的空链表//根据输入的一系列整数，以0标志结束，用头插法建立单链表public void creat() throws Exception {Scanner sc = new Scanner(System.in); //构造用于输入的对象for (int x=sc.nextInt(); x!=0; x=sc.nextInt()) //输入若干个数据元素的值(以0结束) insert(0, x);//生成新结点,插入到表头}//返回带头结点的单链表中第i个结点的数据域的值。
图解Java数据结构之环形链表
图解Java数据结构之环形链表本篇⽂章介绍数据结构中的环形链表。
介绍环形链表，类似于单链表，也是⼀种链式存储结构，环形链表由单链表演化过来。
单链表的最后⼀个结点的链域指向NULL，⽽环形链表的建⽴，不要专门的头结点，让最后⼀个结点的链域指向链表结点。
简单点说链表⾸位相连，组成环状数据结构。
如下图结构：⽽在环形链表中，最为著名的即是约瑟夫环问题。
约瑟夫环问题问题介绍：设编号为1、2、3、... 、n的n个⼈围坐⼀圈，约定编号为k(1<=k<=n)的⼈从1开始报数，数到m的那个⼈出列，它的下⼀位⼜从1开始报数，数到m的那个⼈⼜出列。
依次类推，直到所有⼈出列为⽌，由此产⽣⼀个出队编号的序列。
我们可以举个例⼦来分析⼀下：假设⼀共有5个⼈，即n = 5；从第⼀个⼈开始报数，即k = 1；数到2的⼈出列，即m = 2。
⽰意图如下：出队列的顺序即为：2 -> 4 -> 1 -> 5 -> 3那么我们⾸先得构建出⼀个单向的环形链表。
实现分析：1. 先创建第⼀个节点，让first指向该节点，并形成环状2. 每创建⼀个新的节点就将该节点加⼊到已有的环形链表中分析完毕，我们⽤代码实现⼀下：//创建⼀个环形的单向链表class CircleSingleLinkedList {// 创建⼀个first节点，当前没有编号private Boy first = null;// 添加节点，构建成⼀个环形链表System.out.println("数据错误");return;}// 定义辅助节点Boy curBoy = null;// 使⽤循环创建环形链表for (int i = 1; i <= nums; i++) {// 根据编号创建节点Boy boy = new Boy(i);// 如果是第⼀个节点if (i == 1) {first = boy;first.setNext(first);curBoy = first;// 让curBoy指向第⼀个节点，帮助构建链表} else {curBoy.setNext(boy);boy.setNext(first);// 使其指向第⼀个节点，形成环状curBoy = boy;// curBoy后移}}}// 遍历当前环形链表public void list() {// 判断链表是否空if (first == null) {System.out.println("链表为空");return;}// 定义辅助节点Boy curBoy = first;while (true) {System.out.println("节点编号:" + curBoy.getNo());if (curBoy.getNext() == first) {// 此时说明遍历完毕break;}curBoy = curBoy.getNext();// curBoy后移}}}//创建⼀个Boy类，表⽰⼀个节点class Boy {private int no;// 编号private Boy next;// 指向下⼀个节点public Boy(int no) {this.no = no;}public int getNo() {return no;}public void setNo(int no) {this.no = no;}public Boy getNext() {return next;}public void setNext(Boy next) {this.next = next;}}这样就实现了⼀个环形链表，接下来测试⼀下：public static void main(String[] args) {CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList(); circleSingleLinkedList.addBoy(5);circleSingleLinkedList.list();}运⾏结果：节点编号:1运⾏结果也是没有问题的，接下来便是⽣成出圈序列。
linkedlist的常用方法
linkedlist的常用方法链表（LinkedList）是一种数据结构，具有非常独特的特性，它以节点为单位存储数据，每个节点都有一个指向下一个节点的指针，可以非常方便的进行数据的插入和删除操作。
在Java中，LinkedList是Java Collection Frameworks中比较常用的一种数据结构，下面就来介绍一下LinkedList的常用方法。
一、添加元素1. add(E e)：在链表末尾添加元素e。
2. addFirst(E e)：在链表头部添加元素e。
3. addLast(E e)：与add(E e)一样，在链表末尾添加元素e。
4. add(int index, E e)：在指定索引位置index处添加元素e。
二、获取元素1. get(int index)：获取指定索引位置index处的元素。
2. getFirst()：获取链表头部的元素。
3. getLast()：获取链表末尾的元素。
三、删除元素1. remove()：删除并返回链表首个元素。
2. removeFirst()：删除并返回链表头部元素。
3. removeLast()：删除并返回链表末尾元素。
4. remove(int index)：删除指定索引位置index处的元素。
5. remove(Object o)：删除链表中的元素o。
四、其他操作1. size()：获取链表中元素个数。
2. clear()：清空链表中所有元素。
3. contains(Object o)：判断链表中是否包含元素o。
4. iterator()：返回一个迭代器，可以迭代访问所有元素。
5. toArray()：将链表转换为数组。
注：add()方法可以直接添加任意类型的元素，不受类型限制。
链表的特点是元素可以任意添加、删除，这种特点在实际程序开发中的应用广泛。
比如Java中的栈、队列、双向队列就是基于LinkedList实现的。
另外，链表与数组的区别在于索引访问速度，链表的访问速度比数组慢。
链表排序（冒泡、选择、插入、快排、归并、希尔、堆排序）
链表排序（冒泡、选择、插⼊、快排、归并、希尔、堆排序）这篇⽂章分析⼀下链表的各种排序⽅法。
以下排序算法的正确性都可以在LeetCode的这⼀题检测。
本⽂⽤到的链表结构如下（排序算法都是传⼊链表头指针作为参数，返回排序后的头指针）struct ListNode {int val;ListNode *next;ListNode(int x) : val(x), next(NULL) {}};插⼊排序（算法中是直接交换节点，时间复杂度O（n^2）,空间复杂度O（1））class Solution {public:ListNode *insertionSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.if(head == NULL || head->next == NULL)return head;ListNode *p = head->next, *pstart = new ListNode(0), *pend = head;pstart->next = head; //为了操作⽅便，添加⼀个头结点while(p != NULL){ListNode *tmp = pstart->next, *pre = pstart;while(tmp != p && p->val >= tmp->val) //找到插⼊位置{tmp = tmp->next; pre = pre->next;}if(tmp == p)pend = p;else{pend->next = p->next;p->next = tmp;pre->next = p;}p = pend->next;}head = pstart->next;delete pstart;return head;}};选择排序（算法中只是交换节点的val值，时间复杂度O（n^2）,空间复杂度O（1））class Solution {public:ListNode *selectSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.//选择排序if(head == NULL || head->next == NULL)return head;ListNode *pstart = new ListNode(0);pstart->next = head; //为了操作⽅便，添加⼀个头结点ListNode*sortedTail = pstart;//指向已排好序的部分的尾部while(sortedTail->next != NULL){ListNode*minNode = sortedTail->next, *p = sortedTail->next->next;//寻找未排序部分的最⼩节点while(p != NULL){if(p->val < minNode->val)minNode = p;p = p->next;}swap(minNode->val, sortedTail->next->val);sortedTail = sortedTail->next;}head = pstart->next;delete pstart;return head;}};快速排序1（算法只交换节点的val值，平均时间复杂度O（nlogn）,不考虑递归栈空间的话空间复杂度是O（1））这⾥的partition我们参考(选取第⼀个元素作为枢纽元的版本，因为链表选择最后⼀元素需要遍历⼀遍)，具体可以参考这⾥我们还需要注意的⼀点是数组的partition两个参数分别代表数组的起始位置，两边都是闭区间，这样在排序的主函数中：void quicksort(vector<int>&arr, int low, int high){if(low < high){int middle = mypartition(arr, low, high);quicksort(arr, low, middle-1);quicksort(arr, middle+1, high);}}对左边⼦数组排序时，⼦数组右边界是middle-1，如果链表也按这种两边都是闭区间的话，找到分割后枢纽元middle，找到middle-1还得再次遍历数组，因此链表的partition采⽤前闭后开的区间（这样排序主函数也需要前闭后开区间），这样就可以避免上述问题class Solution {public:ListNode *quickSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.//链表快速排序if(head == NULL || head->next == NULL)return head;qsortList(head, NULL);return head;}void qsortList(ListNode*head, ListNode*tail){//链表范围是[low, high)if(head != tail && head->next != tail){ListNode* mid = partitionList(head, tail);qsortList(head, mid);qsortList(mid->next, tail);}}ListNode* partitionList(ListNode*low, ListNode*high){//链表范围是[low, high)int key = low->val;ListNode* loc = low;for(ListNode*i = low->next; i != high; i = i->next)if(i->val < key){loc = loc->next;swap(i->val, loc->val);}swap(loc->val, low->val);return loc;}};快速排序2（算法交换链表节点，平均时间复杂度O（nlogn）,不考虑递归栈空间的话空间复杂度是O（1））这⾥的partition，我们选取第⼀个节点作为枢纽元，然后把⼩于枢纽的节点放到⼀个链中，把不⼩于枢纽的及节点放到另⼀个链中，最后把两条链以及枢纽连接成⼀条链。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
java链表常用方法
Java链表常用方法
链表是一种常见的数据结构，在Java中也有相应的实现类LinkedList。
链表由一系列节点组成，每个节点都包含数据和指向下一个节点的引用。
下面将介绍一些Java链表常用的方法。
1. 添加元素
- addFirst(E e)：在链表的开头添加一个元素。
- addLast(E e)：在链表的末尾添加一个元素。
- add(int index, E element)：在指定位置插入一个元素。
例如：
```java
LinkedList<String> linkedList = new LinkedList<>();
linkedList.addFirst("A");
linkedList.addLast("C");
linkedList.add(1, "B");
```
2. 删除元素
- removeFirst()：删除链表开头的元素。
- removeLast()：删除链表末尾的元素。
- remove(int index)：删除指定位置的元素。
- remove(Object o)：删除链表中第一次出现的指定元素。
例如：
```java
LinkedList<String> linkedList = new LinkedList<>(); linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
linkedList.removeFirst();
linkedList.removeLast();
linkedList.remove(0);
linkedList.remove("B");
```
3. 获取元素
- getFirst()：获取链表开头的元素。
- getLast()：获取链表末尾的元素。
- get(int index)：获取指定位置的元素。
例如：
```java
LinkedList<String> linkedList = new LinkedList<>(); linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
String first = linkedList.getFirst();
String last = linkedList.getLast();
String element = linkedList.get(1);
```
4. 修改元素
- set(int index, E element)：将指定位置的元素替换为新的元素。
例如：
```java
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
linkedList.set(1, "D");
```
5. 判断元素是否存在
- contains(Object o)：判断链表中是否包含指定元素。
例如：
```java
linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
boolean containsA = linkedList.contains("A");
```
6. 获取链表大小
- size()：返回链表的大小，即元素的个数。
例如：
```java
LinkedList<String> linkedList = new LinkedList<>(); linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
int size = linkedList.size();
```
7. 清空链表
- clear()：清空链表中的所有元素。
例如：
```java
linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
linkedList.clear();
```
这些是Java链表中常用的方法，通过这些方法可以对链表进行添加、删除、获取、修改等操作。
链表的灵活性使得它在某些场景下比数组更加适用，例如需要频繁插入和删除元素的情况。
在实际的开发中，根据具体的需求选择合适的数据结构是非常重要的。