常用类(包装类；String类；StringBuilder/StringBuffer类；时间相关类；Math类；File类；枚举)

包装类:

Java是面向对象的语言,但并不是“纯面向对象”的,因为我们经常用到的基本数据类型就不是对象.但是我们在实际应用中经常需要将
 基本数据转化成对象,以便于操作.比如：将基本数据类型存储到Object[]数组或集合中的操作等等.

为了解决这个不足,Java在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个和基本数据类型对应的类统称为包装类(Wrapper Class).

    包装类均位于java.lang包,八种包装类和基本数据类型的对应关系如表:
    ------------------------------------------------------------
                        基本数据类型　　　　　　　包装类

                          byte                 Byte
                         boolean              Boolean
                          short                Short
                          char                Character
                          int                  Integer
                          long                 Long
                          float                Float          
                          double               Double

    -----------------------------------------------------------
    
在这八个类名中,除了Integer和Character类以外,其它六个类的类名和基本数据类型一致,只是类名的第一个字母大写而已.

在这八个类中,除了Character和Boolean以外,其他的都是“数字型”,“数字型”都是java.lang.Number的子类.
Number类是抽象类,因此它的抽象方法,所有子类都需要提供实现.Number类提供了抽象方法：intValue()、longValue()、
floatValue()、doubleValue(),意味着所有的“数字型”包装类都可以互相转型.

包装类的用途:

1. 作为和基本数据类型对应的类型存在,方便涉及到对象的操作,如Object[]、集合等的操作.

2. 包含每种基本数据类型的相关属性如最大值、最小值等,以及相关的操作方法(这些操作方法的作用是在基本数据类型、包装类对象、
字符串之间提供相互之间的转化!).
-------------------------------------------------------

例子:

public class TestWrappedClass {
	
	public static void main(String[] args) {
		// 基本数据类型转成包装类
		Integer a = new Integer(33);
		Integer b = Integer.valueOf(23);
		
		// 把包装类对象转成基本数据类型
		int c = b.intValue();
	 	double d = b.doubleValue();
		
		// 把字符串转成包装类对象
	 	Integer e = new Integer("998");
	 	Integer f = Integer.parseInt("123123");
	 	
	 	// 把包装类转成字符串
	 	String str = f.toString();
	 	
	 	// 常见的常量
	 	System.out.println("int类型最大的整数 : " + Integer.MAX_VALUE);
	 	
		// 将字符串转为基本数据类型
	 	int x = Integer.parseInt("123");
	 	x++;
	 	System.out.print(x);
		
	}
	
}
-------------------------------------------------------

自动装箱和拆箱:

自动装箱和拆箱就是将基本数据类型和包装类之间进行自动的互相转换.JDK1.5后,Java引入了自动装箱(autoboxing)/拆箱(unboxing).

自动装箱：

  基本类型的数据处于需要对象的环境中时,会自动转为“对象”.

  我们以Integer为例：在JDK1.5以前,这样的代码 Integer i = 5 是错误的,必须要通过Integer i = new Integer(5) 
  这样的语句来实现基本数据类型转换成包装类的过程;而在JDK1.5以后,Java提供了自动装箱的功能,因此只需Integer i = 5
  这样的语句就能实现基本数据类型转换成包装类,这是因为JVM为我们执行了Integer i = Integer.valueOf(5)这样的操作,
  这就是Java的自动装箱.

自动拆箱：

  每当需要一个值时,对象会自动转成基本数据类型,没必要再去显式调用intValue()、doubleValue()等转型方法.

  如 Integer i = 5;int j = i; 这样的过程就是自动拆箱.

  我们可以用一句话总结自动装箱/拆箱：

  自动装箱过程是通过调用包装类的valueOf()方法实现的,而自动拆箱过程是通过调用包装类的 xxxValue()方法实现的
  (xxx代表对应的基本数据类型,如intValue()、doubleValue()等).

  自动装箱与拆箱的功能事实上是编译器来帮的忙,编译器在编译时依据您所编写的语法,决定是否进行装箱或拆箱动作

包装类的缓存问题:

整型、char类型所对应的包装类,在自动装箱时,对于-128~127之间的值会进行缓存处理,其目的是提高效率.

