Java LinkedList

最新推荐文章于 2023-07-06 15:20:57 发布
最新推荐文章于 2023-07-06 15:20:57 发布
阅读量188 收藏 1
点赞数
文章标签： java 链表 数据结构 python redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiaoge66/article/details/115607564
版权

Java LinkedList

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

链表可分为单向链表和双向链表。

一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。

img

一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。

img

Java LinkedList（链表） 类似于 ArrayList，是一种常用的数据容器。

与 ArrayList 相比，LinkedList 的增加和删除对操作效率更高，而查找和修改的操作效率较低。

以下情况使用 ArrayList :

  • 频繁访问列表中的某一个元素。
  • 只需要在列表末尾进行添加和删除元素操作。

以下情况使用 LinkedList :

  • 你需要通过循环迭代来访问列表中的某些元素。
  • 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

LinkedList 继承了 AbstractSequentialList 类。

LinkedList 实现了 Queue 接口，可作为队列使用。

LinkedList 实现了 List 接口，可进行列表的相关操作。

LinkedList 实现了 Deque 接口，可作为队列使用。

LinkedList 实现了 Cloneable 接口，可实现克隆。

LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-djqu1Npx-1618149041131)(C:\Users\李银桥\AppData\Roaming\Typora\typora-user-images\image-20210411213441216.png)]

LinkedList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

// 引入 LinkedList 类
import java.util.LinkedList; 

LinkedList<E> list = new LinkedList<E>();   // 普通创建方法
或者
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表

创建一个简单的链表实例：

// 引入 LinkedList 类

import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites);
    }
}

以上实例，执行输出结果为：

[Google, Runoob, Taobao, Weibo]

更多的情况下我们使用 ArrayList 访问列表中的随机元素更加高效，但以下几种情况 LinkedList 提供了更高效的方法。

在列表开头添加元素：

// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        // 使用 addFirst() 在头部添加元素
        sites.addFirst("Wiki");
        System.out.println(sites);
    }
}

以上实例，执行输出结果为：

[Wiki, Google, Runoob, Taobao]

在列表结尾添加元素：

// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        // 使用 addLast() 在尾部添加元素
        sites.addLast("Wiki");
        System.out.println(sites);
    }
}

以上实例，执行输出结果为：

[Google, Runoob, Taobao, Wiki]

在列表开头移除元素：

// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 removeFirst() 移除头部元素
        sites.removeFirst();
        System.out.println(sites);
    }
}

以上实例，执行输出结果为：

[Runoob, Taobao, Weibo]

在列表结尾移除元素：】

// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 removeLast() 移除尾部元素
        sites.removeLast();
        System.out.println(sites);
    }
}

以上实例，执行输出结果为：

[Google, Runoob, Taobao]

获取列表开头的元素：

// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 getFirst() 获取头部元素
        System.out.println(sites.getFirst());
    }
}

以上实例，执行输出结果为：

Google

获取列表结尾的元素：

// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 getLast() 获取尾部元素
        System.out.println(sites.getLast());
    }
}

以上实例，执行输出结果为：

Weibo

迭代元素

我们可以使用 for 配合 size() 方法来迭代列表中的元素：

// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        for (int size = sites.size(), i = 0; i < size; i++) {
            System.out.println(sites.get(i));
        }
    }
}

size() 方法用于计算链表的大小。

以上实例，执行输出结果为：

Google
Runoob
Taobao
Weibo

也可以使用 for-each 来迭代元素：

// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        for (String i : sites) {
            System.out.println(i);
        }
    }
}

以上实例，执行输出结果为：

Google
Runoob
Taobao
Weibo

常用方法

