Analysieren Sie den Beispielcode für die Java-Datenstruktur

Aufzählungsschnittstelle (Enumeration)

Obwohl die Aufzählungsschnittstelle (Enumeration) selbst keine Datenstruktur ist, wird sie häufig in der Kategorie anderer Datenstrukturen verwendet. Die Enumeration-Schnittstelle definiert eine Möglichkeit, aufeinanderfolgende Elemente aus einer Datenstruktur abzurufen. Die Aufzählung definiert beispielsweise eine Methode namens nextElement, die verwendet wird, um das nächste Element einer Datenstruktur abzurufen, die mehrere Elemente enthält.

Diese traditionelle Schnittstelle wurde durch Iterator ersetzt. Obwohl die Aufzählung nicht aufgegeben wurde, wird sie in modernem Code selten verwendet. Dennoch wird es neben einigen API-Klassen auch in Methoden verwendet, die von traditionellen Klassen wie Vector und Properties definiert werden, und ist in Anwendungen weit verbreitet. Die folgende Tabelle fasst einige durch Enumeration deklarierte Methoden zusammen:

Seriennummer	Methoden und Beschreibungen
1	boolean hasMoreElements( ), testet, ob diese Enumeration mehr Elemente enthält
2	Objekt nextElement (), wenn für dieses Aufzählungsobjekt mindestens ein Element verfügbar ist, wird das nächste Element dieser Aufzählung zurückgegeben

BitSet

Die Bit Set-Klasse implementiert einen Satz von Bits oder Flags , die einzeln gesetzt und gelöscht werden können. Diese Klasse ist sehr nützlich, wenn Sie mit einer Reihe boolescher Werte arbeiten. Sie müssen lediglich jedem Wert ein „Bit“ zuweisen und das Bit dann entsprechend setzen oder löschen, um den booleschen Wert zu bearbeiten.

Eine Bitset-Klasse erstellt einen speziellen Array-Typ zum Speichern von Bitwerten. Die Größe des Arrays in BitSet erhöht sich nach Bedarf. Dies ähnelt einem Vektor aus Bits. Dies ist eine traditionelle Klasse, die jedoch in Java 2 komplett neu gestaltet wurde.

BitSet definiert zwei Konstruktionsmethoden :

// 第一个构造方法创建一个默认的对象：
public BitSet()
// 第二个方法允许用户指定初始大小。所有位初始化为0
public BitSet(int nbits)

Die in der in BitSet implementierten Cloneable-Schnittstelle definierten Methoden sind in der folgenden Tabelle aufgeführt: #🎜 🎜#