缓存处理的原理为：如果数据在-128~127这个区间,那么在类加载时就已经为该区间的每个数值创建了对象,并将这256个对象存放到
一个名为cache的数组中.每当自动装箱过程发生时(或者手动调用valueOf()时),就会先判断数据是否在该区间,如果在则直接获取
数组中对应的包装类对象的引用,如果不在该区间,则会通过new调用包装类的构造方法来创建对象.
---------------------------------------------------------------
例子:

public class TestBoxClass {
	
	public static void main(String[] args) {

		Integer a = 11; // 自动装箱 Integer a = Integer.valueOf(11);
		int b = a;  // 自动拆箱 int b = a.intValue();
		
		// 缓存[-128,127]之间的数字.实际就是系统初始化的时候,创建了[-128,127]之间的一个缓存数组.
		// 当我们调用valueOf()的时候,首先检查是否在[128,-127]之间,如果在这个范围则直接从缓存数组中拿出来已经建好的对象
		// 如果不在这个范围内,则创建新的Integer对象.
		Integer n1 = Integer.valueOf(-128);
		Integer n2 = -128;
		System.out.println(n1 == n2); // true因为123在缓存范围内
		System.out.println(n1.equals(n2)); // true
		System.out.println("----------------");
		Integer n3 = 1232; 
		Integer n4 = 1232;
		System.out.println(n3 == n4); // false,因为1232不在缓存范围内
		System.out.println(n3.equals(n4)); // true
	}
}
----------------------------------------------------------------

String类:

String 类对象代表不可变的Unicode字符序列,因此我们可以将String对象称为“不可变对象”.
“不可变对象”指的是对象内部的成员变量的值无法再改变.

我们发现String子符串内容全部存储到value[]数组中,而变量value是final类型的,也就是常量(即只能被赋值一次). 
这就是“不可变对象”的典型定义方式.

比如：substring()是对字符串的截取操作,但本质是读取原字符串内容生成了新的字符串

String类常用的方法有：

  1. String类的下述方法能创建并返回一个新的String对象: concat()、 replace()、substring()、 toLowerCase()、 
     toUpperCase()、trim().

  2. 提供查找功能的有关方法: endsWith()、 startsWith()、 indexOf()、lastIndexOf().

  3. 提供比较功能的方法: equals()、equalsIgnoreCase()、compareTo().

  4. 其它方法: charAt() 、length().

StringBuffer和StringBuilder:

StringBuffer和StringBuilder非常类似,均代表可变的字符序列. 这两个类都是抽象类AbstractStringBuilder的子类,
方法几乎一模一样.

常用方法列表：

  1. 重载的public StringBuilder append(…)方法

    可以为该StringBuilder 对象添加字符序列,仍然返回自身对象.

  2. 方法 public StringBuilder delete(int start,int end)

    可以删除从start开始到end-1为止的一段字符序列,仍然返回自身对象.

  3. 方法 public StringBuilder deleteCharAt(int index)

    移除此序列指定位置上的 char,仍然返回自身对象.

  4. 重载的public StringBuilder insert(…)方法

    可以为该StringBuilder 对象在指定位置插入字符序列,仍然返回自身对象.

  5. 方法 public StringBuilder reverse()

    用于将字符序列逆序,仍然返回自身对象.

  6. 方法 public String toString() 返回此序列中数据的字符串表示形式.

  7. 和 String 类含义类似的方法：
   -----------------------------------
    public int indexOf(String str)
    public int indexOf(String str,int fromIndex)
    public String substring(int start)
    public String substring(int start,int end)
    public int length() 
    char charAt(int index)
   -----------------------------------

=================================================
例子:
----------------------------------------------------------
public class TestStringBuilder {
	
	public static void main(String[] args) {
		String str;
		
		// StringBuilder线程不安全,效率高(一般用它);StringBuffer线程安全,效率低
		StringBuilder strb = new StringBuilder("adadw");
		
		System.out.println(Integer.toHexString(strb.hashCode()));
		System.out.println(strb);
		
		// 替换原字符串索引处的字符为指定字符
		strb.setCharAt(3, 'M');
		System.out.println(strb);
	}
}
--------------------------------------------------------

