Java工具包类

一时失言乱红尘 2023-10-04 20:38 45阅读 0赞

java.util包有很多实用的类、接口和异常。

向量类，堆栈类，哈希表，枚举接口，日历类，随机函数类，映射接口和属性类。

Vector类

vector是异构的，可以存储不同的对象，同时可以动态增加存储容量

所有向量操作都是针对Object类进行的，要将从向量空间取回的Object对象进行向下转型。

元素个数小于等于容量。

**只能放进对象，基本数据类型要使用其包装类。**

常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Vector()</td> 
   <td>构造空向量</td> 
  </tr> 
  <tr> 
   <td>Vector(int initialCapacity)</td> 
   <td>初始化指定大小的向量</td> 
  </tr> 
  <tr> 
   <td>Vector(int initialCapacity,int capacityIncrement)</td> 
   <td>capacityIncrement 每次扩充的值: 0 每次扩充一倍</td> 
  </tr> 
  <tr> 
   <td>add()</td> 
   <td>添加元素</td> 
  </tr> 
  <tr> 
   <td>addElement()</td> 
   <td>添加到末尾</td> 
  </tr> 
  <tr> 
   <td>capacity()</td> 
   <td>返回容量大小</td> 
  </tr> 
  <tr> 
   <td>clear()</td> 
   <td>清空</td> 
  </tr> 
  <tr> 
   <td>elementAt()</td> 
   <td>返回指定位置的对象元素</td> 
  </tr> 
  <tr> 
   <td>elements()</td> 
   <td>返回允许访问的每个向量元素的对象</td> 
  </tr> 
  <tr> 
   <td>firstElement()</td> 
   <td>返回第一个对象元素</td> 
  </tr> 
  <tr> 
   <td>get()</td> 
   <td>返回指定位置的对象元素</td> 
  </tr> 
  <tr> 
   <td>indexOf()</td> 
   <td>查找指定对象元素的位置, 不存在返回-1</td> 
  </tr> 
  <tr> 
   <td>isEmpty()</td> 
   <td>判断是否为空</td> 
  </tr> 
  <tr> 
   <td>remove()</td> 
   <td>清除指定位置或者对象的元素</td> 
  </tr> 
  <tr> 
   <td>removeAllElements()</td> 
   <td>清除所有元素</td> 
  </tr> 
  <tr> 
   <td>setElementAt()</td> 
   <td>在指定位置设置指定的对象元素，覆盖原来的</td> 
  </tr> 
  <tr> 
   <td>setSize()</td> 
   <td>设置容量大小</td> 
  </tr> 
  <tr> 
   <td>size()</td> 
   <td>返回元素个数</td> 
  </tr> 
  <tr> 
   <td>trimToSize()</td> 
   <td>设置实际容量为内部的缓存容量</td> 
  </tr> 
  <tr> 
   <td>toArray()</td> 
   <td>返回向量元素数组</td> 
  </tr> 
  <tr> 
   <td>subList()</td> 
   <td>返回向量位置</td> 
  </tr> 
  <tr> 
   <td>removeElementAt()</td> 
   <td>删除index所指的地方的对象</td> 
  </tr> 
 </tbody> 
</table>

例子

import java.util.Vector;
    
    public class VectorDemo {
        public void test(){
            Vector vectTemp = new Vector(4,3);
            System.out.println("元素个数: " + vectTemp.size());
            System.out.println("容量大小: " + vectTemp.capacity());
            // 添加元素
            vectTemp.add(new Integer(3));
            vectTemp.addElement(new Double(4.0));
            vectTemp.insertElementAt(new Float(5.0f),1);
            vectTemp.add("hello world");
            vectTemp.add("wkk");
            System.out.println("元素个数: " + vectTemp.size());
            System.out.println("容量大小: " + vectTemp.capacity());
            // toString() 会将所有元素按照字符串输出
            System.out.println(vectTemp.toString());
            // 第2个元素
            System.out.println(vectTemp.get(2));
        }
    
        public static void main(String[] args) {
            new VectorDemo().test();
        }
    }