方法描述
public boolean add(E e)链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public void add(int index, E element)向指定位置插入元素。
public boolean addAll(Collection c)将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。
public boolean addAll(int index, Collection c)将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。
public void addFirst(E e)元素添加到头部。
public void addLast(E e)元素添加到尾部。
public boolean offer(E e)向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public boolean offerFirst(E e)头部插入元素，返回是否成功，成功为 true，失败为 false。
public boolean offerLast(E e)尾部插入元素，返回是否成功，成功为 true，失败为 false。
public void clear()清空链表。
public E removeFirst()删除并返回第一个元素。
public E removeLast()删除并返回最后一个元素。
public boolean remove(Object o)删除某一元素，返回是否成功，成功为 true，失败为 false。
public E remove(int index)删除指定位置的元素。
public E poll()删除并返回第一个元素。
public E remove()删除并返回第一个元素。
public boolean contains(Object o)判断是否含有某一元素。
public E get(int index)返回指定位置的元素。
public E getFirst()返回第一个元素。
public E getLast()返回最后一个元素。
public int indexOf(Object o)查找指定元素从前往后第一次出现的索引。
public int lastIndexOf(Object o)查找指定元素最后一次出现的索引。
public E peek()返回第一个元素。
public E element()返回第一个元素。
public E peekFirst()返回头部元素。
public E peekLast()返回尾部元素。
public E set(int index, E element)设置指定位置的元素。
public Object clone()克隆该列表。
public Iterator descendingIterator()返回倒序迭代器。
public int size()返回链表元素个数。
public ListIterator listIterator(int index)返回从指定位置开始到末尾的迭代器。
public Object[] toArray()返回一个由链表元素组成的数组。
public T[] toArray(T[] a)返回一个由链表元素转换类型而成的数组。

Java HashSet

HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。

HashSet 允许有 null 值。

HashSet 是无序的，即不会记录插入的顺序。

HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。

HashSet 实现了 Set 接口。
在这里插入图片描述

HashSet 中的元素实际上是对象，一些常见的基本类型可以使用它的包装类。

基本类型对应的包装类表如下：

基本类型引用类型
booleanBoolean
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter

HashSet 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.HashSet; // 引入 HashSet 类

以下实例我们创建一个 HashSet 对象 sites，用于保存字符串元素：

HashSet<String> sites = new HashSet<String>();

添加元素

HashSet 类提供类很多有用的方法，添加元素可以使用 add() 方法:

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");  // 重复的元素不会被添加
        System.out.println(sites);
    }
}

执行以上代码，输出结果如下：

[Google, Runoob, Zhihu, Taobao]

在上面的实例中，Runoob 被添加了两次，它在集合中也只会出现一次，因为集合中的每个元素都必须是唯一的。

判断元素是否存在

我们可以使用 contains() 方法来判断元素是否存在于集合当中:

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");  // 重复的元素不会被添加
        System.out.println(sites.contains("Taobao"));
    }
}

执行以上代码，输出结果如下：

true

删除元素

我们可以使用 remove() 方法来删除集合中的元素:

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        sites.remove("Taobao");  // 删除元素，删除成功返回 true，否则为 false
        System.out.println(sites);
    }
}

执行以上代码，输出结果如下：

[Google, Runoob, Zhihu]

删除集合中所有元素可以使用 clear 方法：

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        sites.clear();  
        System.out.println(sites);
    }
}

执行以上代码，输出结果如下：

[]

计算大小

如果要计算 HashSet 中的元素数量可以使用 size() 方法：

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        System.out.println(sites.size());  
    }
}

执行以上代码，输出结果如下：

4

迭代 HashSet

可以使用 for-each 来迭代 HashSet 中的元素。

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        for (String i : sites) {
            System.out.println(i);
        }
    }
}

执行以上代码，输出结果如下：

Google
Runoob
Zhihu
Taobao

更多 API 方法可以查看：https://www.runoob.com/manual/jdk11api/java.base/java/util/HashSet.html

Scala Map(映射)

Map(映射)是一种可迭代的键值对（key/value）结构。

所有的值都可以通过键来获取。

Map 中的键都是唯一的。

Map 也叫哈希表（Hash tables）。

Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。

默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类

在 Scala 中 你可以同时使用可变与不可变 Map，不可变的直接使用 Map，可变的使用 mutable.Map。以下实例演示了不可变 Map 的应用：

// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()

// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

定义 Map 时，需要为键值对定义类型。如果需要添加 key-value 对，可以使用 + 号，如下所示：

A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)

Map 基本操作

Scala Map 有三个基本操作：

方法描述
keys返回 Map 所有的键(key)
values返回 Map 所有的值(value)
isEmpty在 Map 为空时返回true

实例

