Java中几个常用类总结

柔情只为你懂 2022-10-06 13:48 178阅读 0赞

**一. System:**

1. 首先是System类，因为从一开始从接触java起，我们就无时无刻都在接触它，经常用它来向屏幕，向控制台打印输出一些信息，System.out.println(“hello world”);这个只是在控制台输出一条信息“hello world”，今天我们学到这里，才知道out只是System类中的一个字段，也就是一个成员变量，而且还是静态的，是一个对象的引用，即PrintStream，是标准的输出流，向标准的输出设备输出信息的，所以我们这里才调用了对象out的println()这个方法。所以类似与out字段的还有其他两个，如in是InputStream类的一个对象，那么in则是一个标准的输入对象，他可以读取或则也可以说从键盘或则其他输入设备接收或者读入一个信息，那么err也是PrintStream类的一个对象，则是标准的错误输出流，那其实这些所谓的标准的输入输出，他们功能实现底层是靠C语言和设备直接沟通的，java只是依赖C语言完成了这些功能。

2. 老师说学习System这个类并不是说要去做太多的深入了解，而是希望我们能掌握一些查阅API，掌握这个类中常用的几个方法，在以后的开发中能够写出一些需要的小东西。

3. Java中System这个类中的属性和方法都是静态的，可以通过类名可以直接调用，而且它位于java默认的包中java.lang包中，一般情况下我们要使用它的方法和属性，是不需要做导入包的动作的，然后我们还发先这个类没有构造方法，所以这就说明我们不能创建一个System类的对象，只能通过类名来直接调用它的属性和方法了，注意，它还是一个final类型的修饰的类。那么我们来看看还有什么那些方法比较重要呢？

**A. static PropertiesgetProperties()**这个方法可以用来获取当前系统的信息和JAVA虚拟机加载时候的一些属性。

它的返回值是Properties，通过产看API文档我们知道这是一个类对象，是Map集合范畴的一个子类对象，它继承于HashTable<Object,Object>这个类，所以我们可以得知，我们可以使用Map种的一些方法去获得Properties的一些属性信息了，所以Properties中存放的也都是以键值对的形式存在的了，练习一下这个方法吧。。。

package com.System;
 import java.util.*;
 public class PropertiesDemo
 {
 	public static void main(String[] args)
 	{
 	System.out.println("java.vendor = "+System.getProperty("java.vendor"));
 		 //@获取当前系统所有属性和java虚拟机加载的一些系统属性
 		Properties p = System.getProperties();
 //通过上一步骤获得之后，我们可以利用Map种的方法获得//Map.Entry<Object,Object>类型的set集合的迭代器来遍历我们获取到//的信息了//这只是其中一种方法，还可以使用其他的方法。
 Iterator<Map.Entry<Object,Object>> iter = p.entrySet().iterator();
 while(iter.hasNext())
 {
 	Map.Entry<Object,Object> map = iter.next();
 //因为这里没有使用泛型，所以要做一个强制转换的动作，我们知道这些属
 //性和key获得之后都是以String的方式存在的，我们直接将其转换为String
 //类型就好
 	String key = (String)map.getKey();
 	String value = (String)map.getValue();
 	System.out.println(key+" = " +value);
 }
 	}
 }

通过运行以上代码，我们可以看到当前操作系统的版本，使用者国别，java虚拟机运行目录等信息。

**B.** 接下来看一下static String getProperty()

那么我们还可使用这个方法获得指定key的属性:

如上代码中这行语句，System.*getProperty*("java.vendor")，就可以单独获得java.vendor这个key对应的属性了，哦，对了，它的返回值是一个String类型的，其实这个的主要功能是用在判断当前系统版本和类型，来实现我们在不同操作系统上完成一些对应的功能，所以这也算是体现java跨平台的一个小体现吧。

**C.** 既然能获得一些key和属性，那么我们也可以设置一些自己的key和属性，让java虚拟机运行的时候，我们可以去使用他们，去获取他们，那就要使用到

staticString setProperty(String key , String value)方法了

System.*setProperty*("name","ansem");这样我们就可以将自己定义的一个特有的属性设置到系统中，然后就可以通过以上的获得读取方法进行获得了。

**D.** 另外我们还可以在启动java虚拟机的时候，也就是运行javaXXXXXX的时候动态的设定一个key和属性，起方式如下:

Java-D(name)=(value) 类名，就可以了。

**二. Runtime**