![adf1c29f06400934e2ee51d1cf2d2ab6.png][]

Stack类

后进先出: LIFO

可以接收任何类型对象

常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Stack()</td> 
   <td>构造空堆栈</td> 
  </tr> 
  <tr> 
   <td>empty()</td> 
   <td>判断是否为空</td> 
  </tr> 
  <tr> 
   <td>peek()</td> 
   <td>取得堆栈顶端的元素</td> 
  </tr> 
  <tr> 
   <td>pop()</td> 
   <td>删除堆栈顶端的元素，并返回</td> 
  </tr> 
  <tr> 
   <td>push(Object item)</td> 
   <td>入栈</td> 
  </tr> 
  <tr> 
   <td>search(Object item)</td> 
   <td>检查堆栈中中是否有指定的对象</td> 
  </tr> 
 </tbody> 
</table>

例子

import java.util.Stack;
    public class StackDemo {
        public void test(){
            Stack stkTemp = new Stack();
            System.out.println("堆栈是否为空: "+stkTemp.empty());
            stkTemp.push(new Integer(2));
            stkTemp.push("wkk");
            // 查看元素位置
            System.out.println("元素wkk位置:" + stkTemp.search("wkk"));
            System.out.println("元素2位置:" + stkTemp.search(new Integer(2)));
            // 栈顶元素 peek
            System.out.println(stkTemp.peek());
            System.out.println(stkTemp.peek());
            //栈顶元素 pop
            System.out.println(stkTemp.pop());
            System.out.println(stkTemp.pop());
        }
    
        public static void main(String[] args) {
            new StackDemo().test();
        }
    }

![d49f1eaaf920c5a1f209d9137bb32707.png][]

*  栈顶元素所处位置为 1
 *  栈顶的下一个元素的位置为 2

Hashtable类

Dictionary类是一个抽象类，为字典表提供了一个统一的接口。

Hashtable 是一个键值对集合， 是抽象类Dictionary的一个具体实现，可以存储任意对象。

常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Hashtable()</td> 
   <td>构造空的哈希表</td> 
  </tr> 
  <tr> 
   <td>clear()</td> 
   <td>清空</td> 
  </tr> 
  <tr> 
   <td>containsKey()</td> 
   <td>对象是否是表中的关键字</td> 
  </tr> 
  <tr> 
   <td>containsValue()</td> 
   <td>对象是否是表中的值</td> 
  </tr> 
  <tr> 
   <td>elements()</td> 
   <td>返回允许访问每个对象元素的对象</td> 
  </tr> 
  <tr> 
   <td>get()</td> 
   <td>根据指定的键返回其对应的值</td> 
  </tr> 
  <tr> 
   <td>put(Object key, Object value)</td> 
   <td>将一组键值对放进表中</td> 
  </tr> 
  <tr> 
   <td>keys()</td> 
   <td>返回允许访问每一个键的对象</td> 
  </tr> 
  <tr> 
   <td>size()</td> 
   <td>键的个数</td> 
  </tr> 
  <tr> 
   <td>remove()</td> 
   <td>依据指定的键删除对应的键值对</td> 
  </tr> 
 </tbody> 
</table>

每一个键唯一对应一个键值对，一个哈希表中的**键不能重复**

任何一个对象可以充当键，任何一个对象也可以充当值。

例子

import java.util.Hashtable;
    public class HashtableDemo {
        public void test(){
            Hashtable hshTemp = new Hashtable();
            hshTemp.put("001",new Integer(1));
            hshTemp.put("002",new Integer(2));
    
            // 元素个数
            System.out.println("元素个数: " + hshTemp.size());
            // 获取值
            System.out.println(hshTemp.get("001"));
            // 判断是否有值 1
            System.out.println("有值1: " + hshTemp.containsValue(new Integer(1)));
            // 哈希表转换为String
            System.out.println(hshTemp);
        }
    
        public static void main(String[] args) {
            new HashtableDemo().test();
        }
    }

