简单介绍java Enumeration以及split

最新推荐文章于 2024-04-29 02:31:29 发布

原创最新推荐文章于 2024-04-29 02:31:29 发布 · 942 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#Enumeration #Iterator #split

Java 专栏收录该内容

31 篇文章

订阅专栏

本文介绍Java中字符串的分割技巧，特别是如何处理特殊字符作为分隔符，并通过实例展示了分割后的数据如何存储到矩阵中及进一步处理。此外，还详细解释了使用Enumeration接口遍历和操作Hashtable的方法。

先上例子：

public class SplitTest {
	public static void splitString(){
		String inData="101_DE|102_AR|103_|104_JK|105_|106_KI|107_|108_BA";
		String[] outDatas = inData.split("\\|");
		System.out.println(outDatas);
		if(null != outDatas && outDatas.length > 0){
			int m = outDatas.length;
			int n = 2;
			String[][] matrix = new String[m][n];
			for (int i = 0; i < m; i++) {
				String outData = outDatas[i];
				String[] keyValue = outData.split("_");
				if(null != keyValue && keyValue.length <= n){
					if(keyValue.length == n){
						matrix[i][0] = keyValue[0];
						matrix[i][1] = keyValue[1];
					}else if(outData.endsWith("_")){
						matrix[i][0] = keyValue[0];
					}else{
						matrix[i][1] = keyValue[0];
					}					
				}
			}			
			Hashtable<String, String> hashtable = new Hashtable<>();
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++) {
					System.out.println("matrix["+i+"]["+j+"] is "+matrix[i][j]);
				}
				if(matrix[i][0]!=null&&matrix[i][1]!=null){
	                hashtable.put(matrix[i][0], matrix[i][1]);
	            }
			}
			 System.out.println();
		        Enumeration<String> keys=hashtable.keys();
		        while(keys.hasMoreElements()){
		            String key=keys.nextElement();
		            String value=hashtable.get(key);
		            System.out.println("hashtable key: "+key+"--value: "+value);
		        }
		}
	}
	public static void main(String[] args) {
		splitString();
	}
}

一、分隔符总结：

1.字符"|","*","+","."都得加上转义字符，前面加上"\\"。
2.而如果是"\"，那么就得写成"\\\\"。
3.如果一个字符串中有多个分隔符，可以用"|"作为连字符。

比如：String str = "Java string-split#test",可以用Str.split(" |-|#")把每个字符串分开。这样就把字符串分成了3个子字符串。

二、介绍Enumeration

Enumeration接口本身不是一个数据结构。但是，对其他数据结构非常重要。 Enumeration接口定义了从一个数据结构得到连续数据的手段。例如，Enumeration定义了一个名为nextElement的方法，可以用来从含有多个元素的数据结构中得到的下一个元素。
Enumeration接口提供了一套标准的方法，由于Enumeration是一个接口，它的角色局限于为数据结构提供方法协议

1、用 Enumeration 类的 hasMoreElements 和 nestElement 方法来遍历输出 HashTable 中的内容：

public static void main(String[] args) {
		 Hashtable<String,String> ht = new Hashtable<>();
	      ht.put("1", "One");
	      ht.put("2", "Two");
	      ht.put("3", "Three");
	      Enumeration<String> e = ht.elements();
	      while(e.hasMoreElements()){
	         System.out.println(e.nextElement());
	      }
    }

2、一般情况下，也可以用Enumeration来遍历集合

public class Test {
	 public static void main(String[] args) {
	        //初始化创建hashtable
	        Hashtable<String, String> ht = new Hashtable<String, String>();
	        for (int i = 0; i < 10000; i++) {
	            ht.put("Key=" + i, "Val=" + i);
	        }

	        // 1. 使用Enumeration
	        long start = System.currentTimeMillis();
	        Enumeration<String> en = ht.keys();//使用枚举获取key
	        while (en.hasMoreElements()) {
	            en.nextElement();
	        }
	        long end = System.currentTimeMillis();
	        System.out.println("Enumeration keys costs " + (end - start)
	                + " milliseconds");

	        // 2. 使用Enumeration
	        start = System.currentTimeMillis();
	        Enumeration<String> en2 = ht.elements();//使用枚举获取这个key-value对
	        while (en2.hasMoreElements()) {
	            en2.nextElement();
	        }
	        end = System.currentTimeMillis();
	        System.out.println("Enumeration elements costs " + (end - start)
	                + " milliseconds");

	        // 3. Iterator
	        start = System.currentTimeMillis();
	        Iterator<String> it = ht.keySet().iterator();//使用迭代器获取这个key
	        while (it.hasNext()) {
	            it.next();
	        }
	        end = System.currentTimeMillis();
	        System.out.println("Iterator keySet costs " + (end - start)
	                + " milliseconds");

	        // 4. Iterator
	        start = System.currentTimeMillis();
	        Iterator<Entry<String, String>> it2 = ht.entrySet().iterator();//使用迭代器获取这个key-value对
	        while (it2.hasNext()) {
	            it2.next();
	        }
	        end = System.currentTimeMillis();
	        System.out.println("Iterator entrySet costs " + (end - start)
	                + " milliseconds");
	    }
}

运行结果：

Enumeration keys costs 4 milliseconds
Enumeration elements costs 8 milliseconds
Iterator keySet costs 20 milliseconds
Iterator entrySet costs 2 milliseconds

Enumeration接口是JDK1.0时推出的，是最好的迭代输出接口，最早使用Vector（现在推荐使用ArrayList）时就是使用Enumeration接口进行输出。虽然Enumeration是一个旧的类，但是在JDK1.5之后为Enumeration类进行了扩充，增加了泛型的操作应用。

Enumeration接口常用的方法有hasMoreElements()（判断是否有下一个值）和 nextElement()（取出当前元素），这些方法的功能跟Iterator类似，只是Iterator中存在删除数据的方法，而此接口不存在删除操作。

3、Enumeration和Iterator接口功能相似，而且Iterator的功能还比Enumeration多，那么为什么还要使用Enumeration？

这是因为java的发展经历了很长时间，一些比较古老的系统或者类库中的方法还在使用Enumeration接口，因此为了兼容，还是需要使用Enumeration。

补充：

List接口常用的子类有ArrayList和Vector，两者有许多相似的地方，下面给出这两者之间的比较