A. 接下来就要来做一下Runtime类的笔记了，通过查API，我们知道这个Runtime是一个与应用程序能够与其运行的环境相关联的，接下来我们发现这个类却没有构造方法，自身还不是一个抽象类或者接口，这时候我们就不能new出来一个Runtime类的对象了，那我们是不是会想到直接通过类名调用他的方法呢？可是我们查看API，发现它还有很多不是静态的方法，表示我们就不能直接调用了，所以我们会联想到，这个类肯定有一个静态的方法是使用来获取Runtime对象实例的，那么这个方法我们在API中可以找到是getRuntime()这个方法：

Runtime r = Runtime.getRuntime()这个方法就可以返回一个Runtime类的实例了，

而且是这个实例是当前与java应用程序相关的运行时对象。

B. 由此我们可以深刻的体会到，这就是运用了java单例设计模式，保证了此时此刻只能有一个当前与java应用程序相关的运行时对象。

C. 接下来我们来看一个Runtime类比较常用的一个方法exec(String command)，这个方法是创建一个指定的本机进程，直接贴代码吧。。。。。。

package com.Runtime;
    public class RuntimeDemo
    {
    	public static void main(String[] args) throws Exception
    	{
         //如上所说，利用Runtime类的getRuntime()方法来返回一个当前与java应用程序相、//关的运行时对象
    		Runtime re = Runtime.getRuntime();
    /*查看API我们知道exec(String command)方法返回的是一个Process类的对象
    所以我们在这里定一个Process类变量，返回值赋给p，所以当代码执行到这一行的时候，就会运行本机器上的一个外部应用程序即notepad.exe文本编辑器，这里没加notepad.exe的所在目录，是因为，notepad.exe是在C:\Windows\system32目录下面，系统默认将这个目录添加到path环境变量中了，系统会在当前目录下寻找，找不到的话会自动到C:\Windows\system32去找，然后运行它。
    */
    		Process p = re.exec("notepad.exe");
            Thread.sleep(5000);
            p.destroy();
            System.out.println(p.exitValue());
    	}
    }

D. 说到Runtiem，然后和他联系十分紧密的一个类是Process，这个类中是一个抽象类，方法全部是抽象的，同样也没有任何子类，所以他一般是通过`ProcessBuilder.start()` 和`Runtime.exec` 方法创建一个本机进程，并返回`Process` 子类的一个实例，该实例可用来控制进程并获取相关信息。`Process` 类提供了执行从进程输入、执行输出到进程、等待进程完成、检查进程的退出状态以及销毁（杀掉）进程的方法，它的一个destroy()方法可以用来结束一个进程，而且它只能结束`ProcessBuilder.start()` 和`Runtime.exec`方法获得Process实例所对应的进程。

我们也来贴几段几行代码看一看吧。。。。。

package com.Runtime;
    public class RuntimeDemo
    {
    	public static void main(String[] args) throws Exception
    	{
    		Runtime re = Runtime.getRuntime();
    		Process p = re.exec("notepad.exe");
    //调用线程类得sleep(long Milli)，就是程序执行到这行代码的时候，先停止继续执//行，休眠指定的时间，因为下面的结束进程语句执行非常快，会秒杀Process p = /re.exec("notepad.exe")代码运行出来的进程，所以才加sleep的
            Thread.sleep(5000);
            p.destroy();
            System.out.println(p.exitValue());
    	}
    }

**三. Date类**

接下来是Date类，可想而知，Date就是一个跟时间操作相关的，不多说我们来看看吧，Date类是位于java.util包中的，`Date` 表示特定的瞬间，精确到毫秒。我们查看API可以发现，他有多个构造方法，但是大多数构造方法都已经过时了，这里的过时就表明这个方法或则构造方法不建议被使用了，所以剩下来的，比较常用的一个构造方法就是Date()了，它可以将当前系统的时间信息作为值初始化给他的成员变量，好了不多说，我们创建一个对象看看看效果吧。。。

package com.date;
    import java.util.*;
    import java.text.*;
    public class DateDemo
    {
    	public static void main(String[] args)
    	{
          Date d = new Date();
          System.out.println(d);
    	}
    }

执行结果为: MonAug05 16:20:29 CST 2010

看上去结果特别别扭，那么我们要怎么才能转换成我们喜欢的格式呢？是不是有相应的方法去实现以某种格式显示时间呢？