以下实例演示了以上三个方法的基本应用：

object Test {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000",
                       "azure" -> "#F0FFFF",
                       "peru" -> "#CD853F")

      val nums: Map[Int, Int] = Map()

      println( "colors 中的键为 : " + colors.keys )
      println( "colors 中的值为 : " + colors.values )
      println( "检测 colors 是否为空 : " + colors.isEmpty )
      println( "检测 nums 是否为空 : " + nums.isEmpty )
   }
}

执行以上代码，输出结果为：

$ scalac Test.scala 
$ scala Test
colors 中的键为 : Set(red, azure, peru)
colors 中的值为 : MapLike(#FF0000, #F0FFFF, #CD853F)
检测 colors 是否为空 : false
检测 nums 是否为空 : true

Map 合并

你可以使用 ++ 运算符或 Map.++() 方法来连接两个 Map，Map 合并时会移除重复的 key。以下演示了两个 Map 合并的实例:

object Test {
   def main(args: Array[String]) {
      val colors1 = Map("red" -> "#FF0000",
                        "azure" -> "#F0FFFF",
                        "peru" -> "#CD853F")
      val colors2 = Map("blue" -> "#0033FF",
                        "yellow" -> "#FFFF00",
                        "red" -> "#FF0000")

      //  ++ 作为运算符
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )

      //  ++ 作为方法
      colors = colors1.++(colors2)
      println( "colors1.++(colors2) : " + colors )

   }
}

执行以上代码，输出结果为：

$ scalac Test.scala 
$ scala Test
colors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)
colors1.++(colors2) : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

输出 Map 的 keys 和 values

以下通过 foreach 循环输出 Map 中的 keys 和 values：

object Test {
   def main(args: Array[String]) {
      val sites = Map("runoob" -> "http://www.runoob.com",
                       "baidu" -> "http://www.baidu.com",
                       "taobao" -> "http://www.taobao.com")

      sites.keys.foreach{ i =>  
                           print( "Key = " + i )
                           println(" Value = " + sites(i) )}
   }
}

执行以上代码，输出结果为：

$ scalac Test.scala 
$ scala Test
Key = runoob Value = http://www.runoob.com
Key = baidu Value = http://www.baidu.com
Key = taobao Value = http://www.taobao.com

查看 Map 中是否存在指定的 Key

你可以使用 Map.contains 方法来查看 Map 中是否存在指定的 Key。实例如下：

object Test {
   def main(args: Array[String]) {
      val sites = Map("runoob" -> "http://www.runoob.com",
                       "baidu" -> "http://www.baidu.com",
                       "taobao" -> "http://www.taobao.com")

      if( sites.contains( "runoob" )){
           println("runoob 键存在，对应的值为 :"  + sites("runoob"))
      }else{
           println("runoob 键不存在")
      }
      if( sites.contains( "baidu" )){
           println("baidu 键存在，对应的值为 :"  + sites("baidu"))
      }else{
           println("baidu 键不存在")
      }
      if( sites.contains( "google" )){
           println("google 键存在，对应的值为 :"  + sites("google"))
      }else{
           println("google 键不存在")
      }
   }
}

执行以上代码，输出结果为：

$ scalac Test.scala 
$ scala Test
runoob 键存在，对应的值为 :http://www.runoob.com
baidu 键存在，对应的值为 :http://www.baidu.com
google 键不存在

Scala Map 方法

下表列出了 Scala Map 常用的方法：