SeriennummerMethode und Anleitung1#🎜 🎜 #2#🎜🎜 # void andNot(BitSet set), löscht alle Bits in diesem BitSet und die entsprechenden Bits wurden im angegebenen BitSet gesetzt 3#🎜🎜 #int cardinality( ), gibt die Anzahl der Ziffern zurück, die in diesem BitSet auf true gesetzt sind. void clear( ) , gibt dieses BitSet zurück Alle Bits auf false setzenvoid clear(int index) , setze das Bit am angegebenen Index auf false#🎜🎜 # 6void clear(int startIndex, int endIndex), ändern Sie den angegebenen startIndex (einschließlich) in den angegebenen toIndex (exklusiv) innerhalb des Bereichs Das Bit ist auf false gesetzt7Object clone( ), kopiert dieses BitSet und generiert ein neues BitSet, das ihm entspricht#🎜 🎜# # 🎜 🎜#9void flip(int index) , setzt das Bit am angegebenen Index auf das Komplement seines aktuellen Werts 10 # 🎜🎜#boolean get(int index) , gibt den Bitwert am angegebenen Index zurück #🎜 🎜# 12BitSet get(int startIndex, int endIndex), gibt ein neues BitSet zurück, das aus Bits im Bereich von fromIndex (einschließlich) bis toIndex (exklusiv) in diesem BitSet besteht#🎜 🎜## 🎜🎜#13int hashCode( ), gibt den Hash-Codewert dieses Bitsatzes zurück # 🎜🎜# 14 #🎜🎜 #15boolean isEmpty( ), wenn dieses BitSet keine auf true gesetzten Bits enthält, wird true zurückgegebenint length( ), gibt die „logische Größe“ dieses BitSets zurück: der Index des höchsten gesetzten Bits im BitSet plus 117int nextClearBit(int startIndex) , gibt den Index des ersten auf false gesetzten Bits zurück, das am oder nach dem angegebenen Startindex auftritt #🎜🎜 ## 🎜🎜#18int nextSetBit(int startIndex), gibt den Index des ersten auf true gesetzten Bits zurück, das am angegebenen Startindex oder am nachfolgenden Index auftritt 19void or(BitSet bitSet), führe eine logische ODER-Operation für die Bitsatz- und Bitsatzparameter aus#🎜 🎜#20void set(int index), setzt das Bit am angegebenen Index auf true#🎜🎜 #void set(int index, boolean v), setzt das Bit am angegebenen Index auf den angegebenen Wert # 🎜🎜#void set(int startIndex, int endIndex), setzt die Bits im Bereich vom angegebenen fromIndex (einschließlich) bis zum angegebenen toIndex (exklusiv) auf true#🎜🎜 #2324int size( ), gibt die Anzahl der Bits des tatsächlich verwendeten Speicherplatzes zurück, wenn dieses BitSet den Bitwert darstellt#🎜🎜 ##🎜🎜 #25String toString( ), gibt die String-Darstellung dieses Bitsatzes zurück void xor(BitSet bitSet), führt eine logische XOR-Operation für das Bitset und die Bitset-Parameter aus

实例：

public class Test {
    public static void main(String args[]) throws IOException {
        BitSet bits1 = new BitSet(16);
        BitSet bits2 = new BitSet(16);
        // 设置一些位
        for(int i=0; i<16; i++) {
            if((i%2) == 0) bits1.set(i);
            if((i%5) != 0) bits2.set(i);
        }
        System.out.println("位集合1初始模式: ");
        System.out.println(bits1);
        System.out.println("\n位集合2初始模式: ");
        System.out.println(bits2);
        // 对此目标位 set 和参数位 set 执行逻辑与操作
        bits2.and(bits1);
        System.out.println("\n位集合2 与 位集合1 执行逻辑与操作 ");
        System.out.println(bits2);
        // 对此位 set 和位 set 参数执行逻辑或操作
        bits2.or(bits1);
        System.out.println("\n位集合2 与 位集合1 执行逻辑或操作: ");
        System.out.println(bits2);
        // 对此位 set 和位 set 参数执行逻辑异或操作
        bits2.xor(bits1);
        System.out.println("\n位集合2 与 位集合1 执行逻辑异或操作 ");
        System.out.println(bits2);
    }
}
// 程序编译运行结果如下：
// 位集合1初始模式: 
// {0, 2, 4, 6, 8, 10, 12, 14}
// 位集合2初始模式: 
// {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}
// 位集合2 与 位集合1 执行逻辑与操作 
// {2, 4, 6, 8, 12, 14}
// 位集合2 与 位集合1 执行逻辑或操作: 
// {0, 2, 4, 6, 8, 10, 12, 14}
// 位集合2 与 位集合1 执行逻辑异或操作 
// {}

向量（Vector）

向量（Vector）类和传统数组非常相似，但是Vector的大小能根据需要动态的变化。和数组一样，Vector对象的元素也能通过索引访问。使用Vector类最主要的好处就是在创建对象的时候不必给对象指定大小，它的大小会根据需要动态的变化。

Vector 与 ArrayList的区别：

• Vector 是同步访问的，所以线程就会安全，但是同时也会带来弊端就是效率就会降低，但 Arraylist 恰恰相反，这也就导致Arraylist的效率比 Vector 高。