![5bb52f01ecac2dee5d660bc92ca83b2f.png][]

Enumeration接口

Enumeration对应着一个对象集合，一般是和Vector, Stack, Hashtable或者其他类共同实现完成。

使用它们的elements()方法来得到元素集合。

> iterator 迭代器

常用方法：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>hasMoreElements()</td> 
   <td>判断对象是否有多的元素</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>nextElement()</td> 
   <td>获得对象集合的下一个对象</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

例子

import java.util.Vector;
    import java.util.Enumeration;
    
    public class EnumerationDemo {
        public void test(){
            Vector vctTemp = new Vector(3,2);
            Enumeration enumTemp ;
            // 添加字符串
            for(int intTemp = 1;intTemp < 4;intTemp++){
                String string = "字符串" + intTemp;
                vctTemp.addElement(string);
            }
    
            enumTemp = vctTemp.elements();
            while(enumTemp.hasMoreElements()){
                String  strElement = (String)enumTemp.nextElement();
                System.out.println("元素值: " + strElement);
            }
        }
    
        public static void main(String[] args) {
            new EnumerationDemo().test();
        }
    }

![909307c392504262734cced848370646.png][]

**Enumeration 是一个接口**，所以不能使用new() 方法来定义一个实例

Calendar类

工作原理，从本机电脑系统中取得系统时间、所处时区等数据来得到时间的具体信息。

常用属性

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>YEAR</td> 
   <td>年</td> 
  </tr> 
  <tr> 
   <td>MONTH</td> 
   <td>月</td> 
  </tr> 
  <tr> 
   <td>DAY_OF_MONTH</td> 
   <td>当月的第几天</td> 
  </tr> 
  <tr> 
   <td>DAY_OF_WEEK</td> 
   <td>当星期的第几天</td> 
  </tr> 
  <tr> 
   <td>DAY_OF_YEAR</td> 
   <td>当前的第几天</td> 
  </tr> 
  <tr> 
   <td>WEEK_OF_YEAR</td> 
   <td>当年的第几周</td> 
  </tr> 
  <tr> 
   <td>Calendar()</td> 
   <td>构造函数，但是是protected的，不能直接new</td> 
  </tr> 
  <tr> 
   <td>getInstance()</td> 
   <td>获得日历类的实例</td> 
  </tr> 
  <tr> 
   <td>get(int field)</td> 
   <td>获得某一属性的值，field为日历中定义的属性</td> 
  </tr> 
  <tr> 
   <td>set(int field)</td> 
   <td>设置某一属性的值</td> 
  </tr> 
  <tr> 
   <td>getTime()</td> 
   <td>返回日历所对应的日期(date)</td> 
  </tr> 
  <tr> 
   <td>Clear(int field)</td> 
   <td>清除日历类的某一个属性的值</td> 
  </tr> 
 </tbody> 
</table>

例子

import java.util.Calendar;
    
    public class CalendarDemo {
        public void test(){
            Calendar cldTemp = Calendar.getInstance();
            // 打印基本的日历信息
            System.out.println("年：" + cldTemp.get(Calendar.YEAR));
            System.out.println("月: " + cldTemp.get(Calendar.MONTH));
            System.out.println("日: " + cldTemp.get(Calendar.DATE));
            // 具体日历信息
            System.out.println("上/下午: " + cldTemp.get(Calendar.AM_PM));
            System.out.println("小时: " + cldTemp.get(Calendar.HOUR));
            System.out.println("分钟: " + cldTemp.get(Calendar.MINUTE));
            System.out.println("秒: " + cldTemp.get(Calendar.SECOND));
            System.out.println("毫秒: " + cldTemp.get(Calendar.MILLISECOND));
            // 转换为数组
            System.out.println("数组: " + cldTemp.toString());
        }
    
        public static void main(String[] args) {
            new CalendarDemo().test();
        }
    }