序号方法及描述
1**def ++(xs: Map[(A, B)]): Map[A, B]**返回一个新的 Map，新的 Map xs 组成
2**def -(elem1: A, elem2: A, elems: A*): Map[A, B]**返回一个新的 Map, 移除 key 为 elem1, elem2 或其他 elems。
3**def --(xs: GTO[A]): Map[A, B]**返回一个新的 Map, 移除 xs 对象中对应的 key
4**def get(key: A): Option[B]**返回指定 key 的值
5**def iterator: Iterator[(A, B)]**创建新的迭代器，并输出 key/value 对
6def addString(b: StringBuilder): StringBuilder将 Map 中的所有元素附加到StringBuilder，可加入分隔符
7def addString(b: StringBuilder, sep: String): StringBuilder将 Map 中的所有元素附加到StringBuilder，可加入分隔符
8def apply(key: A): B返回指定键的值，如果不存在返回 Map 的默认方法
9def clear(): Unit清空 Map
10**def clone(): Map[A, B]**从一个 Map 复制到另一个 Map
11def contains(key: A): Boolean如果 Map 中存在指定 key，返回 true，否则返回 false。
12def copyToArray(xs: Array[(A, B)]): Unit复制集合到数组
13def count(p: ((A, B)) => Boolean): Int计算满足指定条件的集合元素数量
14def default(key: A): B定义 Map 的默认值，在 key 不存在时返回。
15**def drop(n: Int): Map[A, B]**返回丢弃前n个元素新集合
16**def dropRight(n: Int): Map[A, B]**返回丢弃最后n个元素新集合
17**def dropWhile(p: ((A, B)) => Boolean): Map[A, B]**从左向右丢弃元素，直到条件p不成立
18**def empty: Map[A, B]**返回相同类型的空 Map
19def equals(that: Any): Boolean如果两个 Map 相等(key/value 均相等)，返回true，否则返回false
20def exists(p: ((A, B)) => Boolean): Boolean判断集合中指定条件的元素是否存在
21**def filter(p: ((A, B))=> Boolean): Map[A, B]**返回满足指定条件的所有集合
22**def filterKeys(p: (A) => Boolean): Map[A, B]**返回符合指定条件的不可变 Map
23**def find(p: ((A, B)) => Boolean): Option[(A, B)]**查找集合中满足指定条件的第一个元素
24def foreach(f: ((A, B)) => Unit): Unit将函数应用到集合的所有元素
25**def init: Map[A, B]**返回所有元素，除了最后一个
26def isEmpty: Boolean检测 Map 是否为空
27**def keys: Iterable[A]**返回所有的key/p>
28**def last: (A, B)**返回最后一个元素
29**def max: (A, B)**查找最大元素
30**def min: (A, B)**查找最小元素
31def mkString: String集合所有元素作为字符串显示
32**def product: (A, B)**返回集合中数字元素的积。
33**def remove(key: A): Option[B]**移除指定 key
34def retain(p: (A, B) => Boolean): Map.this.type如果符合满足条件的返回 true
35def size: Int返回 Map 元素的个数
36**def sum: (A, B)**返回集合中所有数字元素之和
37**def tail: Map[A, B]**返回一个集合中除了第一元素之外的其他元素
38**def take(n: Int): Map[A, B]**返回前 n 个元素
39**def takeRight(n: Int): Map[A, B]**返回后 n 个元素
40**def takeWhile(p: ((A, B)) => Boolean): Map[A, B]**返回满足指定条件的元素
41**def toArray: Array[(A, B)]**集合转数组
42**def toBuffer[B >: A]: Buffer[B]**返回缓冲区，包含了 Map 的所有元素
43**def toList: List[A]**返回 List，包含了 Map 的所有元素
44**def toSeq: Seq[A]**返回 Seq，包含了 Map 的所有元素
45**def toSet: Set[A]**返回 Set，包含了 Map 的所有元素
46def toString(): String返回字符串对象

笔记

使用 ++ 或则 .++() 方法合并两个 Map。

需要注意的是: 如果 Map 中存在相同的 key，合并后的 Map 中的 value 会被最右边的 Map 的值所代替。

var suit1 = Map("red"->"#FFF","blue"->"#FED","yellow"->"#00F","green"->"#0F0")
var suit2 = Map("red"->"#FF1","green"->"#1F1")
var suit3 = suit1++suit2
println("the value of suit1 is:" +suit1)
println("the value of suit2 is:" +suit2)
println("the value of after ++ is:" +suit3)
println("the value of after .++() is:" +suit1.++(suit2))

结果：