• 在进行扩容时，Vector 会增长为原来数组长的一倍，而 Arraylist 只会增长为原来的一半，所以Arraylist节约内存空间。

• Vector 包含了许多传统的方法，这些方法不属于集合框架。

Vector 类支持 4 种构造方法：

// 第一种构造方法创建一个默认的向量，默认大小为 10
Vector()
// 第二种构造方法创建指定大小的向量
Vector(int size)
// 第三种构造方法创建指定大小的向量，并且增量用 incr 指定。增量表示向量每次增加的元素数目
Vector(int size,int incr)
// 第四种构造方法创建一个包含集合 c 元素的向量
Vector(Collection c)

除了从父类继承的方法外 Vector 还定义了以下方法：

void and(BitSet set), logische UND-Verknüpfung für diesen Zielbitsatz und Parameterbitsatz durchführen
	4
	5
8	boolean equal(Object bitSet) Vergleicht dieses Objekt mit dem angegebenen Objekt
void flip(int startIndex, int endIndex), setzt jedes Bit im Bereich vom angegebenen fromIndex (einschließlich) bis zum angegebenen toIndex (exklusiv) auf das Komplement seines aktuellen Werts #🎜🎜 ##🎜 🎜#	11
boolean intersects(BitSet bitSet), wenn im angegebenen BitSet ein Bit auf true gesetzt ist und es in diesem BitSet auch auf true gesetzt ist, dann true zurückgeben
	# 🎜🎜#16
#🎜 🎜 #
	# 🎜🎜#
	21# 🎜🎜#
#🎜🎜 #22
void set(int startIndex, int endIndex, boolean v), setzt die Bits im Bereich vom angegebenen fromIndex (einschließlich) bis zum angegebenen toIndex (exklusiv) Für den angegebenen Wert #🎜🎜 #
#🎜 🎜#26#🎜 🎜#

?? int minCapacity) Erhöhen Sie die Kapazität dieses Vektors (falls erforderlich), um sicherzustellen, dass er mindestens die durch den Parameter „Mindestkapazität“ angegebene Anzahl von Komponenten aufnehmen kann zu diesem Vektor für GleichheitObject firstElement() , gibt die erste Komponente dieses Vektors zurück (das Element bei Index 0) Object get(int index) , gibt das Element bei zurück angegebene Position im Vektor int hashCode() , gibt den Hash-Codewert dieses Vektors zurück int indexOf(Object elem) , gibt den Index des ersten Vorkommens des angegebenen Elements zurück Wenn dieser Vektor in diesem Vektor dieses Element nicht enthält, wird -1 zurückgegeben vorwärts vom Index, wenn das Element kein gefundenes Element ist, gebe -1 zurückvoid insertElementAt(Object obj, int index), füge das angegebene Objekt als Komponente in diesem Vektor am angegebenen Index einboolean isEmpty(), Testet, ob dieser Vektor keine Komponenten enthält Object lastElement() , gibt die letzte Komponente dieses Vektors zurück int lastIndexOf(Object elem) , gibt die zurück letztes Vorkommen des angegebenen Elements in diesem Vektor. Der Index von. Wenn das Element nicht gefunden wird, wird -1 zurückgegeben 27Boolean Remove(Object o) , Remove Das erste Vorkommen des angegebenen Elements in diesem Vektor Wenn der Vektor das Element nicht enthält, bleibt das Element unverändert 28Boolean RemoveAll(Collection c) , Entfernt aus diesem Vektor alle Elemente, die im angegebenen Collection-Element enthalten sind 29void removeAllElements(), entfernt alle Komponenten aus diesem Vektor und setzt seine Größe auf Null 30boolean removeElement(Object obj) , Entfernt den th der Variablen aus diesem Vektor. Eine (kleinste indizierte) Übereinstimmung 31void removeElementAt(int index) , entfernt die Komponente am angegebenen Index 32protected void removeRange(int fromIndex, int toIndex ), aus diesem Vektor. Entfernen Sie alle Elemente, deren Index zwischen fromIndex (einschließlich) und toIndex (exklusiv) liegt 34Object set(int index, Object element) , ersetzen Sie das Element an der angegebenen Position in diesem Vektor durch das angegebene Element 35void setElementAt(Object obj, int index) , geben Sie diesen Vektor am Index an Komponenten werden auf das angegebene Objekt gesetzt 36void setSize(int newSize) , legt die Größe dieses Vektors fest 37int size() , gibt die Anzahl der Komponenten in diesem Vektor zurück 38 List subList(int fromIndex, int toIndex), gibt eine Teilansicht dieser Liste zurück, die Elemente reichen von fromIndex (einschließlich) bis toIndex (exklusiv) 39Object[] toArray(), gibt zurück ein Array, das alle Elemente in diesem Vektor in der richtigen Reihenfolge enthält

