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中的 数据结构的更多相关文章

  1. java中的数据结构(集合|容器)

    对java中的数据结构做一个小小的个人总结,虽然还没有到研究透彻jdk源码的地步.首先.java中为何需要集合的出现?什么需求导致.我想对于面向对象来说,对象适用于描述任何事物,所以为了方便对于对象的 ...

  2. [转]详细介绍java中的数据结构

    详细介绍java中的数据结构 本文介绍的是java中的数据结构,本文试图通过简单的描述,向读者阐述各个类的作用以及如何正确使用这些类.一起来看本文吧! 也许你已经熟练使用了java.util包里面的各 ...

  3. 详细介绍java中的数据结构

    详细介绍java中的数据结构 http://developer.51cto.com/art/201107/273003.htm 本文介绍的是java中的数据结构,本文试图通过简单的描述,向读者阐述各个 ...

  4. Java中的数据结构及排序算法

    (明天补充) 主要是3种接口:List Set Map List:ArrayList,LinkedList:顺序表ArrayList,链表LinkedList,堆栈和队列可以使用LinkedList模 ...

  5. 动图+源码,演示Java中常用数据结构执行过程及原理

    最近在整理数据结构方面的知识, 系统化看了下Java中常用数据结构, 突发奇想用动画来绘制数据流转过程. 主要基于jdk8, 可能会有些特性与jdk7之前不相同, 例如LinkedList Linke ...

  6. 动图+源码,演示 Java 中常用数据结构执行过程及原理

    ​阅读本文大概需要 3.7 分钟. 作者:大道方圆 cnblogs.com/xdecode/p/9321848.html 最近在整理数据结构方面的知识, 系统化看了下Java中常用数据结构, 突发奇想 ...

  7. Java中的数据结构有哪些?HashMap的工作原理是什么?

    Java中常用数据结构 常用的数据结构有哈希表,线性表,链表,java.util包中有三个重要的接口:List,Set,Map常用来实现基本的数据结构 HashMap的工作原理 HashMap基于ha ...

  8. Java中的数据结构-HashMap

    Java数据结构-HashMap 目录 Java数据结构-HashMap 1. HashMap 1.1 HashMap介绍 1.1.1 HashMap介绍 1.1.2 HashMap继承图 1.2 H ...

  9. java中的数据结构 --- 集合

    集合类在Java.util包中!  在java中常用的是Set,Map,和List. 容器和迭代器 链表 集 映射

随机推荐

  1. java 面向对象(一):类与对象

    1.面向对象学习的三条主线: * 1.Java类及类的成员:属性.方法.构造器:代码块.内部类 * * 2.面向对象的大特征:封装性.继承性.多态性.(抽象性) * * 3.其它关键字:this.su ...

  2. Linux07 /redis的配置、五大数据类型、发布订阅、持久化、主从复制、哨兵配置、集群搭建

    Linux07 /redis的配置.五大数据类型.发布订阅.持久化.主从复制.哨兵配置.集群搭建 目录 Linux07 /redis的配置.五大数据类型.发布订阅.持久化.主从复制.哨兵配置.集群搭建 ...

  3. Django框架10 /sweetalert插件、django事务和锁、中间件、django请求生命周期

    Django框架10 /sweetalert插件.django事务和锁.中间件.django请求生命周期 目录 Django框架10 /sweetalert插件.django事务和锁.中间件.djan ...

  4. Linux基础入门(一)初识Shell

    Linux基础入门(一)初识Shell shell是什么 Shell 是一个用 C 语言编写的程序,它是用户使用 Linux 的桥梁.Shell 既是一种命令语言,又是一种程序设计语言. Shell ...

  5. 如何在项目中封装api

    一般在项目中,会有很多的api请求,无论在vue,angular,还是react中都应该把接口封装起来,方便后期的维护. 1.新建一个api文件 我们可以在项目的分目录下创建一个api文件夹,在这里面 ...

  6. CentOS 无法加载 ntfs文件系统类型解决办法

    问题: CentOS无法加载ntfs 文件系统类型的移动硬盘. 解决办法: 1.下载rpmforge,下载对应的版本.(对应的CentOS版本,并区分32位和64位). 例如: wget http:/ ...

  7. 想用@Autowired注入static静态成员?官方不推荐你却还偏要这么做

    生命太短暂,不要去做一些根本没有人想要的东西.本文已被 https://www.yourbatman.cn 收录,里面一并有Spring技术栈.MyBatis.JVM.中间件等小而美的专栏供以免费学习 ...

  8. linux : 新服务器部署项目要做的事

    环境:阿里云服务器两台,一台web,一台db,系统centos7. 用户用外网访问web server ,web server 再去访问db server. 1 阿里云控制台进入系统2 SSH进入系统 ...

  9. idea中maven导入依赖报红的解决办法

    使用idea创建maven项目,maven导入依赖报红,从以下几个步骤排查解决问题: 1.首先查看maven的安装和配置有没有问题.那么,要看那些内容呢.maven的安装位置.maven的settin ...

  10. java计算下一个整5分钟时间点

    需求背景 我的需求是获取当前时间之后的下一个"整5分钟时间点". 首先,那么何为"整5分钟时间点"? 满足以下两个条件的时间: 分钟数等于以下时间中的一个,且秒 ...