the value of suit1 is:Map(red -> #FFF, blue -> #FED, yellow -> #00F, green -> #0F0)
the value of suit2 is:Map(red -> #FF1, green -> #1F1)
the value of after ++ is:Map(red -> #FF1, blue -> #FED, yellow -> #00F, green -> #1F1)
the value of after .++() is:Map(red -> #FF1, blue -> #FED, yellow -> #00F, green -> #1F1)

Java Hashtable 类

Hashtable是原始的java.util的一部分， 是一个Dictionary具体的实现 。

然而，Java 2 重构的Hashtable实现了Map接口，因此，Hashtable现在集成到了集合框架中。它和HashMap类很相似，但是它支持同步。

像HashMap一样，Hashtable在哈希表中存储键/值对。当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。

然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。

Hashtable定义了四个构造方法。第一个是默认构造方法：

Hashtable()

第二个构造函数创建指定大小的哈希表：

Hashtable(int size)

第三个构造方法创建了一个指定大小的哈希表，并且通过fillRatio指定填充比例。

填充比例必须介于0.0和1.0之间，它决定了哈希表在重新调整大小之前的充满程度：

Hashtable(int size,float fillRatio)

第四个构造方法创建了一个以M中元素为初始化元素的哈希表。

哈希表的容量被设置为M的两倍。

Hashtable(Map m)

Hashtable中除了从Map接口中定义的方法外，还定义了以下方法：

序号方法描述
1void clear( ) 将此哈希表清空，使其不包含任何键。
2Object clone( ) 创建此哈希表的浅表副本。
3boolean contains(Object value) 测试此映射表中是否存在与指定值关联的键。
4boolean containsKey(Object key) 测试指定对象是否为此哈希表中的键。
5boolean containsValue(Object value) 如果此 Hashtable 将一个或多个键映射到此值，则返回 true。
6Enumeration elements( ) 返回此哈希表中的值的枚举。
7Object get(Object key) 返回指定键所映射到的值，如果此映射不包含此键的映射，则返回 null. 更确切地讲，如果此映射包含满足 (key.equals(k)) 的从键 k 到值 v 的映射，则此方法返回 v；否则，返回 null。
8boolean isEmpty( ) 测试此哈希表是否没有键映射到值。
9Enumeration keys( ) 返回此哈希表中的键的枚举。
10Object put(Object key, Object value) 将指定 key 映射到此哈希表中的指定 value。
11void rehash( ) 增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素。
12Object remove(Object key) 从哈希表中移除该键及其相应的值。
13int size( ) 返回此哈希表中的键的数量。
14String toString( ) 返回此 Hashtable 对象的字符串表示形式，其形式为 ASCII 字符 ", " （逗号加空格）分隔开的、括在括号中的一组条目。

实例

下面的程序说明这个数据结构支持的几个方法：

import java.util.*;

public class HashTableDemo {

   public static void main(String args[]) {
      // Create a hash map
      Hashtable balance = new Hashtable();
      Enumeration names;
      String str;
      double bal;

      balance.put("Zara", new Double(3434.34));
      balance.put("Mahnaz", new Double(123.22));
      balance.put("Ayan", new Double(1378.00));
      balance.put("Daisy", new Double(99.22));
      balance.put("Qadir", new Double(-19.08));

      // Show all balances in hash table.
      names = balance.keys();
      while(names.hasMoreElements()) {
         str = (String) names.nextElement();
         System.out.println(str + ": " +
         balance.get(str));
      }
      System.out.println();
      // Deposit 1,000 into Zara's account
      bal = ((Double)balance.get("Zara")).doubleValue();
      balance.put("Zara", new Double(bal+1000));
      System.out.println("Zara's new balance: " +
      balance.get("Zara"));
   }
}

以上实例编译运行结果如下：

Qadir: -19.08
Zara: 3434.34
Mahnaz: 123.22
Daisy: 99.22
Ayan: 1378.0

Zara's new balance: 4434.34
So Young007
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java集合之LinkedList
骑着猪猪去旅行的博客
10-30 2293
LinkedList是实现了List和Deque接口的双向链表，实现了所有可选列表的操作，允许存放所有元素（包括null）
Java中的LinkedList
weixin_52758364的博客
01-16 2018
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
LinkedList用法详解
热门推荐
韩家老大的博客
06-21 1万+
一、LinkedList介绍
【Java】链表LinkedList
qq_61635026的博客
07-06 5749
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。 数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。
剑指offer（Java实现） 从上往下打印二叉树
一只特立独行的猪
09-15 200
题目描述 从上往下打印出二叉树的每个节点，同层节点从左至右打印。 解题思路 利用队列（链表）辅助实现。 代码实现 import java.util.ArrayList; import java.util.LinkedList; /** public class TreeNode { int val = 0; TreeNode left = null; TreeNode r...
Java LinkedList教程
最新发布
08-23
Java LinkedList教程
java linkedlist
10-10
about single linked list, using java programming language. modify some error.
JAVA LinkedList和ArrayList的使用及性能分析
09-04
JAVA LinkedList和ArrayList的使用及性能分析，这篇文章也是以JAVA List的总结。
Java LinkedList集合功能实例解析
08-19
主要介绍了Java LinkedList集合功能实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
LinkedList常用方法
weixin_58696998的博客
04-20 1669
一、介绍 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。链表可分为单向链表和双向链表。 LinkedList和ArrayList的区别 Java LinkedList（链表） 类似于 ArrayList，是一种常用的数据容器。 与 ArrayList 相比，LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。 以下情况使用 ArrayList : 频繁访问列表中的某一个元素。
Java基础之LinkedList
qq_45344586的博客
04-09 1295
Java基础之LinkedList
Java集合之LinkedList详解
qq_39939541的博客
06-25 1166
例如containsAll、removeAll、retainAll等方法，这些方法可以被ArrayList直接继承和使用，从而避免了重复实现这些操作。同时，AbstractCollection也提供了一些抽象方法，例如size、iterator、toArray等方法，这些方法需要由具体的集合类去实现，LinkedList也需要实现这些方法以完成自身的功能。AbstractList是List接口的一个抽象实现，实现了List接口的大部分方法，包括添加、删除、获取元素、遍历等。
简谈LinkedList特有的方法
Star_RainSea的博客
01-19 3221
一、什么是LinkedList集合 二、LinkedList集合特有的方法
java之 LinkedList详解
xinning的博客
04-24 644
LinkedList （双向链表结构） (1)LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 (2)LinkedList 实现 List 接口，能对它进行队列操作。 (3)LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。 (4)LinkedList 实现了Clone...
Java中的LinkedList集合详解
明璐花生牛奶的博客
12-15 4207
LinkedList集合 基础概念 可以在任何位置高效插入和删除的一个有序序列，简而言之就是数据结构里的链表。 我们都清楚在链表很容易进行插入和删除，但是我们在使用c/c++的时候需要新建一个链表项的结构体并且需要在里面设置指针，java不需要指针，java在这方面就很好的为程序员消除了这个问题。使用LinkedList类就可以解决问题。 如下代码将实现先添加3个元素，然后将第二个元素删除的操作，方便快捷So easy~ import java.util.*; public class pred { pu
Java的LinkedList
BASK2312的博客
05-08 222
分别实现了 Queue 接口，可作为队列使用；List 接口，可进行列表的相关操作；Deque 接口，可作为队列使用；java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。Java的LinkedList（链表） 类似于 ArrayList，是一种常用的数据容器。更多的情况下我们使用 ArrayList 访问列表中的随机元素更加高效，但。: 当前节点的值和一个指向下一个节点的链接。: 数值、向后的节点链接、向前的节点链接。链表可分为单向链表和双向链表。
Java LinkedList详解
qq_35939417的博客
01-24 1674
简介 LinkedList是List接口的实现类，这意味着它可以根据索引来随机访问集合中的元素。除此之外，LinkedList还实现了Deque接口，可以被当成双端队列来使用，因此既可以被当成“栈”来使用，也可以当成队列使用。 LinkedList不是线程安全的，如果想使用线程安全的LinkedList，可以通过如下方式实现： List list = Collections.synchronizedList(new LinkedList()); 内部结构 LinkedList的内部结构是一个双向链表。如下
Java【链表】详细图解/ 模拟实现+【LinkedList】常用方法介绍
yzhcjl_的博客
02-12 1389
以上就是今天分享的关于数据结构中【链表】的内容，一方面介绍了如何模拟实现简易的单链表，一方面介绍了Java集合框架中的 LInkedList 类的基本使用，并且分析了链表和顺序表的区别对比上山总比下山辛苦下篇文章见。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值