Seriennummer	Methode und Beschreibung
1	void add(int index, Object element) , füge das angegebene Element an der angegebenen Position dieses Vektors ein
2	boolean add(Object o) , fügt das angegebene Element am Ende dieses Vektors hinzu
3	boolean addAll(Collection c) , fügt alle Elemente in der angegebenen Sammlung am Ende dieses Vektors hinzu und fügt sie in der vom Iterator zurückgegebenen Reihenfolge hinzu des angegebenen Sammlungselements
4	boolean addAll(int index, Collection c) , füge alle Elemente in der angegebenen Sammlung an der angegebenen Position in diesen Vektor ein
5	void addElement(Object obj) , Die angegebenen Komponenten werden am Ende dieses Vektors eingefügt, wodurch seine Größe um 1
6	int Capacity() erhöht wird und die aktuelle Kapazität dieses Vektors zurückgegeben wird
7	void clear() , entfernen alle Elemente aus diesem Vektor
8	Object clone() , gibt eine Kopie des Vektors zurück
9	boolean enthält(Object elem) , gibt true zurück, wenn dieser Vektor das angegebene Element enthält
10	boolean containsAll(Collection c), gibt true zurück, wenn dieser Vektor alle Elemente in der angegebenen Collection enthält
11	void copyInto(Object[] anArray), kopiert die Komponenten dieses Vektors in das angegebene Array
	16
	17
	18
	19
	21
	22
	23
	24
40	Object[] toArray(Object[] a) ，返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型
41	String toString() ，返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式
42	void trimToSize() ，对此向量的容量进行微调，使其等于向量的当前大小

实例：

public class Test {
    public static void main(String args[]) throws IOException {
        // 初始大小为3，增量为2
        Vector v = new Vector(3, 2);
        System.out.println("初始大小: " + v.size());
        System.out.println("初始容量: " + v.capacity());
        v.addElement(new Integer(1));
        v.addElement(new Double(5.45));
        v.addElement(new Double(6.08));
        v.addElement(new Integer(7));
        System.out.println("四次添加后的容量: " + v.capacity());
        v.addElement(new Float(9.4));
        System.out.println("当前容量: " + v.capacity());
        v.addElement(new Integer(10));
        System.out.println("当前容量: " + v.capacity());
        System.out.println("第一元素: " + (Integer)v.firstElement());
        System.out.println("最后一个元素: " + (Integer)v.lastElement());
        v.addElement(new Integer(3));
        // 向量包含3
        if(v.contains(new Integer(3))) {
            System.out.println("向量包含 3");
        }
        // 列举向量中的元素
        Enumeration vEnum = v.elements();
        System.out.println("\n向量中的元素:");
        while(vEnum.hasMoreElements()) {
            System.out.print(vEnum.nextElement() + " ");
        }
        System.out.println();
    }
}
// 程序编译运行结果如下：
// 初始大小: 0
// 初始容量: 3
// 四次添加后的容量: 5
// 当前容量: 5
// 当前容量: 7
// 第一元素: 1
// 最后一个元素: 10
// 向量包含 3
// 向量中的元素:
// 1 5.45 6.08 7 9.4 10 3

