java 常用类

0.String类

构造方法：

String()	初始化一个新创建的 String 对象，它表示一个空字符序列。
String(String orig)	初始化一个新创建的 String 对象，表示一个与该参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的一个副本。
String(byte[] bytes, int offset, int length)	构造一个新的 String，方法是使用指定的字符集解码字节的指定子数组。

初始化举例：

String s1="";

String s2=new String();

String s3=new String("aaa");

1.系统相关类

System类
- System类是一些与系统相关的属性和方法的集合，且System类中所有的属性和方法都是静态的，要想引用这些属性和方法，直接使用System类调用即可。
- System类的构造方法是private修饰的，所以不能创建该类的实例对象，但是可以通过类名直接调用。
- System类还被final关键字修饰，所以不能被继承。

　　1.System类的成员变量

in：标准输入流（键盘输入），InputStream类型
out：标准输出流（显示器输出），PrintStream类型
err：标准错误输出流（显示器输出），PrintStream类型

1 System.out.println("hello world");

　2.System类的成员方法

getProperty方法：获取系统的属性信息，常见的属性名以及属性说明如下表所示

属性名	属性说明
java.version	jdk版本
java.home	jdk安装目录
os.name	操作系统名称
os.version	操作系统版本
user.home	用户宿主目录
user.name	用户名称
user.dir	当前工作目录

代码示例：

1         System.out.println("jdk版本："+System.getProperty("java.version"));
2         System.out.println("操作系统："+System.getProperty("os.name"));
3         System.out.println("用户："+System.getProperty("user.name"));
4         System.out.println("用户目录："+System.getProperty("user.home"));
5         System.out.println("当前工作目录："+System.getProperty("user.dir"));

currentTimeMillis方法：获取当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。

1     Long ctime = System.currentTimeMillis();
2     System.out.println("系统当前时间："+ctime);//系统当前时间：1509009739936

arraycopy方法：进行数组拷贝，也就是将一个数组中的内容复制到另外一个数组中的指定位置，由于该方法是native方法，所以性能上比使用循环高效。（ArrayList的插入和删除操作就是调用System类的arraycopy方法实现的）