public class TestStringBuilder2 {
	
	public static void main(String[] args) {
		
		StringBuilder sb = new StringBuilder();
		sb.append("231");
		for(int i=0;i<26;i++) {
			char temp = (char)('a'+ i);
			sb.append(temp); // 追加
		}
		
		System.out.println(sb);
		sb.reverse(); // 反转(逆序)
		System.out.println(sb);
		sb.setCharAt(3, '六'); // 替换指定位置字符
		System.out.println(sb);
		// 链式调用,核心就是该方法调用了return this,把自己返回
		sb.insert(0, '网').insert(5, '罗').insert(23, '啊');
		System.out.println(sb);
		sb.delete(19, 22); // 删除指定字符[19,22) 22不取
		System.out.println(sb);
	}
}

时间处理相关类:

我们用long类型的变量来表示时间,从基准时间往前几亿年,往后几亿年都能表示.如果想获得现在时刻的“时刻数值”,可以使用：
long now = System.currentTimeMillis();

Date时间类(java.util.Date):

在标准Java类库中包含一个Date类.它的对象表示一个特定的瞬间,精确到毫秒.

  1. Date() 分配一个Date对象,并初始化此对象为系统当前的日期和时间,可以精确到毫秒).

  2. Date(long date) 分配 Date 对象并初始化此对象,以表示自从标准基准时间(称为“历元(epoch)”,
     即 1970 年 1 月 1 日 00:00:00 GMT)以来的指定毫秒数.

  3. boolean after(Date when) 测试此日期是否在指定日期之后.

  4. booleanbefore(Date when) 测试此日期是否在指定日期之前.

  5. boolean equals(Object obj) 比较两个日期的相等性.

  6. long getTime() 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数.

  7. String toString() 把此 Date 对象转换为以下形式的 String：
    dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun、 Mon、Tue、Wed、 Thu、 Fri、 Sat).

JDK1.1之后,日期操作一般使用Calendar类,而字符串的转化使用DateFormat类.
----------------------------------------------------
例子:

import java.util.Date;

public class TestDate {
	public static void main(String[] args) {
		// 不传数字时默认获取当前时间
		Date d = new Date(1600902230013L);
		System.out.println(d);
		
		Date d2 = new Date();
		System.out.println(d2.getTime());
		System.out.println(d2);
		System.out.println(d2.after(d));
	}
}
--------------------------------------------------

DateFormat类和SimpleDateFormat类:

DateFormat类的作用:
 把时间对象转化成指定格式的字符串.反之,把指定格式的字符串转化成时间对象.
 DateFormat是一个抽象类,一般使用它的的子类SimpleDateFormat类来实现.

-------------------------------------------------
例子:

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestDateFormat {
	
	public static void main(String[] args) throws ParseException {
		
		// 把时间对象按照"格式字符串指定的格式"　转换成相应的字符串
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		String str = df.format(new Date().getTime());
		System.out.println(str);
		
		// 把字符串按照"格式字符串指定的格式"　转成相应的对象
		DateFormat df2 = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
		Date date = df2.parse("2020年10月10日 22时22分22秒");
		System.out.println(date);
		
		// 测试其他的格式字符. 比如利用D,获取本时间对象是所处年份的第几天
		DateFormat df3 = new SimpleDateFormat("D");
		String str3 = df3.format(new Date().getTime());
		System.out.println(str3);
		
	}
}
------------------------------------------------
                       表(格式化宇符的含义)

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

Calendar日历类:

Calendar 类是一个抽象类,为我们提供了关于日期计算的相关功能,比如：年、月、日、时、分、秒的展示和计算.

GregorianCalendar 是 Calendar 的一个具体子类,提供了世界上大多数国家/地区使用的标准日历系统.
----------------------------------------------------------------
例子:

import java.util.Date;
import java.util.Calendar;
import java.util.GregorianCalendar;

public class TestCanlendar {
	