*  整个日历是由一个数组存放的
 *  日历类的构造函数是protected的，所以不能直接用new创建，而是用getInstance()获得
    
    ![31bdb890eb47636a8b07224c140e12a2.png][]

Random类

Random类是伪随机数生成器。

常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Random</td> 
   <td>构造方法</td> 
  </tr> 
  <tr> 
   <td>nextBoolean()</td> 
   <td>返回一个boolean变量 true / false</td> 
  </tr> 
  <tr> 
   <td>nextDouble()</td> 
   <td>返回一个double数 0.0 - 1.0</td> 
  </tr> 
  <tr> 
   <td>nextFloat()</td> 
   <td>0.0 - 1.0</td> 
  </tr> 
  <tr> 
   <td>nextInt()</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>nextLong()</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>nextGaussian()</td> 
   <td>根据一个伪离散高斯分布生成一个双精度随机数 0.0 - 1.0</td> 
  </tr> 
 </tbody> 
</table>

例子

import java.util.Random;
    
    public class RandomDemo {
        public void test() {
            Random rndTemp = new Random();
            System.out.println("布尔: " + rndTemp.nextBoolean());
            System.out.println("double: " + rndTemp.nextDouble());
            System.out.println("float: "+ rndTemp.nextFloat());
            System.out.println("long: " + rndTemp.nextLong());
            System.out.println("int: " + rndTemp.nextInt());
            // 10以内整型
            System.out.println("int(10以内): " +rndTemp.nextInt(10));
        }
    
        public static void main(String[] args) {
            new RandomDemo().test();
        }
    }

![eb7e5bbca138b8c5c298cee726a12c81.png][]

*  nextInt(n) 返回\[0, n) 的整数 -> n>0

Map接口

Map(映射)接口定义了一个框架，用来实现基本的映射数据结构。

Hashtable类实现了Map接口。

Map接口定义了在索引的基础上存储和检索信息的方法，Map接口中的键可以是任何类型。

常用方法：

基本都是针对键和键对应的对象

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>clear()</td> 
   <td>清除所有</td> 
  </tr> 
  <tr> 
   <td>containsKey()</td> 
   <td>是否有指定的键</td> 
  </tr> 
  <tr> 
   <td>containsValue()</td> 
   <td>是否有指定的值</td> 
  </tr> 
  <tr> 
   <td>entrySet()</td> 
   <td>返回映射对象所对应的集合</td> 
  </tr> 
  <tr> 
   <td>hashCode()</td> 
   <td>返回映射对象本身的哈希码</td> 
  </tr> 
  <tr> 
   <td>isEmpty()</td> 
   <td>是否为空</td> 
  </tr> 
  <tr> 
   <td>keySet()</td> 
   <td>返回键的集合</td> 
  </tr> 
  <tr> 
   <td>put()</td> 
   <td>添加键值对</td> 
  </tr> 
  <tr> 
   <td>putAll(Map t)</td> 
   <td>将已知的映射t中的所有映射添加到本映射中</td> 
  </tr> 
  <tr> 
   <td>remove()</td> 
   <td>根据键删除映射</td> 
  </tr> 
  <tr> 
   <td>size()</td> 
   <td>返回映射个数</td> 
  </tr> 
  <tr> 
   <td>values()</td> 
   <td>返回值的集合</td> 
  </tr> 
 </tbody> 
</table>

Map是一个接口，需要实现。

HashMap类实现了Map接口。

例子

import java.util.HashMap;
    import java.util.Set;
    import java.awt.Rectangle;
    
    public class HashMapDemo {
        public void test(){
            HashMap hmTemp = new HashMap();
            // 构造数组，预存放键对象
            Object objectKeyTemp [] = new Object[3];
            hmTemp.put("small",new Rectangle(0,0,5,5));
            hmTemp.put("midium",new Rectangle(0,0,15,15));
            hmTemp.put("large",new Rectangle(0,0,30,30));
            // 个数
            System.out.println("个数: " + hmTemp.size());
            // 是否含有键small
            System.out.println("是否含有small键: " + hmTemp.containsKey("small"));
            System.out.println("是否含有Rectangle(0,0,15,15): "+hmTemp.containsValue(new Rectangle(0,0,15,15)));
            // 返回映射中键的集合
            Set setTemp = hmTemp.keySet();
            objectKeyTemp = setTemp.toArray();
            for (int i = 0; i < objectKeyTemp.length; i++) {
                if(objectKeyTemp[i] instanceof String) {
                    String s = (String) objectKeyTemp[i];
                    System.out.println("key的值: " + s);
                }
            }
        }
    
        public static void main(String[] args) {
            new HashMapDemo().test();
        }
    }