接着，我们查API，发现这个类中有一些获得年，月，日….的一些方法，可是都表明已经过时了，这就以为着我们在开发中不能使用了，那么接下来，再查看API，发现在另请参见这个地方有一个与之相关联的类DateFormat，我们再看看它的API吧，我们发现这个类是一个抽象类，当然这个类的大部分功能使用来格式化一个时间的，既然他是一个抽象类，那么我们只能依靠它的子类SimpleDateFormat了我们再看SimpleDateFormat，这个类是存在于java.text包中，我们看到这个类有四个构造方法，但是我这里只介绍一个比较常用的构造方法**SimpleDateFormat**`(`String`pattern)` ，用给定的模式和默认语言环境的日期格式符号构造 `SimpleDateFormat`，也就是说我们可以给她传递一个字符串类型的参数，然后去调用他的时间格式化方法，就能按照给定字符串方式转换出我们需要的时间格式，不多说，看代码。。。。。。

package com.date;
    import java.util.*;
    import java.text.*;
    public class DateDemo
    {
    	public static void main(String[] args)
    	{
    //首先创建一个Date对象。
          Date d = new Date();
    //然后使用DateFormat类的子类SimpleDateFormat类来创建一个对象
    //并传递一个字符串参数，至于这个字符串参数，其实是有规定的，待会会说明。
    SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月d日  E a");
    //接下来在使用其format方法，将Date作为被各式化对象传递进去，format方//法返回的是一个字符串类型的时间表示。
         String date = df.format(d);
          System.out.println(date);
    	}
    }

运行结果: 2010年08月5日 星期一 下午

很显然结果是非常符合我们中国人的使用标准，哈哈，比较本地化了。。。。

说明一下SimpleDateFormat df = newSimpleDateFormat("yyyy年MM月d日 E a");这个构造方法的里面的字符串参数到底是怎么回事，为什么我们传递一个"yyyy年MM月d日 E a"参数就能拿到我们想要的时间格式呢？这是因为使用这个类的时候他们有一个时间日期模式的约定:

日期和时间格式由*日期和时间模式* 字符串指定。在日期和时间模式字符串中，未加引号的字母 'A' 到 'Z' 和 'a' 到 'z' 被解释为模式字母，用来表示日期或时间字符串元素。文本可以使用单引号 (') 引起来，以免进行解释。"''" 表示单引号。所有其他字符均不解释；只是在格式化时将它们简单复制到输出字符串，或者在分析时与输入字符串进行匹配。

定义了以下模式字母（所有其他字符 'A' 到 'Z' 和 'a' 到 'z' 都被保留）：

<table> 
 <tbody> 
 <tr> 
 <td style="background-color:#ccccff;"> 字母 </td> 
 <td style="background-color:#ccccff;"> 日期或时间元素 </td> 
 <td style="background-color:#ccccff;"> 表示 </td> 
 <td style="background-color:#ccccff;"> 示例 </td> 
 </tr> 
 <tr> 
 <td> <code>G</code> </td> 
 <td> Era 标志符 </td> 
 <td> Text </td> 
 <td> <code>AD</code> </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> <code>y</code> </td> 
 <td style="background-color:#eeeeff;"> 年 </td> 
 <td style="background-color:#eeeeff;"> Year </td> 
 <td style="background-color:#eeeeff;"> <code>1996</code>; <code>96</code> </td> 
 </tr> 
 <tr> 
 <td> <code>M</code> </td> 
 <td> 年中的月份 </td> 
 <td> Month </td> 
 <td> <code>July</code>; <code>Jul</code>; <code>07</code> </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> <code>w</code> </td> 
 <td style="background-color:#eeeeff;"> 年中的周数 </td> 
 <td style="background-color:#eeeeff;"> Number </td> 
 <td style="background-color:#eeeeff;"> <code>27</code> </td> 
 </tr> 
 <tr> 
 <td> <code>W</code> </td> 
 <td> 月份中的周数 </td> 
 <td> Number </td> 
 <td> <code>2</code> </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> <code>D</code> </td> 
 <td style="background-color:#eeeeff;"> 年中的天数 </td> 
 <td style="background-color:#eeeeff;"> Number </td> 
 <td style="background-color:#eeeeff;"> <code>189</code> </td> 
 </tr> 
 <tr> 
 <td> <code>d</code> </td> 
 <td> 月份中的天数 </td> 
 <td> Number </td> 
 <td> <code>10</code> </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> <code>F</code> </td> 
 <td style="background-color:#eeeeff;"> 月份中的星期 </td> 
 <td style="background-color:#eeeeff;"> Number </td> 
 <td style="background-color:#eeeeff;"> <code>2</code> </td> 
 </tr> 
 <tr> 
 <td> <code>E</code> </td> 
 <td> 星期中的天数 </td> 
 <td> Text </td> 
 <td> <code>Tuesday</code>; <code>Tue</code> </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> <code>a</code> </td> 
 <td style="background-color:#eeeeff;"> Am/pm 标记 </td> 
 <td style="background-color:#eeeeff;"> Text </td> 
 <td style="background-color:#eeeeff;"> <code>PM</code> </td> 
 </tr> 
 <tr> 
 <td> <code>H</code> </td> 
 <td> 一天中的小时数（0-23） </td> 
 <td> Number </td> 
 <td> <code>0</code> </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> <code>k</code> </td> 
 <td style="background-color:#eeeeff;"> 一天中的小时数（1-24） </td> 
 <td style="background-color:#eeeeff;"> Number </td> 
 <td style="background-color:#eeeeff;"> <code>24</code> </td> 
 </tr> 
 <tr> 
 <td> <code>K</code> </td> 
 <td> am/pm 中的小时数（0-11） </td> 
 <td> Number </td> 
 <td> <code>0</code> </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> <code>h</code> </td> 
 <td style="background-color:#eeeeff;"> am/pm 中的小时数（1-12） </td> 
 <td style="background-color:#eeeeff;"> Number </td> 
 <td style="background-color:#eeeeff;"> <code>12</code> </td> 
 </tr> 
 <tr> 
 <td> <code>m</code> </td> 
 <td> 小时中的分钟数 </td> 
 <td> Number </td> 
 <td> <code>30</code> </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> <code>s</code> </td> 
 <td style="background-color:#eeeeff;"> 分钟中的秒数 </td> 
 <td style="background-color:#eeeeff;"> Number </td> 
 <td style="background-color:#eeeeff;"> <code>55</code> </td> 
 </tr> 
 <tr> 
 <td> <code>S</code> </td> 
 <td> 毫秒数 </td> 
 <td> Number </td> 
 <td> <code>978</code> </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> <code>z</code> </td> 
 <td style="background-color:#eeeeff;"> 时区 </td> 
 <td style="background-color:#eeeeff;"> General time zone </td> 
 <td style="background-color:#eeeeff;"> <code>Pacific Standard Time</code>; <code>PST</code>; <code>GMT-08:00</code> </td> 
 </tr> 
 <tr> 
 <td> <code>Z</code> </td> 
 <td> 时区 </td> 
 <td> RFC 822 time zone </td> 
 <td> <code>-0800</code> </td> 
 </tr> 
 </tbody> 
</table>

**示例**

以下示例显示了如何在美国语言环境中解释日期和时间模式。给定的日期和时间为美国太平洋时区的本地时间 2001-07-0412:08:56。

<table> 
 <tbody> 
 <tr> 
 <td style="background-color:#ccccff;"> 日期和时间模式 </td> 
 <td style="background-color:#ccccff;"> 结果 </td> 
 </tr> 
 <tr> 
 <td> "yyyy.MM.dd G 'at' HH:mm:ss z" </td> 
 <td> 2001.07.04 AD at 12:08:56 PDT </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> "EEE, MMM d, ''yy" </td> 
 <td style="background-color:#eeeeff;"> Wed, Jul 4, '01 </td> 
 </tr> 
 <tr> 
 <td> "h:mm a" </td> 
 <td> 12:08 PM </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> "hh 'o''clock' a, zzzz" </td> 
 <td style="background-color:#eeeeff;"> 12 o'clock PM, Pacific Daylight Time </td> 
 </tr> 
 <tr> 
 <td> "K:mm a, z" </td> 
 <td> 0:08 PM, PDT </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> "yyyyy.MMMMM.dd GGG hh:mm aaa" </td> 
 <td style="background-color:#eeeeff;"> 02001.July.04 AD 12:08 PM </td> 
 </tr> 
 <tr> 
 <td> "EEE, d MMM yyyy HH:mm:ss Z" </td> 
 <td> Wed, 4 Jul 2001 12:08:56 -0700 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#eeeeff;"> "yyMMddHHmmssZ" </td> 
 <td style="background-color:#eeeeff;"> 010704120856-0700 </td> 
 </tr> 
 <tr> 
 <td> "yyyy-MM-dd'T'HH:mm:ss.SSSZ" </td> 
 <td> 2001-07-04T12:08:56.235-0700 </td> 
 </tr> 
 </tbody> 
</table>

想必看到这里大家就应该明白为什么要这样传递一个字符串参数了.

**四. Calender类**

接下来再看与Date相关的另外一个类，Calender，它是一个抽象类，不过这里类中有很多静态的具体方法和字段，这些是我们可以通过类名直接使用的，它的一字段都表示一个日历字段，我们发现它有一个**getInstance**`()` 方法，他还有ige重载版本的，这里就不多讲了，一般我们使用不带参数的就行了，这个方法会使用默认时区和语言环境获得一个日历，然后我再介绍几个它的比较重要的方法就行了，看代码吧。。。。。

package com.date;
    import java.util.*;
    import java.text.*;
    public class DateDemo2
    {
    	public static void main(String[] args)
    	{
    		String[] week = {"","周日","周一","周二","周三","周四","周五","周六"};
    		String[] year = {"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};
    //获取一个Calender类的实例。
    		Calendar c = Calendar.getInstance();
    //获取周中的星期几，并用中文表示，利用查表法在week数组中获得中文表示
    		int index1 = c.get(Calendar.DAY_OF_WEEK);
    //获得日历字段中的月，也表示用中文表示，同样也利用查表法获得中文表示
    		int index2 = c.get(Calendar.MONTH);
    //获得完整的时间，并打印。
    System.out.println(c.get(Calendar.YEAR)+"年"+year[index2]+c.get(Calendar.DAY_OF_MONTH)+"日"+"星期"+week[index1]);
    	}
    }

打印结果: 2010年八月5日 星期周一

再看一个例子，这个例子是获得任意年的2月有多少天:

package com.date;
    import java.util.*;
    import java.text.*;
    public class DateDemo3
    {
    	public static void main(String[] args)
    	{
    		System.out.println(getDays(2012));
    	}
    	public static int getDays(int year)
    	{
    		Calendar c = Calendar.getInstance();
    //强制设定c实例当中的月份为传进来年的3月1日，注意这里的要表示3月
    //1日却为什么是2呢，因为calender中月是从0开始表示的。
    		c.set(year,2,1);
          //然后利用add方法将月里面的天数往前减去1天，也就是表示2月的最后一天。
    		c.add(Calendar.DAY_OF_MONTH,-1);
    		int days = c.get(Calendar.DAY_OF_MONTH);
    		return days;
    	}
    }

运行结果为:29

**五. Math类**

Math类是一个用Final类型修饰的，是一个与数学操作相关的类，他和System类一样没有构造方法，但是他的字段和方法都是静态的，那就好了不用创建对象就能使用，太爽了，里面一些方法是求什么一些求正切，余切等等，这些方法我就不多说了，直接贴代码，在代码中加注解说说几个常用的方法就好了。。。

package com.Math;
 public class MathCeilDemo
 {
 	public static void main(String[] args)
 	{
 //返回最小的（最接近负无穷大）double 值，该值大于或等于参数，并且等于某个整数。
 		double d = Math.ceil(21.56);
 //返回最大的（最接近正无穷大）double 值，该值小于或等于参数，并且等于某个整数。
 		double d1 = Math.floor(21.56);
 //round(double a) 返回最接近参数的 long。round(float a) 返回最接近参数的 int。
 		int l = (int)Math.round(12.54);
 		int l2 = (int)Math.round(12.34);
 		int l3 = (int)Math.round(-12.34);
 //pow(double a, double b) 返回第一个参数的第二个参数次幂的值。
 		double d3 = Math.pow(3,3);
 		int a = 23;
 		int b = 24;
 //min(int a, int b) 返回两个 int 值中较小的一个。max(int a, int b) 返回两个 int 值中较//大的一个。
 		int max = Math.max(a,b);
 		int min = Math.min(a,b);
 		sop(d3);
 sop(d);
 sop(d1);
 sop(max);
 sop(min);
 sop(l);
 sop(l2);
 sop(l3);
 //最重要的一个方法random()，返回带正号的 double 值，大于或等于 0.0，小于 1.0，//不包含1.0，与这个方法异曲同工之妙的类还有java.util.Random，使用方法差不多，这//里就不介绍了。
 		for (int i = 1; i<=10 ; i++)
 		{
 			int d2 = (int)(Math.random()*11+20);
 			System.out.println(d2);
 		}
 	}
 public static void sop(Object o)
 {
 	System.out.println(o);
 }
 }

执行结果:

27.0

22.0

21.0

\-12

最后还有一个java.lang.String这个类也是一个经常用的的类，而且它是是使用最频繁的，所以要单独做一个笔记来讲解他了，所以这里就不多说了。