	public static void main(String[] args) {
		// 获得日期相关元素
		Calendar calendar = new GregorianCalendar(2000,10,24,12,22,2);
		int year = calendar.get(Calendar.YEAR);
		int month = calendar.get(Calendar.MONTH);
		int day = calendar.get(Calendar.DATE);
		int weekday = calendar.get(Calendar.DAY_OF_WEEK);
		// 直接打印此对象将得到很多日期相关信息
		System.out.println(calendar);
		System.out.println(year);
		System.out.println(month);
		System.out.println(day);
		System.out.println(weekday);
		
		// 设置日期的相关元素
		Calendar c2 = new GregorianCalendar();
		c2.set(Calendar.YEAR, 2060);
		
		System.out.println(c2);
		
		// 日期的计算
		Calendar c3 = new GregorianCalendar();
		c3.add(Calendar.YEAR, -10);
		System.out.println(c3);
		
		// 日期对象和时间对象的转换
		// System.out.println(c3.getTime());
		Date d4 = c3.getTime();
		Calendar c4 = new GregorianCalendar();
		c4.setTime(new Date());
	}
	
}

可视化日历:

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Scanner;

public class VisualCalendar {
	public static void main(String[] args) throws ParseException {
		
		System.out.println("请输入日期(格式:2020-9-10):");
		Scanner scanner = new Scanner(System.in);
		String str = scanner.nextLine();
		
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		// 将格式化字符串转为日期对象
		Date date = df.parse(str);
		// 创建日期计算类
		Calendar c = new GregorianCalendar();
		// 设置日期为输入的日期(将时间对象转换为日期对象)
		c.setTime(date);
		// 获取输入的日期为这个月的哪一天
		int day = c.get(Calendar.DAY_OF_MONTH);
		int days = c.getActualMaximum(Calendar.DATE);
		
		System.out.println("日\t一\t二\t三\t四\t五\t六");
		// 设置当前时期为这个月的一号
		c.set(Calendar.DAY_OF_MONTH, 1);
		// 获取这月的一号是周几,并在前面添加制表符
		for(int i=0;i<c.get(Calendar.DAY_OF_WEEK)-1;i++) {
			System.out.print("\t");
		}
		
		for(int i=1;i<days;i++) {
			// 判断如过是输入的那一天则顺便输出'*'
			if(day == c.get(Calendar.DAY_OF_MONTH)) {
				System.out.print(c.get(Calendar.DAY_OF_MONTH)+"*\t");
			}else {
				System.out.print(c.get(Calendar.DAY_OF_MONTH)+"\t");
			}
			// 如果是周六则换行
			if(c.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY) {
				System.out.println(); // 换行
			}
			// 将当前日期向后加一天
			c.add(Calendar.DAY_OF_MONTH, 1);
		}	
	}
}

Math类:

java.lang.Math提供了一系列静态方法用于科学计算;其方法的参数和返回值类型一般为double型.

Math类的常用方法：

  1. abs 绝对值
  2. acos,asin,atan,cos,sin,tan 三角函数
  3. sqrt 平方根
  4. pow(double a, double b) a的b次幂
  5. max(double a, double b) 取大值
  6. min(double a, double b) 取小值
  7. ceil(double a) 大于a的最小整数
  8. floor(double a) 小于a的最大整数
  9. random() 返回 0.0 到 1.0 的随机数
  10. long round(double a) double型的数据a转换为long型(四舍五入)
  11. toDegrees(double angrad) 弧度->角度
  12. toRadians(double angdeg) 角度->弧度
---------------------------------------------

public class TestMath {
    public static void main(String[] args) {
        //取整相关操作
        System.out.println(Math.ceil(3.2));
        System.out.println(Math.floor(3.2));
        System.out.println(Math.round(3.2));
        System.out.println(Math.round(3.8));
        //绝对值、开方、a的b次幂等操作
        System.out.println(Math.abs(-45));
        System.out.println(Math.sqrt(64));
        System.out.println(Math.pow(5, 2));
        System.out.println(Math.pow(2, 5));
        //Math类中常用的常量
        System.out.println(Math.PI);
        System.out.println(Math.E);
        //随机数
        System.out.println(Math.random());// [0,1)
    }
}
--------------------------------------------
Math类中虽然为我们提供了产生随机数的方法Math.random(),但是通常我们需要的随机数范围并不是[0, 1)之间的double类型的数据,
这就需要对其进行一些复杂的运算.如果使用Math.random()计算过于复杂的话,我们可以使用例外一种方式得到随机数,即Random类,
这个类是专门用来生成随机数的,并且Math.random()底层调用的就是Random的nextDouble()方法.