![73c61ee3140f2d07a0a4b79a46b57a5f.png][]

Properties类

主要用于读取Java的配置文件

在Java中，其配置文件常为.properties文件，是以键值对的形式进行参数配置的。

Properties类是Hashtable类的子类，有Hashtable类对象的所有方法

常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getProperty()</td> 
   <td>依据指定的键或者值返回属性值</td> 
  </tr> 
  <tr> 
   <td>load(InputStream inStream)</td> 
   <td>从指定的输入流中读取键和其指定对象进行加载</td> 
  </tr> 
  <tr> 
   <td>propertyNames()</td> 
   <td>将属性对象中的键返回到枚举接口</td> 
  </tr> 
  <tr> 
   <td>setProperty(String key,String value)</td> 
   <td>设定属性对象中的一组属性对象对，其中键和值都是String类型</td> 
  </tr> 
  <tr> 
   <td>store(OutputStream out,String header)</td> 
   <td>将属性对象中的属性对象加载到指定的输出流中，同时指定名字</td> 
  </tr> 
 </tbody> 
</table>

例子

配置文件： file.properites

age = 25
    name = wkk

package com.wkk;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.util.Enumeration;
    import java.util.Properties;
    import java.io.IOException;
    public class PropertiesDemo {
        public void test(){
            Properties ppTemp = new Properties();
            try{
                ppTemp.load(new FileInputStream("src/com/wkk/file.properties"));
            }catch (FileNotFoundException e){
                e.printStackTrace();
            }catch(IOException e){
                e.printStackTrace();
            }
            Enumeration content = ppTemp.propertyNames();
            while(content.hasMoreElements()){
                String key = (String)content.nextElement();
                String value =ppTemp.getProperty(key);
                System.out.println(key + ":" + value);
            }
        }
    
        public static void main(String[] args) {
            new PropertiesDemo().test();
        }
    }

![2f26d9eded085d63e7298f14972804d1.png][]

[adf1c29f06400934e2ee51d1cf2d2ab6.png]: https://img-blog.csdnimg.cn/img_convert/adf1c29f06400934e2ee51d1cf2d2ab6.png
[d49f1eaaf920c5a1f209d9137bb32707.png]: https://img-blog.csdnimg.cn/img_convert/d49f1eaaf920c5a1f209d9137bb32707.png
[5bb52f01ecac2dee5d660bc92ca83b2f.png]: https://img-blog.csdnimg.cn/img_convert/5bb52f01ecac2dee5d660bc92ca83b2f.png
[909307c392504262734cced848370646.png]: https://img-blog.csdnimg.cn/img_convert/909307c392504262734cced848370646.png
[31bdb890eb47636a8b07224c140e12a2.png]: https://img-blog.csdnimg.cn/img_convert/31bdb890eb47636a8b07224c140e12a2.png
[eb7e5bbca138b8c5c298cee726a12c81.png]: https://img-blog.csdnimg.cn/img_convert/eb7e5bbca138b8c5c298cee726a12c81.png
[73c61ee3140f2d07a0a4b79a46b57a5f.png]: https://img-blog.csdnimg.cn/img_convert/73c61ee3140f2d07a0a4b79a46b57a5f.png
[2f26d9eded085d63e7298f14972804d1.png]: https://img-blog.csdnimg.cn/img_convert/2f26d9eded085d63e7298f14972804d1.png