[ 复制代码 ](javascript:void(0)😉

 1         //将数组按指定要求进行复制
 2         char[] a = {'A','B','C','D'};
 3         char[] b = {'1','2','3','4','5'};
 4         /*
 5          * 将原数组a从第1个索引开始复制到目标数组b的第2个索引开始的位置，一共复制2个元素
 6          *     即是将a[1]复制给b[2],a[2]复制给b[3]，所以最终为1 2 B C 5
 7          */
 8         System.arraycopy(a, 1, b, 2, 2);
 9         for (int i = 0; i < b.length; i++) {
10             System.out.print(b[i]+" ");
11         }//1 2 B C 5

gc方法：请求系统进行垃圾回收，相当于给GC加上了优先级。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况，这个方法只是对Runtime类中的gc方法进行了一次包装。

1         //请求垃圾回收
2         System.gc();

exit方法：退出程序，其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
Runtime类

这里首先给出Runtime类的一些总结：

Runtime类封装了程序运行时的环境，每个java应用程序都有一个Runtime类的实例，使得应用程序能够与运行时的环境相连接。
和System类一样，不能创建Runtime类的实例对象（构造方法私有的），但是能够通过getRuntime静态方法获取该对象的一个引用。
一旦得到了一个当前Runtime类的引用，就可以通过调用Runtime对象的成员方法来控制JVM的状态和行为。

1.Runtime类的内存管理

Runtime类代表了java程序的运行环境，通过Runtime类可以访问JVM的相关信息，如处理器数量、内存信息等等。另外还有Runtime类的gc方法，通知JVM进行垃圾回收，这是一个native方法，由C语言实现。

1     //获取java程序关联的运行时对象
2     Runtime runtime = Runtime.getRuntime();
3     
4     System.out.println("处理器数量："+runtime.availableProcessors());
5     System.out.println("空闲内存数："+runtime.freeMemory());
6     System.out.println("总内存数："+runtime.totalMemory());
7     System.out.println("最大可用内存数："+runtime.maxMemory());

2.Runtime类执行其他程序

除了能够获取JVM的信息之外，Runtime类还可以直接单独启动一条进程来运行操作系统的命令，主要调用exec这个成员方法来实现。

exec方法返回一个Process对象，可以使用这个对象来控制java程序与新运行的进程来进行交互操作。
exec方法的本质是依赖于环境。
Runtime提供了系列exec方法来运行操作系统的命令，关于它们的用法和差别可以查阅API文档。

1     //获取java程序关联的运行时对象
2     Runtime runtime = Runtime.getRuntime();
3 
4     //运行记事本程序
5     runtime.exec("notepad.exe");

2.日期时间类

java提供了一系列用于处理日期、时间的类，包括创建日期、时间对象，获取系统当前日期、时间等的操作。

Date类

java提供了Date类来处理日期和时间，这里介绍的是java.util包下的Date类，而不是java.sql包下的Date类。由于这个Date类的历史悠久，所以大部分构造器、成员方法已经失效，这里先介绍它未失效的两个构造器：

Date()：生成一个代表当前日期时间的Date对象，该方法实际是调用System类的currentTimeMillis()方法获取long型的整数作为日期参数。
Date(long Date)：根据指定的long型整数来生成一个Date对象。创建的对象是从1970年01月01日00时（格林威治时间）开始以毫秒计算时间，计算 millisec 毫秒。

由于Date类的大部分成员方法也失效了，这里介绍一些还未失效的方法：

boolean after(Date when)：测试该日期是否在指定日期when之后。
boolean before(Date when)：测试该日期是否在指定日期when之前。
int compareTo(Date anotherDate)：比较两个日期的大小，后面的时间大于前面的时间时返回-1，否则返回1。
boolean equals(Object obj)：比较两个时间是否相同，当表示同一时刻时返回true。
long getTime()：返回该时间对应的long型整数，一个毫秒值。
void setDate(long time)：设置Date对象的时间。

 1         Date date = new Date();
 2         System.out.println(date);//Mon Oct 30 15:09:54 CST 2017
 3         System.out.println(date.getTime());//1509347462950
 4         
 5         Date d1 = new Date(10000);
 6         Date d2 = new Date(20000);
 7         System.out.println(d1.before(d2));//true
 8         System.out.println(d1.compareTo(d2));//-1
 9         
10         date.setTime(100000000);
11         System.out.println(date);//Fri Jan 02 11:46:40 CST 1970

Date对象的格式化可以采用SimpleDateFormat这个类的format(Date date)方法，具体代码示例如下：

1         Date date = new Date();
2         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");    
3         System.out.println(simpleDateFormat.format(date));//2017/10/30 15:15:48

Calendar类

因为Date类在设计上的一些缺陷，所以java提供了Calendar类来更好地处理日期和时间。Calendar是一个抽象类，所以不能创建一个Calendar类的实例对象，但是可以通过getInstance静态方法获得。这里介绍一些Calendar类常用的操作：

getInstance()：获取Calendar的实例对象。
get()：获取calendar对象的日期和时间信息。
set()：设置日期和时间。
getTimeInMillis()：获取时间的毫秒级数据。
此外还介绍了一些日期时间格式化、计算时间差的方法。

 1     //通过getInstance()方法获得Calendar的实例对象
 2     Calendar calendar = Calendar.getInstance();
 3     
 4     /*
 5      * 通过calendar对象获取日期和时间信息
 6      *     注意：Calendar类中年份的数值直接书写，月份的值为实际的月份值减1，日期的值就是实际的日期值。
 7      */
 8     System.out.println(calendar.get(calendar.YEAR));//年
 9     System.out.println(calendar.get(calendar.MONTH)+1);//月
10     System.out.println(calendar.get(calendar.DAY_OF_MONTH));//日
11     System.out.println(calendar.get(calendar.HOUR_OF_DAY));//时
12     System.out.println(calendar.get(calendar.MINUTE));//分
13     System.out.println(calendar.get(calendar.SECOND));//秒
14     
15     //设置日期和时间
16     calendar.set(2017, 11, 10, 15, 30, 20);
17     
18     /*利用SimpleDateFormat进行格式化
19      *    注意：此处format方法传入的参数为一个Date对象，所以需要调用calendar对象的getTime方法以获取一个Date对象
20      */
21     System.out.println(new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(calendar.getTime()));//2017/12/10 15:30:20
22     
23     /*
24      *计算时间差：
25      *    通过调用calendar类的getTimeInMillis方法，计算毫秒级的时间差，再进行换算得到所需的时间差格式 
26      */
27     Calendar startCalendar = Calendar.getInstance();
28     startCalendar.set(2017, 6, 1, 12, 30, 50);//起始时间为2017/7/1 12:30:50
29     Calendar endCalendar = Calendar.getInstance();//结束时间为当前时间
30     long deltaTime = endCalendar.getTimeInMillis() - startCalendar.getTimeInMillis() ;
31     //直接输出毫秒级的时间差
32     System.out.println(deltaTime);
33     //换算成天数的时间差
34     System.out.println(deltaTime/(1000*3600*24));

3.Object类

Object类存储在java.lang包中，是所有java类(Object类除外)的终极父类。当然，数组也继承了Object类，但是，接口和枚举类是不继承Object类的。
java的任何类都继承了Object类的成员方法，并且可以重写不被final修饰的方法。
Object类包含的一些成员方法：

Object()方法：一般情况下，java通过new关键字来创建对象，而这是通过类中的构造方法来实现的。因此，java中规定：在类的定义过程中，对于未定义构造方法的类，默认会有一个无参的构造方法，作为所有java类的父类，Object自然也要体现这一特性。所以，在Object的源码中没有给出构造方法的具体定义，但实际上这个构造方法是存在的。
clone()方法：这个方法可以产生一个相同的类，并且返回给调用者。这是一个native方法，由C语言实现，使用时需要注意：当代码执行的时候，将会检查调用对象的类(或者父类)是否实现了java.lang.Cloneable接口(Object类不实现Cloneable)。如果没有实现这个接口，clone()将会抛出一个检查异常()——java.lang.CloneNotSupportedException,如果实现了这个接口，clone()会创建一个新的对象，并将原来对象的内容复制到新对象，最后返回这个新对象的引用。
finalize()方法：finalize()也是一个native方法，并且这个方法可以被子类对象所覆盖，然后作为一个终结者，当GC被调用的时候完成最后的清理工作（例如释放系统资源之类）。默认的finalize()方法什么也不做，当被调用时直接返回。
Object还提供了wait、notify、notifyAll几个方法，用于控制线程的暂停和运行，这将在以后的文章中进行详细介绍。
clone()方法的使用示例：

1 /*
2 * 定义一个Person类，并实现Cloneable接口
3 */
4 public class Person implements Cloneable {
5
6 @Override
7 protected Object clone() throws CloneNotSupportedException {
8 // TODO Auto-generated method stub
9 return super.clone();
10 }
11
12 public String name;
13 }

1 public class CloneTest {
2 public static void main(String[] args) throws CloneNotSupportedException {
3 //创建一个Person对象，并初始化
4 Person p1 = new Person("hello");
5 System.out.println(p1.name);//hello
6
7 /*
8 * 调用clone方法，对p1对象进行克隆
9 * 注意：当代码执行的时候，将会检查调用对象的类(或者父类)是否实现了java.lang.Cloneable接口(Object类不实现Cloneable)。
10 * 如果没有实现这个接口，clone()将会抛出一个检查异常()——java.lang.CloneNotSupportedException,
11 * 如果实现了这个接口，clone()会创建一个新的对象，并将原来对象的内容复制到新对象，最后返回这个新对象的引用。
12 */
13 //所以，此处会先检查Person类是否实现了Cloneable，即重写clone()方法。
14 Person p2 = (Person) p1.clone();
15 System.out.println(p2.name);//hello
16
17 }
18
19 }



### 4.Math类

Math类提供了基本数学函数的计算方法，并且Math类中所有的成员变量（主要指PI和E）和成员方法都是静态的，可以通过类名直接调用。这里只是简单列举一些：

![img](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif) View Code

需要注意的是Math类中的取整方法：rint和round。

- rint遇到x.5的时候会取偶数
- round(x) = floor(x+0.5)

### 5.Random类

Random类用于生成伪随机数，它有两个构造器：一个构造器使用默认的种子（系统当前时间的毫秒值）；另一个构造器需要程序员显示的传入一个long型的参数作为种子。

1 public static void main(String[] args) {
2
3 //使用默认种子的构造器，以系统当前时间的毫秒数作为种子
4 Random random = new Random();
5 for (int i = 0; i < 10; i++) {
6 System.out.print(random.nextInt(10)+" ");
7 }//5 0 2 6 5 0 4 1 4 9
8
9 /*使用带参数的构造器，传入一个long型整数作为种子
10 *需要注意的是：
11 * 相同种子数的Random对象，相同次数生成的随机数字是完全相同的。
12 * 即是，两个种子数相同的Random对象，第一次生成的随机数完全相同，第二次生成的随机数也完全相同
13 * 这点在生成多个随机数字时需要特别注意。
14 */
15 Random r1 = new Random(10);
16 Random r2 = new Random(10);
17 System.out.println(r1.nextInt() == r2.nextInt());//true
18 System.out.println(r1.nextInt() == r2.nextInt());//true
19
20 }




因此，为了避免两个Random对象产生相同的随机数序列，我们通常使用系统当前时间作为种子来生成随机数。而且，Random类还提供了一些其他类型的随机数生成方法，如nextDouble、nextFloat、nextLong、nextBoolean等。

1 Random random = new Random();
2
3 //nextDouble方法，产生[0.0,1.0)之间的double型随机数
4 //注意：Math类中的random方法就是调用Random类中的nextDouble方法实现的。
5 for (int i = 0; i < 10; i++) {
6 System.out.print(random.nextDouble()+" ");
7 }
8 System.out.println();
9
10 //nextFloat方法，产生[0.0,1.0)之间的float型随机数
11 for (int i = 0; i < 10; i++) {
12 System.out.print(random.nextFloat()+" ");
13 }
14 System.out.println();
15
16 //nextLong方法，产生long型的随机整数
17 for (int i = 0; i < 10; i++) {
18 System.out.print(random.nextLong()+" ");
19 }
20 System.out.println();
21
22 //nextBoolean方法，产生随机的布尔数
23 for (int i = 0; i < 10; i++) {
24 System.out.print(random.nextBoolean());
25 }
26



### 6.File类

 File类是java.io包下用于操作与平台无关的文件和目录，也就是说，不管是文件还是目录都是使用File类来操作的。File类能够新建、删除和重命名文件和目录，但是File类不能访问文件的内容，需要通过输入/输出流来访问。

- 构造方法：File(String pathname)、File(String parent, String child)、File(File parent, String child)、File(URI uri)
- 创建文件和目录：createNewFile() 文件不存在则创建并返回true，否则返回false、mkdir()创建目录、mkdirs()创建多级目录
- 删除文件和目录：delete()、deleteOnExit()
- 文件和目录信息获取：getName()、getPath()、getAbsolutePath()、getAbsoluteFile()、getParent()、getParentFile()等等。
- 获取指定目录下文件列表：listFiles()、list()
- 文件过滤：list(FilenameFilter filter)、listFiles(FilenameFilter filter)、listFiles(FileFilter filter)，代码示例如下：

1　　 /*
2 * 从根目录开始搜索符合条件的文件
3 */
4 public static void main(String[] args){
5 File[] files =File.listRoots();
6 for(File file:files){
7 System.out.println(file);
8 if(file.length()>0){
9 String[] filenames =file.list(new FilenameFilter(){
10 //file 过滤目录 name 文件名
11 public boolean accept(File file,String filename){
12 return filename.endsWith(".mp3");
13 }
14 });
15 for(String filename:filenames){
16 System.out.println(filename);
17 }
18 }
19 }
20 }
21
22
23 public static void main(String[] args) {
24 // System.out.println(System.getProperty("user.dir"));
25
26 //先获取文件列表，再进行逐个筛选
27 File fileRoot = new File("D:\...\codeAnal");
28 File[] files = fileRoot.listFiles();
29 for(File file: files){
30 if(file.getName().startsWith("C")){
31 System.out.println(file.getName());
32 }
33 }
34 }



### 7.枚举类（Enum）

 在一些特定的情况下，某个类的对象是有限而且固定的，例如季节类，它只有四个对象，再例如星期类，只有七个对象等等。这种实例对象有限而且固定的类在java中称为枚举类。

#### 一、手动实现一个枚举类

一般来说有下面几个步骤：

- 将枚举类的构造器定义为private，使得其它类不可自行创建该类的实例对象；
- 将这个类的所有可能的实例对象用public static final来修饰，即定义为该类的静态常量；
- 在必要的情况下，提供一些静态方法，允许其他类通过指定参数来获取指定的实例对象。

代码示例如下：

1 /*
2 * 这是一个枚举类，只有四个实例对象
3 */
4 public class Season {
5
7 //将season类定义成私有的，将其属性也定义成final
8 private final String name;
9 private final String desc;
10 public static final Season SPRIGN = new Season("春天", "春天来了");
11 public static final Season SUMMER = new Season("夏天", "夏天来了");
12 public static final Season FALL = new Season("秋天", "秋天来了");
13 public static final Season WINTER = new Season("冬天", "冬天来了");
14
15 private Season (String name, String desc) {
16 this.name = name;
17 this.desc = desc;
18 }
19
20 //定义一个获取season对象的方法，这是一个静态工厂方法
21 public static Season getSeason(int seasonNum){
22 switch(seasonNum){
23 case 1: return SPRIGN;
24 case 2: return SUMMER;
25 case 3: return FALL;
26 case 4: return WINTER;
27 default: return null;
28 }
29 }
30
31 public String getDesc() {
32 return desc;
33 }
34
35 public String getName() {
36 return name;
37 }
38
39 @Override
40 public String toString() {
41 return "Season [name=" + name + ", desc=" + desc + "]";
42 }
43 }

1 public class EnumDemo {
2 public static void main(String[] args) {
3 //获取枚举类的实例对象
4 System.out.println(Season.getSeason(1).toString());//Season [name=春天, desc=春天来了]
5 System.out.println(Season.SPRIGN.toString());//Season [name=春天, desc=春天来了]
6 System.out.println(Season.FALL.toString());//Season [name=秋天, desc=秋天来了]
7 }
8
9 }



 通过观察代码可知，使用枚举类可以增加程序的健壮性，能够避免随意地创建对象。

####  二、枚举类的简单使用

JDK1.5新增了enum关键字，其作用类似于class和interface关键字，将生成一个枚举类，即一种特殊的java类。这种枚举类与其他一些普通类有如下简单区别：

- 使用enum定义的枚举类默认继承了java.lang.Enum类，而不是继承Object类。
- 枚举类的构造器只能使用private关键字来修饰，如果省略此关键字，则默认使用private修饰。
- 枚举类中的所有实例必须显示列出，而且对于列出的实例，系统都会自动加上public static final修饰，无序程序员手动添加。
- 所有枚举类都提供了一个values方法，用于遍历所有的枚举值。

代码示例：

1 /*
2 * 定义一个枚举类
3 */
4 public enum SeasonNum {
5 SPRING,SUMMER,FALL,WINTER;
6 }

1 public class EnumDemo {
2
3 public static void main(String[] args) {
4
5 //通过values方法遍历枚举值，即枚举类的所有实例
6 for(SeasonNum season: SeasonNum.values()){
7 System.out.print(season+" ");
8 }//SPRING SUMMER FALL WINTER
9
10 System.out.println();
11 judge(SeasonNum.SPRING);//春天来了
12
13 }
14
15 private static void judge(SeasonNum season) {
16
17 switch (season) {
18 case SPRING:
19 System.out.println("春天来了");
20 break;
21 case SUMMER:
22 System.out.println("夏天来了");
23 break;
24 case FALL:
25 System.out.println("秋天来了");
26 break;
27 case WINTER:
28 System.out.println("冬天来了");
29 break;
30 default:
31 break;
32 }
33 }
34 }


####  三、实现接口的枚举类

枚举类可以实现一个或者多个接口，与普通类一样，枚举类实现接口时也需要实现该接口所包含的方法。但是不同的是：如果需要每个枚举值在调用接口中的方法时呈现不同的行为方式，则可以让每个枚举值分别按照自己的方式来实现该方法。每个枚举值提供不同的实现方式，从而让不同枚举值调用该方法时具有不同的行为方式。

代码示例：

1 /*
2 * 定义一个性别的接口类
3 */
4 public interface GenderInfo {
5
6 void info();
7 }

1 /*
2 * 定义一个性别的枚举类，实现GenderInfo接口
3 */
4 public enum Gender implements GenderInfo {
5
6 //此处的枚举值必须调用对应的构造器来实现，并且不同的枚举值提供不同的实现方式
7 MALE("男"){
8 @Override
9 public void info() {
10 System.out.println("这是一个男性的枚举值");
11 }
12 },
13
14 FEMALE("女"){
15 @Override
16 public void info() {
17 System.out.println("这是一个女性的枚举值");
18 }
19 };
20
21 private final String name;
22 //自定义枚举类的构造器，访问修饰符必须为private
23 private Gender(String name){
24 this.name = name;
25 }
26
27 }

1 /*
2 * 接口枚举类的测试
3 */
4 public class GenderEnumDemo {
5
6 public static void main(String[] args) {
7 //通过类名直接获取枚举类的实例对象，然后调用info方法
8 Gender.MALE.info();//输出：这是一个男性的枚举值
9 Gender.FEMALE.info();//输出：这是一个男女性的枚举值
10 }
11 }

posted @ 2020-07-17 14:15 闲棋阅读(77) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

java 常用类

0.String类

1.系统相关类

System类

Runtime类

2.日期时间类

Date类

Calendar类

3.Object类

公告