Random类的常用方法:

import java.util.Random;
public class TestRandom {
    public static void main(String[] args) {
        Random rand = new Random();
        //随机生成[0,1)之间的double类型的数据
        System.out.println(rand.nextDouble());
        //随机生成int类型允许范围之内的整型数据
        System.out.println(rand.nextInt());
        //随机生成[0,1)之间的float类型的数据
        System.out.println(rand.nextFloat());
        //随机生成false或者true
        System.out.println(rand.nextBoolean());
        //随机生成[0,10)之间的int类型的数据
        System.out.println(rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据
        System.out.println(20 + rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据（此种方法计算较为复杂）
        System.out.print(20 + (int) (rand.nextDouble() * 10));
    }
}
------------------------------------------------

File类的基本用法:

java.io.File类：代表文件和目录. 在开发中,读取文件、生成文件、删除文件、修改文件的属性时经常会用到本类.

File类的常见构造方法：public File(String pathname)

  以pathname为路径创建File对象,如果pathname是相对路径,则默认的当前路径在系统属性user.dir中存储

f.delete(); // 将该文件或目录从硬盘上删除
-----------------------------
例子:

import java.io.File;
import java.io.IOException;
import java.util.Date;

public class TestFile {
	public static void main(String[] args) throws IOException {
		// 打开指定位置的文件
		File f = new File("/home/sweetheart/Test/nn.txt");
		// 输出文件路径
		System.out.println(f);
		// 对文件重命名
		f.renameTo(new File("/home/sweetheart/Test/nn.txt"));
		// 获取当前运行文件所在项目路径
		System.out.println(System.getProperty("user.dir"));
		// 创建文件对象
		File f2 = new File("gg.txt");
		// 创建文件
		f2.createNewFile();
		
		System.out.println("File是否存在："+f.exists());
		System.out.println("File是否是目录："+f.isDirectory());
		System.out.println("File是否是文件："+f.isFile());
		System.out.println("File最后修改时间："+new Date(f.lastModified()));
		System.out.println("File的大小："+f.length());
		System.out.println("File的文件名："+f.getName());
		System.out.println("File的目录路径："+f.getAbsolutePath());
		
		File f3 = new File("/home/sweetheart/Test/电影/华语/大陆");
		boolean flag = f3.mkdir(); // 目录结构中有一个不存在,则不会创建目录树
		System.out.println(flag);
		boolean flag2 = f3.mkdirs(); // 会递归创建
		System.out.println(flag2);
	}
	
}
--------------------

递归遍历目录结构和树状展现:

import java.io.File;

public class TestDirTree {
	public static void main(String[] args) {
		File f = new File("/home/sweetheart/java_code");
		printFile(f, 0);
	}
	
	static void printFile(File file, int level) {
		for(int i=0;i<level;i++) {
			System.out.print("-");
		}
		
		System.out.println(file.getName());
		// 判断是否是文件夹
		if(file.isDirectory()) {
			// 获取文件夹下的文件放到数组里面
			File[] files = file.listFiles();
			for(File tt:files) {
				printFile(tt,level+1);
			}
		}	
	}
}

枚举:

enum  枚举名 {
  枚举体（常量列表）
}

所有的枚举类型隐性地继承自 java.lang.Enum.枚举实质上还是类!而每个被枚举的成员实质就是一个枚举类型的实例,
他们默认都是public static final修饰的.可以直接通过枚举类型名使用它们.
-----------------------

import java.util.Random;

public class TestEnum {
	public static void main(String[] args) {
		Season ss = Season.AUTUMN;
		// vlaues()方法返回数组
		int a = new Random().nextInt(4);
		switch(Season.values()[a]) {
			case SPRING:
				System.out.println("春天来了");
				break;
			case AUTUMN:
				System.out.println("秋天来了");
				break;
			case SUMMER:
				System.out.println("夏天来了");
				break;
			case WINTER:
				System.out.println("冬天来了");
				break;
		}
	}
}

enum Season{
	SPRING,SUMMER,AUTUMN,WINTER
}
-----------------------------------------