18、Java中的 数据结构
Java2中引入了新的数据结构 集合框架 Collection,下一节再谈论(非常重要,面试也常问).
1、枚举 (Enumeration)
1.1 Enumeration
源码：
public interface Enumeration<E> {
boolean hasMoreElements();
E nextElement();
}
Enumeration接口中定义了一些方法，通过这些方法可以枚举（一次获得一个）对象集合中的元素。
这种传统接口已被迭代器取代，虽然Enumeration 还未被遗弃，但在现代代码中已经被很少使用了。尽管如此，它还是使用在诸如Vector和Properties这些传统类所定义的方法中
实例1 ：
import java.util.Vector;
import java.util.Enumeration; public class EnumerationTester { public static void main(String args[]) {
Enumeration<String> days;
Vector<String> dayNames = new Vector<String>();
dayNames.add("Sunday");
dayNames.add("Monday");
dayNames.add("Tuesday");
dayNames.add("Wednesday");
dayNames.add("Thursday");
dayNames.add("Friday");
dayNames.add("Saturday");
days = dayNames.elements();
while (days.hasMoreElements()){
System.out.println(days.nextElement());
}
}
}
以上实例编译运行结果如下：
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
实例2：
{
Map map = request.getParameterMap();
java.util.Enumeration enum=this.getRequest().getParameterNames();
while ( enum.hasMoreElements()){
String paramName = (String) enum.nextElement();
String[] values = request.getParameterValues(paramName);
for (int i = 0; i < values.length; i++) {
System.out.println("[" + i + "] " + paramName + " " + values[i]);
}
}
//形成键值对应的map
map.put(paramName, paramValue);
}
1.2 枚举类
Java中的枚举其实是一种语法糖，在 JDK 1.5之后出现，用来表示固定且有限个的对象。比如一个季节类有春、夏、秋、冬四个对象；一个星期有星期一到星期日七个对象。这些明显都是固定的，且有限个。
枚举类和普通类的区别
①、使用 enum 定义的枚举类默认继承 java.lang.Enum 类，即枚举类是不能再继承别的类了。而普通类的一般父类默认是 Object
②、枚举类的构造器只能使用 private 定义，而普通类的还可以用 public 修饰
③、枚举类的所有实例必须在枚举类中显示列出（，分隔 ；结尾），列出的实例系统会默认自动添加 public static final 修饰
④、所有的枚举类都提供了一个 values() 方法，可以用来遍历枚举值
实例：
package cn.fage.enums; /**
* @author lin
* @version 1.0
* @date 2020-06-19 17:11
* @Description TODO
*/
public enum SeasonTwoArgs { /**
* 春天
*/
SPRING(1, "春天"),
SUMMER(2, "夏天"),
AUTUMN(3, "秋天"),
WINTER(4, "冬天"); int key;
String msg; SeasonTwoArgs(int key, String season) {
this.key = key;
this.msg = season;
System.out.println("初始化:" + this.name() + "," + this.msg + "," + season);
} // 很多情况，我们可能从前端拿到的值是枚举类的 key ，然后就可以通过以下静态方法获取到对应枚举值
public static SeasonTwoArgs valueofKey(Integer key) {
for (SeasonTwoArgs season : SeasonTwoArgs.values()) {
if (season.key == key) {
return season;
}
}
throw new IllegalArgumentException("No element matches " + key);
} public String getMsg() {
return msg;
} public int getKey() {
return key;
} public void setKey(int key) {
this.key = key;
} public void setMsg(String msg) { this.msg = msg;
} public static void main(String[] args) {
SeasonTwoArgs autumn = SeasonTwoArgs.AUTUMN;
System.out.println("autumn.getKey() = " + autumn.getKey());
System.out.println("autumn.getMsg() = " + autumn.getMsg());
System.out.println("autumn = " + autumn); }
}
运行结果如下所示：
初始化:SPRING,春天,春天
初始化:SUMMER,夏天,夏天
初始化:AUTUMN,秋天,秋天
初始化:WINTER,冬天,冬天
autumn.getKey() = 3
autumn.getMsg() = 秋天
autumn = AUTUMN
枚举类是最完美的单例模式
2、位集合 (BitSet)
一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。这和位向量（vector of bits）比较类似。
这是一个传统的类，但它在Java 2中被完全重新设计。
BitSet定义了两个构造方法。
第一个构造方法创建一个默认的对象：
BitSet()
第二个方法允许用户指定初始大小。所有位初始化为0。
BitSet(int size)
实例：
package cn.fage.three; import java.util.BitSet; /**
* @author lin
* @version 1.0
* @date 2020-07-10 14:00
* @Description TODO
*/
public class BitSetDemo {
public static void main(String[] args) {
BitSet bits1 = new BitSet(16);
BitSet bits2 = new BitSet(16);
// set some bits
for (int i = 0; i < 16; i++) {
if ((i % 2) == 0) {
bits1.set(i);
}
if ((i % 5) != 0) {
bits2.set(i);
}
}
System.out.println("bits1.length() = " + bits1.length());
System.out.println("bits2.length() = " + bits2.length());
System.out.println("bits1.get(4) = " + bits1.get(0));
System.out.println("bits2.get(4) = " + bits2.get(0));
System.out.println("bits1 = " + bits1);
System.out.println("bits2 = " + bits2); // void and(BitSet set)
// 对此目标位 set 和参数位 set 执行逻辑与操作, (最大位)
// bits2.and(bits1);
// System.out.println(bits1);
// System.out.println(bits2); // void andNot(BitSet set)
// 清除此 BitSet 中所有的位，其相应的位在指定的 BitSet 中已设置 (去重)
// bits2.andNot(bits1);
// System.out.println(bits1);
// System.out.println(bits2); //int cardinality( )
//返回此 BitSet 中设置为 true 的位数
// System.out.println(bits1.cardinality());
// System.out.println(bits2.cardinality()); //void clear( )
//将此 BitSet 中的所有位设置为 false
// bits1.clear();
// System.out.println(bits1);
// System.out.println(bits2); // void clear(int index)
// 将索引指定处的位设置为 false
// bits1.clear(2);
// System.out.println(bits1);
// System.out.println(bits2); // void clear(int startIndex, int endIndex)
// 将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的位设置为 false
//前开后闭
// bits1.clear(2,6);
// System.out.println(bits1);
// System.out.println(bits2); // Object clone( )
// 复制此 BitSet，生成一个与之相等的新 BitSet
//boolean equals(Object bitSet)
// 将此对象与指定的对象进行比较
// BitSet bits3 = (BitSet) bits1.clone();
// System.out.println(bits3);
// System.out.println(bits3.equals(bits1)); //void flip(int index)
// 将指定索引处的位设置为其当前值的补码
// bits1.flip(0);
// bits1.flip(2);
// bits1.flip(3);
// System.out.println(bits1);
// System.out.println(bits2); //boolean get(int index)
// 将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的每个位设置为其当前值的补码
// 返回指定索引处的位值
// System.out.println(bits1.get(4));
// System.out.println(bits1.get(5)); //BitSet get(int startIndex, int endIndex)
// 返回一个新的 BitSet，它由此 BitSet 中从 fromIndex（包括）到 toIndex（不包括）范围内的位组成
// BitSet bits3=bits1.get(2,6);
// System.out.println(bits3); //int hashCode( )
// 返回此位 set 的哈希码值
// System.out.println(bits1.hashCode());
// System.out.println(bits1.hashCode()); //boolean intersects(BitSet bitSet)
// 如果指定的 BitSet 中有设置为 true 的位，并且在此 BitSet 中也将其设置为 true，则返回 true
/*BitSet bits3 = new BitSet(16);
System.out.println(bits3);
bits3.set(0);
System.out.println(bits3.intersects(bits1));
System.out.println(bits3.intersects(bits2));
System.out.println(bits1);
System.out.println(bits2);
System.out.println(bits3);*/ //boolean isEmpty( )
// 如果此 BitSet 中没有包含任何设置为 true 的位，则返回 true
// bits1.clear();
// System.out.println(bits1);
// System.out.println(bits1.isEmpty()); //... //OR bits
// 对此位 set 和位 set 参数执行逻辑或操作
// bits2.or(bits1);
// System.out.println("bits2 OR bits1: ");
// System.out.println(bits2); //返回此 BitSet 表示位值时实际使用空间的位数
// System.out.println(bits1.size()); // System.out.println(bits1.toString());
// 对此位 set 和位 set 参数执行逻辑异或操作
// bits1.xor(bits2);
// System.out.println(bits1); }
}
3、向量 (Vector)
Vector（向量）是 java.util 包中的一个类，该类实现了类似动态数组的功能。
向量和数组相似，都可以保存一组数据（数据列表）。但是数组的大小是固定的，一旦指定，就不能改变，而向量却提供了一种类似于“动态数组”的功能，向量与数组的重要区别之一就是向量的容量是可变的。
构造方法：
1 创建一个默认的向量，默认大小为 10：
Vector()
2 创建指定大小的向量。
Vector(int size)
3 创建指定大小的向量，并且增量用 incr 指定。增量表示向量每次增加的元素数目。
Vector(int size,int incr)
4 创建一个包含集合 c 元素的向量：
Vector(Collection c)
实例：
package cn.fage.three; import java.util.Enumeration;
import java.util.Vector; /**
* @author lin
* @version 1.0
* @date 2020-07-10 14:57
* @Description TODO
*/
public class TestVectorDemo { public static void main(String args[]) {
// initial size is 3, increment is 2
Vector v = new Vector(3, 2);
System.out.println("Initial size: " + v.size());
System.out.println("Initial capacity: " +
v.capacity());
v.addElement(new Integer(1));
v.addElement(new Integer(2));
v.addElement(new Integer(3));
v.addElement(new Integer(4));
System.out.println("Capacity after four additions: " +
v.capacity()); v.addElement(new Double(5.45));
System.out.println("Current capacity: " +
v.capacity());
v.addElement(new Double(6.08));
v.addElement(new Integer(7));
System.out.println("Current capacity: " +
v.capacity());
v.addElement(new Float(9.4));
v.addElement(new Integer(10));
System.out.println("Current capacity: " +
v.capacity());
v.addElement(new Integer(11));
v.addElement(new Integer(12));
System.out.println("First element: " +
(Integer) v.firstElement());
System.out.println("Last element: " +
(Integer) v.lastElement());
if (v.contains(new Integer(3)))
System.out.println("Vector contains 3.");
// enumerate the elements in the vector.
Enumeration vEnum = v.elements();
System.out.println("\nElements in vector:");
while (vEnum.hasMoreElements()) {
System.out.print(vEnum.nextElement() + " ");
}
System.out.println();
}
}
以上运行如下所示：
Initial size: 0
Initial capacity: 3
Capacity after four additions: 5
Current capacity: 5
Current capacity: 7
Current capacity: 9
First element: 1
Last element: 12
Vector contains 3. Elements in vector:
1 2 3 4 5.45 6.08 7 9.4 10 11 12
4、栈 (Stack)
栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
堆栈只定义了默认构造函数，用来创建一个空栈。堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。
Stack()
1.栈（Stack）的介绍
栈是一个先入后出（FILO：First In Last Out）的有序列表。
栈（Stack）是限制线性表中元素的插入和删除只能在同一端进行的一种特殊线性表。
允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶
而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
实例：
package cn.fage.three; import java.util.EmptyStackException;
import java.util.Stack; /**
* @author lin
* @version 1.0
* @date 2020-07-10 15:00
* @Description TODO
*/
public class TestStackDemo { static void showpush(Stack<Integer> st, int a) {
st.push(new Integer(a));
System.out.println("push(" + a + ")");
System.out.println("stack: " + st);
} static void showpop(Stack<Integer> st) {
System.out.print("pop -> ");
Integer a = (Integer) st.pop();
System.out.println(a);
System.out.println("stack: " + st);
} public static void main(String args[]) {
Stack<Integer> st = new Stack<Integer>();
System.out.println("stack: " + st);
showpush(st, 42);
showpush(st, 66);
showpush(st, 99);
showpop(st);
showpop(st);
showpop(st);
try {
showpop(st);
} catch (EmptyStackException e) {
System.out.println("empty stack");
}
}
}
以上运行如下所示：
stack: []
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop -> 99
stack: [42, 66]
pop -> 66
stack: [42]
pop -> 42
stack: []
5、字典 (Dictionary)
Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。
给出键和值，你就可以将值存储在Dictionary对象中。一旦该值被存储，就可以通过它的键来获取它。所以和Map一样， Dictionary 也可以作为一个键/值对列表。
Dictionary类已经过时了。在实际开发中，你可以[实现Map接口来获取键/值的存储功能。
6、哈希表 (Hashtable)
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。
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
7、属性 (Properties)
java.util.Properties 继承于 Hashtable ，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时， System.getProperties 方法就是返回一个 Properties 对象。
特点：
Properties类是Hashtable的子类，所以Map集合中的方法都可以使用。
Properties集合是没有泛型的，所有的key和value值都是字符串。
有和流技术结合的方法，是唯一可以和IO流结合的集合类，当与流结合时可以永久存储数据，其他集合只能暂时存储。
Properties与别的集合的区别是它能保存到流里或者在流中加载，属性列表的每一个键和值都是字符串。
常用方法
添加/修改
setProperty(String key,String value);
getProperty(String key)
在这个属性列表中搜索指定的键的属性。
load(InputStream inStream)
从输入字节流中读取属性列表（键和元素对）。
load(Reader reader)
新建一个test.txt文件.
name=张三
age=18
county=杭州
package FileAndIO; import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
import java.util.Set; public class PropertiesDemo {
public static void main(String[] args) throws IOException {
//创建properties对象和文件输入流对象
Properties properties = new Properties();
FileInputStream fileInputStream = new FileInputStream("Demo//test.txt");
//用load方法传入输入流对象
properties.load(fileInputStream);
//用stringPropertyNames方法获取所有key，存入set集合中
Set<String> keys = properties.stringPropertyNames();
//遍历set集合，打印获取到的键值对
for (String key : keys) {
System.out.println(key+":"+properties.getProperty(key));
}
}
}
发哥讲
如果你觉得文章还不错，就请点击右上角选择发送给朋友或者转发到朋友圈~
● 扫码关注公众号
18、Java中的 数据结构的更多相关文章
- java中的数据结构（集合|容器）
对java中的数据结构做一个小小的个人总结,虽然还没有到研究透彻jdk源码的地步.首先.java中为何需要集合的出现?什么需求导致.我想对于面向对象来说,对象适用于描述任何事物,所以为了方便对于对象的 ...
- ［转]详细介绍java中的数据结构
详细介绍java中的数据结构 本文介绍的是java中的数据结构,本文试图通过简单的描述,向读者阐述各个类的作用以及如何正确使用这些类.一起来看本文吧! 也许你已经熟练使用了java.util包里面的各 ...
- 详细介绍java中的数据结构
详细介绍java中的数据结构 http://developer.51cto.com/art/201107/273003.htm 本文介绍的是java中的数据结构,本文试图通过简单的描述,向读者阐述各个 ...
- Java中的数据结构及排序算法
(明天补充) 主要是3种接口:List Set Map List:ArrayList,LinkedList:顺序表ArrayList,链表LinkedList,堆栈和队列可以使用LinkedList模 ...
- 动图+源码，演示Java中常用数据结构执行过程及原理
最近在整理数据结构方面的知识, 系统化看了下Java中常用数据结构, 突发奇想用动画来绘制数据流转过程. 主要基于jdk8, 可能会有些特性与jdk7之前不相同, 例如LinkedList Linke ...
- 动图+源码，演示 Java 中常用数据结构执行过程及原理
阅读本文大概需要 3.7 分钟. 作者:大道方圆 cnblogs.com/xdecode/p/9321848.html 最近在整理数据结构方面的知识, 系统化看了下Java中常用数据结构, 突发奇想 ...
- Java中的数据结构有哪些？HashMap的工作原理是什么？
Java中常用数据结构 常用的数据结构有哈希表,线性表,链表,java.util包中有三个重要的接口:List,Set,Map常用来实现基本的数据结构 HashMap的工作原理 HashMap基于ha ...
- Java中的数据结构-HashMap
Java数据结构-HashMap 目录 Java数据结构-HashMap 1. HashMap 1.1 HashMap介绍 1.1.1 HashMap介绍 1.1.2 HashMap继承图 1.2 H ...
- java中的数据结构 --- 集合
集合类在Java.util包中! 在java中常用的是Set,Map,和List. 容器和迭代器 链表 集 映射
随机推荐
- Quartz.Net系列（十四）：详解Job中两大特性（DisallowConcurrentExecution、PersistJobDataAfterExecution）
1.DisallowConcurrentExceution 从字面意思来看也就是不允许并发执行 简单的演示一下 [DisallowConcurrentExecution] public class T ...
- 2020牛客暑期多校训练营（第一场）H Minimum-cost Flow
Minimum-cost Flow 题目:给n个点,m条边.接下来m行包含(a,b,c),即a,b之间有单位流量代价为c的边.接下来有q个问题,每个问题给定(x,y),即假设每条边的容量为x/y时,从 ...
- STL源码剖析：迭代器
准备知识 什么是迭代器? 迭代器是链接容器和算法的桥梁,所有的算法都通过迭代器操作容器中的数据 迭代器是一种智能指针,最重要的操作符重载就是operator*,operator-> 迭代器的实现 ...
- VS Code 上那些沙雕插件
本文整理自网络,作者不详,如有侵权,则可删除. VS Code 作为前端最牛逼的一个前端编辑器,可以说是最流行的开发工具了,以其可支持扩展程序(通过安装扩展程序,VS Code 可以支持更多新的语言. ...
- PHP date_modify() 函数
------------恢复内容开始------------ 实例 修改时间戳.增加 15 天: <?php$date=date_create("2013-05-01");d ...
- HTML 布局 - 使用<div> 元素
网站布局 大多数网站会把内容安排到多个列中(就像杂志或报纸那样).高佣联盟 www.cgewang.com 大多数网站可以使用 <div> 或者 <table> 元素来创建多列 ...
- PHP imagecolorclosesthwb - 取得与指定的颜色最接近的色度的黑白色的索引
imagecolorclosesthwb — 取得与指定的颜色最接近的色度的黑白色的索引.高佣联盟 www.cgewang.com 语法 int imagecolorclosesthwb (s res ...
- Python Cookbook(第3版) 中文版 pdf完整版|网盘下载内附提取码
Python Cookbook(第3版)中文版介绍了Python应用在各个领域中的一些使用技巧和方法,其主题涵盖了数据结构和算法,字符串和文本,数字.日期和时间,迭代器和生成器,文件和I/O,数据编码 ...
- 牛客练习赛63 牛牛的斐波那契字符串 矩阵乘法 KMP
LINK:牛牛的斐波那契字符串 虽然sb的事实没有改变 但是 也不会改变. 赛时 看了E和F题 都不咋会写 所以弃疗了. 中午又看了一遍F 发现很水 差分了一下就过了. 这是下午和古队长讨论+看题解的 ...
- 服务没有报告任何错误。 请键入 NET HELPMSG 3534 以获得更多的帮助。
解决: 删除data文件夹 然后按顺序执行: sc delete mysql mysqld --initialize-insecure mysqld -install mysql net start ...