栈（Stack）

栈（Stack）实现了一个后进先出（LIFO）的数据结构。你可以把栈理解为对象的垂直分布的栈，当你添加一个新元素时，就将新元素放在其他元素的顶部。当你从栈中取元素的时候，就从栈顶取一个元素。换句话说，最后进栈的元素最先被取出。

栈是Vector的一个子类，栈只定义了默认构造函数，用来创建一个空栈。栈除了包括由Vector定义的所有方法，也定义了自己的一些方法：

序号	方法及说明
1	boolean empty() ，测试栈是否为空
2	Object peek( ) ，查看栈顶部的对象，但不从栈中移除它
3	Object pop( ) ，移除栈顶部的对象，并作为此函数的值返回该对象
4	Object push(Object element) ，把项压入堆栈顶部
5	int search(Object element) ，返回对象在堆栈中的位置，以 1 为基数

字典（Dictionary）

字典（Dictionary） 类是一个抽象类，它定义了键映射到值的数据结构。当你想要通过特定的键而不是整数索引来访问数据的时候，这时候应该使用Dictionary。由于Dictionary类是抽象类，所以它只提供了键映射到值的数据结构，而没有提供特定的实现。

Dictionary类已经过时了。在实际开发中，你可以实现 Map 接口来获取键/值的存储功能。

哈希表（Hashtable）

Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。例如，在地址列表的哈希表中，你可以根据邮政编码作为键来存储和排序数据，而不是通过人名。哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。

Hashtable是原始的java.util的一部分， 是一个Dictionary具体的实现 。然而，Java 2 重构的Hashtable实现了 Map 接口，因此，Hashtable 现在集成到了集合框架中。它和HashMap类很相似，但是它支持同步。

像HashMap一样，Hashtable在哈希表中存储键/值对。当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。

Hashtable定义了四个构造方法：

// 默认构造方法
public Hashtable()
// 创建指定大小的哈希表
public Hashtable(int initialCapacity)
// 创建了一个指定大小的哈希表，并且通过fillRatio指定填充比例
// 填充比例必须介于0.0和1.0之间，它决定了哈希表在重新调整大小之前的充满程度
public Hashtable(int initialCapacity, float loadFactor)
// 创建了一个以 t 中元素为初始化元素的哈希表，哈希表的容量被设置为 t 的两倍
public Hashtable(Map<? extends K, ? extends V> t)

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

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

属性（Properties）

Properties 继承于 Hashtable。Properties 类表示了一个持久的属性集。属性列表中每个键及其对应值都是一个字符串。Properties 类被许多Java类使用。例如，在获取环境变量时它就作为System.getProperties()方法的返回值。

Properties 定义如下实例变量.这个变量持有一个 Properties 对象相关的默认属性列表：

protected Properties defaults;

Properties类定义了两个构造方法：

// 第一个构造方法没有默认值
public Properties()
// 第二个构造方法使用propDefault 作为默认值
public Properties(Properties defaults)

除了从 Hashtable 中所定义的方法，Properties 还定义了以下方法：

序号	方法及说明
1	String getProperty(String key)， 用指定的键在此属性列表中搜索属性
2	String getProperty(String key, String defaultProperty)，用指定的键在属性列表中搜索属性
3	void list(PrintStream streamOut)，将属性列表输出到指定的输出流
4	void list(PrintWriter streamOut)，将属性列表输出到指定的输出流
5	void load(InputStream streamIn) throws IOException，从输入流中读取属性列表（键和元素对）
6	Enumeration propertyNames( )，按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）
7	Object setProperty(String key, String value)，调用 Hashtable 的方法 put
8	void store(OutputStream streamOut, String description)，以适合使用 load(InputStream)方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流

Das obige ist der detaillierte Inhalt vonAnalysieren Sie den Beispielcode für die Java-Datenstruktur. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!