tinyint对应java数据类型_015、Java常用类

1包装类基本知识

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

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

基本数据类型的对应关系

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

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

2.包装类的用途

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

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

构造方法：

Integer(int value):构造一个新分配的 Integer对象，该对象表示指定的 int值。

Integer(String s):构造一个新分配 Integer对象，表示 int由指示值 String参数。

常用的方法：

static int max(int a, int b)返回两个 int的较大值，就像调用 Math.max一样 。

static int min(int a, int b) 返回两个 int的较小值，就像调用 Math.min一样 。

static String toBinaryString(int i) 将指定的整数转换2进制的字符串表示。

static String toOctalString(int i) 将指定的整数转换8进制的字符串表示。

static String toHexString(int i) 将指定的整数转换16进制的字符串表示。

包装类的使用

/**
 * 包装类的作用：
 * 1.作为和基本数据类型对应的类型存在，方便涉及到对象的操作，如Object[]、集合等的操作。(可以通过自动装箱解决)
 * 2.包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。
 * 将字符串转换为Integer对象的方法：
 * 1.调用Integer(String str)构造方法。
 * 2.调用Integer.paserInt(String str)：将字符串转换为int类型
 * @author Administrator
 *
 * 日期：2019年7月
 */
public class TestWapper2 {
	public static void main(String[] args) {
		Integer i1 = new Integer(10);//如果是最新的JDK12，该方法已经"过时".
		Integer i2 = Integer.valueOf(15);//推荐
		Integer i3 = new Integer("123");
	//	Date date = new Date(2019,1,1);//已过时的方法，不推荐使用，但依然可以使用
		int i4 = Integer.parseInt("123");
	}
}

3.自动装箱和拆箱

自动装箱和拆箱就是将基本数据类型和包装类之间进行自动的互相转换。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()等)。

包装类空指针异常问题

/**
 * 自动装箱和拆箱就是将基本数据类型和包装类之间进行自动的互相转换。
 * JDK1.5之后，java引入了自动装箱(autoboxing)/拆箱(unboxing).
 * 装箱（autoboxing）：将基本类型转换为包装类型。
 * 拆箱(unboxing)：将包装类型转换为基本类型
 *
 * 日期：2019年7月
 */
public class TestBoxing {
	public static void main(String[] args) {
		//JDK1.5之前需要手工完成装箱和拆箱
		int i = 123;
		Integer i2 = new Integer(i);//手工装箱:int--->Integer
		int i3 = i2.intValue();//手工拆箱：Integer--->int
		//JDK1.5之后支持自定装箱和拆箱
		Integer i4 = i;//自动封箱:int--->Integer
		int i5 = i4;//自动拆箱:Integer--->int(本质调用的i4.intValue())
		Integer i6 = null;
		int i7 = i6;//本质调用i6.intValue()方法，因为i6对象null所以会出现NullPointerException异常
	}
}

4.包装类的缓存问题

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

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

/*
 * 在自动装箱时，对于-128~127之间的值会进行缓存处理，其目的是提高效率。
 * 每当自动装箱过程发生时(或者手动调用valueOf()时)，就会先判断数据是否在该区间，
 * 如果在则直接获取数组中对应的包装类对象的引用，如果不在该区间，则会通过new调用包装类的构造方法来创建对象。
 */
public class TestCache {
	public static void main(String[] args) {
		Integer i1 = Integer.valueOf(123);
		Integer i2 = Integer.valueOf(123);
		System.out.println(i1==i2);
		System.out.println(i1.equals(i2));
		Integer i3 = Integer.valueOf(1234);
		Integer i4 = Integer.valueOf(1234);
		System.out.println(i3==i4);
		System.out.println(i3.equals(i4));
	}
}

5.String类

String 类对象代表不可变的Unicode字符序列，因此我们可以将String对象称为“不可变对象”。 那什么叫做“不可变对象”呢?指的是对象内部的成员变量的值无法再改变。

/**
 * 字符串：String具有不可变性，其本质使用的final修饰的char类型的数组实现，拼接字符串效率较低。
 */
public class TestString {
	public static void main(String[] args) {
		String str="abc";
		long begin = System.currentTimeMillis();//获取当前时间距1970-1-1 00:00:00:000之间总毫秒
		for(int i=0;i<100000;i++) {
			str = str+i;//字符串拼接
		}
		long end = System.currentTimeMillis();//获取当前时间距1970-1-1 00:00:00:000之间总毫秒数
		System.out.println("总耗时:"+(end-begin));
	}
}

public class TestString2 {
	/**
	 * 校验用户名是否合法（用户名长度在8-20之间，并且只能有字母，数字和下划线组成）
	 */
	public static void checkUserName(String userName) {
		int length = userName.length();
		if(length>=8&&length<=20) {
			boolean flag=true;
			for(int i=0;i<length;i++) {
				char ch = userName.charAt(i);//获取用户名的每一个字符
				if(!((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')||(ch>='0'&&ch<='9')||(ch=='_'))){
					flag=false;
					break;
				}
			}
			if(flag) {
				System.out.println("用户名合法！");
			}else {
				System.out.println("用户名必须有字母，数字和下划线组成！");
			}
		}else {
			System.out.println("用户名长度必须在8-20位之间！");
		}
	}
	/**
	 * 校验邮箱是否合法（邮箱必须包含@和.，并且@必须在.之前）
	 * zhangsan@163.com 合法
	 * zhangsan.163@com 不合法
	 */
	public static void checkEmail(String email) {
		int index1 = email.indexOf("@");//获取email中@的下标位置，如果不存在返回负数(-1)
		int index2 = email.indexOf(".");//获取email中.的下标位置，如果不存在返回负数(-1)
		System.out.println(index1+"****"+index2);
		if(index1>0&&index2>0&&index1<index2) {
			System.out.println("邮箱合法！");
		}else {
			System.out.println("邮箱不合法！");
		}
	}
	public static void login(String userName,String password) {
		if(userName.equals("admin")&&password.equals("12345")) {
			System.out.println("登录成功！");
		}else {
			System.out.println("用户名或密码有误！");
		}
	}
	public static void main(String[] args) {
		checkUserName("zhang!");
		checkEmail("zhangsan@163");
		login("admin", "123456");
	}
}

6.StringBuffer和StringBuilder

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

区别：

1. StringBuffer JDK1.0版本提供的类，线程安全，做线程同步检查， 效率较低。

2. StringBuilder JDK1.5版本提供的类，线程不安全，不做线程同步检查，因此效率较高。 建议采用该类。

常用方法列表：

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 类含义类似的方法：

StringBuffer

/**
 * StringBuffer和StringBuilder非常类似，均代表可变的字符序列。
 * 构造方法：
 * StringBuffer(String str):构造一个初始化为指定字符串内容的字符串缓冲区。
 * 常用方法：
 * append(String str):将字符串追加到StringBuffer的尾部。
 * length():获取长度
 * charAt(int index):返回char在指定索引在这个序列值。
 * subSequence(int start,int end):返回一个新的字符序列，该序列是该序列的子序列。
 * subString(int start):返回一个新的String，其中包括此字符序列中当前包含的字符的子序列。
 * indexOf(String str):返回指定子字符串第一次出现的字符串内的索引。
 * insert(String str,int fromIndex):在指定的下标位置插入内容。
 * delete(int start,int end):删除此序列的子字符串中的字符
 */
public class TestStringBuffer2 {
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("hello");
		sb.append(",java");
	//	System.out.println(sb);
		System.out.println(sb.toString());
		System.out.println("获取指定下标的字符:"+sb.charAt(0));
		System.out.println("截取[0,5)的内容:"+sb.substring(0,5));
		System.out.println("截取从指定位置截取到最后:"+sb.substring(5));
		System.out.println("java字符串的下标位置:"+sb.indexOf("java"));
		System.out.println("插入字符串:"+sb.insert(0, "我爱"));
		System.out.println("删除字符串:"+sb.delete(0, 2));
		System.out.println("长度:"+sb.length());
	}
}

StringBuilder

public class TestStringBuilder {
	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder("hello");
		sb.append(",java");
		System.out.println(sb);
		System.out.println("容量:"+sb.capacity());
		System.out.println(sb.toString());
		System.out.println("获取指定下标的字符:"+sb.charAt(0));
		System.out.println("截取[0,5)的内容:"+sb.substring(0,5));
		System.out.println("截取从指定位置截取到最后:"+sb.substring(5));
		System.out.println("java字符串的下标位置:"+sb.indexOf("java"));
		System.out.println("插入字符串:"+sb.insert(0, "我爱"));
		System.out.println("删除字符串:"+sb.delete(0, 2));
		System.out.println("长度:"+sb.length());
	}
}

7.不可变和可变字符序列使用陷阱

String使用的陷阱

String一经初始化后，就不会再改变其内容了。对String字符串的操作实际上是对其副本(原始拷贝)的操作，原来的字符串一点都没有改变。

String和StringBuilder在频繁字符串修改时效率测试

/**
 * String：不可变的字符序列，StringBuilder和StringBuffer可变的字符序列。
 * 结论：当需要频繁操作字符序列时，推荐使用StringBuilder/和StringBuffer效率更高
 */
public class Test {
	public static void main(String[] args) {
		//使用String进行字符串拼接
		String str8 ="";
		//本质上使用StringBuilder拼接，但是每次循环都会产生一个StringBuilder对象
		long num1 = Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
		long time1 = System.currentTimeMillis();//获取系统的当前时间
		for(int i = 0;i<5000;i++) {
			str8 =str8+i;//相当于产生10000个对象
		}
		long num2 = Runtime.getRuntime().freeMemory();
		long time2=System.currentTimeMillis();
		System.out.println("String占用内存:"+(num1-num2));
		System.out.println("String占用时间:"+(time2-time1));
		
		/**使用StringBuilder进行字符串的拼接*/
		StringBuilder sb1=new StringBuilder("");
		long num3 = Runtime.getRuntime().freeMemory();
		long time3=System.currentTimeMillis();
		for(int i=0;i<5000;i++) {
			sb1.append(i);
		}
		long num4 = Runtime.getRuntime().freeMemory();
		long time4=System.currentTimeMillis();
		System.out.println("String占用内存:"+(num3-num4));
		System.out.println("String占用时间:"+(time4-time3));
	}
}

8.时间处理相关类

在计算机世界，我们把1970 年 1 月 1 日 00:00:00定为基准时间，每个度量单位是毫秒(1秒的千分之一)。

日期时间相关类

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

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

常见的构造方法：

Date():获取当前日期对象

Date(long date):创建指定日期的对象，其中的参数代表距1970年1月1日00:00:00的总毫秒数。

Date(int year,int month,int date):创建指定日期的对象，已过时

常用的方法：

1.equals(Object obj):比较两个日期是否相等。

2.before(Date when):测试此日期是否在指定日期之前。

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

4.getXxx():获取日期的自定部分，其中Xxx代表日期的部分，如getYear();获取年份，getMonth():获取月份...

5.String toString() 把此 Date 对象转换为以下形式的 String：

Date类的使用

public class TestDate {
	public static void main(String[] args) {
		Date date = new Date();
		System.out.println(date.toString());
		System.out.println(date.toLocaleString());//过时的方法，将日期转换为本地语言环境的日期字符串形式
		Date date2 = new Date(118,1,1);//year:在1900年的基础上叠加--->2018-1-1
		System.out.println(date2.toLocaleString());
		Date date3 = new Date(1000);
		System.out.println(date3.toLocaleString());
		System.out.println("比较日期是否相等:"+date.equals(date2));
		System.out.println("此日期是否在指定日期之前:"+date.before(date2));
		System.out.println("此日期是否在指定日期之后:"+date.after(date2));
		
		int year = date.getYear();//获取年份，当前日期局1900年的年份差
		int month = date.getMonth();//获取月份，月份的范围是（0-11）
		int da = date.getDate();//获取日期
		int hour = date.getHours();//获取小时
		int mins = date.getMinutes();//获取分钟
		int seds = date.getSeconds();//获取秒
		System.out.println(year+"-"+month+"-"+da+" "+hour+":"+mins+":"+seds);
	}
}

查看API文档可以看到其实Date类中的很多方法都已经过时了。JDK1.1之前的Date包含了：日期操作、字符串转化成时间对象等操作。JDK1.1之后，日期操作一般使用Calendar类，而字符串的转化使用DateFormat类。

10.DateFormat类和SimpleDateFormat类

DateFormat类的作用

把时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。

DateFormat是一个抽象类，一般使用它的的子类SimpleDateFormat类来实现。

java.text.SimpleDateFormat类:继承了DateFormat，可以将日期和字符串相互转换。

构造方法：

SimpleDateFormat(String Pattern)：使用给定模式SimpleDateFormat并使用默认的FORMAT语言环境的默认日期格式符号。

yyyy:年份 MM:月份 dd日期 hh(12进制)小时 mm分钟 ss秒 sss毫秒

常用方法：

format(Date date)：将日期格式化成日期/时间字符串。

parse(String str)：将字符串转化为日期。

DateFormat类和SimpleDateFormat类的使用

public class TestDateFormat {
	public static void main(String[] args) {
		Date date =new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日hh时mm分ss秒sss毫秒");
		String str = sdf.format(date);
		System.out.println(str);
		//将字符串转换为日期
		String str2 ="2019-1-1";
		SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
		try {
			Date date2 = sdf2.parse(str2);
			System.out.println(date2);
		}catch(ParseException e) {
			e.printStackTrace();
		}
	}
}

格式化字符的具体含义

11. Calendar日历类

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

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

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

java.util.GregorianCalendar：继承了Calendar

构造方法：

GregorianCalendar();

GregorianCalendar(int year,int month,int dayOfMonth)

常用的方法：

get(int field):返回给定日历字段的值。

set(int field,int value):将给定的日历字段设置为给定的值。

add(int field,int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段。

getActualMaximum(int field):给定此Calendar的时间值，返回指定日历字段可能具有的Calendar。

public class TestCalendar {
	public static void main(String[] args) {
		Calendar calendar = new GregorianCalendar();
	//	Calendar calendar = new GregorianCalendar(2020,1,5);
//		Calendar calendar = new GregorianCalendar(2020,1,5,10,11,12);
		System.out.println(calendar);
		int year = calendar.get(Calendar.YEAR);//获取年份
		int month = calendar.get(Calendar.MONTH);//获取月份（0-11）
		int date = calendar.get(Calendar.DATE);//获取日期
		int hour = calendar.get(Calendar.HOUR);//获取小时
		int min = calendar.get(Calendar.MINUTE);//获取分钟
		int sec = calendar.get(Calendar.SECOND);//获取秒
		System.out.println(year+"-"+month+"-"+date+" "+hour+":"+min+":"+sec);
		int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);//获取星期几，（1-7）星期日是第一天（1）
		int weekOfMonth = calendar.get(Calendar.WEEK_OF_MONTH);//一个月的第几周
		System.out.println("星期:"+dayOfWeek+",第"+weekOfMonth+"周");
		System.out.println("******************");
		Calendar calendar2 = new GregorianCalendar();//默认是当前时间
		calendar2.set(Calendar.YEAR,2050);//设置年份
		calendar2.set(Calendar.MONTH, 3);//设置月份
		calendar2.add(Calendar.YEAR, 10);//增加10年
		calendar2.add(Calendar.MONTH, -1);//月份减少1
		System.out.println(calendar2.get(Calendar.YEAR)+"----"+calendar2.get(calendar2.MONTH));
		int day = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);//获取指定月份最大的天数
		System.out.println("当月最大天数"+day);
	}
}

利用GregorianCalendar类，打印当前月份的日历

/**
 * 根据用户输入的年月日，动态展示该月的"万年历"
 */
public class TestCalendar2 {
	public static void main(String[] args) throws ParseException {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个日期:yyyy-MM-dd");
		String str = input.next();
		//创建DateFormat对象，用于将String转Date
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		Date d =df.parse(str);
		//Date对象所表示的时间设置到Calendar中
		Calendar cal = new GregorianCalendar();
		cal.setTime(d);
		//获取输入日期中的date部分
		int nowDate = cal.get((Calendar.DAY_OF_MONTH));
		
		//将日期设置成1号，设置成2030-2-1
		cal.set(Calendar.DAY_OF_MONTH,1);
		//获取1号是星期几？
		int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
		System.out.println("日t一t二t三t四t五t六");
		for(int i=1;i<dayOfWeek;i++) {
			System.out.print("t");
		}
		//获取输入的月份的最后一天
		int maxDay=cal.getActualMaximum(Calendar.DAY_OF_MONTH);
//	    System.out.println(maxDay);
		for(int i=1;i<=maxDay;i++) {
			System.out.print(i);
			if(i==nowDate) {
				System.out.print("*");
			}
			System.out.print("t");
			if(cal.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY) {
				System.out.println();
			}
			cal.add(Calendar.DAY_OF_MONTH, 1);
		}
	}
}

12.Math类

java.lang.Math提供了一系列静态方法用于科学计算;其方法的参数和返回值类型一般为double型。如果需要更加强大的数学运算能力，计算高等数学中的相关内容，可以使用apache commons下面的Math类库。

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) 角度->弧度

Math类的常用方法

/**
 * Math类
 */
public class TestMath {
	public static void main(String[] args) {
		System.out.println("绝对值:"+Math.abs(-3)+"t"+Math.abs(25));
		System.out.println("向上取整再转double:"+Math.ceil(12.00001)+"t"+Math.ceil(-9.99999));
		System.out.println("向下取整再转double:"+Math.floor(23.999)+"t"+Math.floor(-9.99));
		System.out.println("最值"+Math.max(46, 15)+"t"+Math.min(20, 80));
		System.out.println("6的2次方:"+Math.pow(6, 2)+"t"+"6的3次方"+Math.pow(6, 3));
		System.out.println("随机数[0,1):"+Math.random());
		int ran = (int)(Math.random()*9000)+1000;
		System.out.println("1000-9999的随机数:"+ran);
		System.out.println("四舍五入:"+Math.round(12.621)+"t"+Math.round(33.045));
		System.out.println("开方:"+Math.sqrt(9));
		
	}
}

13.File类的基本用法

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

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

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

文件的创建

import java.io.File;
public class TestFile1 {
    public static void main(String[] args) throws Exception {
        System.out.println(System.getProperty("user.dir"));
        File f = new File("a.txt"); //相对路径：默认放到user.dir目录下面
        f.createNewFile();//创建文件
        File f2 = new File("d:/b.txt");//绝对路径
        f2.createNewFile();
    }
}

在eclipse项目开发中，user.dir就是本项目的目录。因此，执行完毕后，在本项目和D盘下都生成了新的文件(如果是eclipse下，一定按F5刷新目录结构才能看到新文件)。

通过File对象可以访问文件的属性：

测试File类访问属性的基本用法

import java.io.File;
import java.io.IOException;

public class TestFile {
	public static void main(String[] args) throws IOException {
		File f1=new File("D:a.txt");//绝对路径
		File f2=new File("D:/a.txt");
		File f3=new File("a.txt");//相对路径
		File f4=new File("D:Test");//目录
		File f5=new File(f4,"a.txt");
		File f6=new File("D:"+File.separator+"a.txt");
		
		/**File操作文件的想关方法*/
	//	System.out.println(f1.createNewFile());
		System.out.println(f1.delete());//直接从磁盘上删除
		System.out.println(f1.exists());//不存在false,
		System.out.println("绝对路径:"+f3.getAbsolutePath());
		System.out.println("相对路径:"+f3.getPath());
		System.out.println("获取文件名:"+f3.getName());
		System.out.println(f3.toString());//相对路径
		System.out.println("是否是文件:"+f3.isFile());
		System.out.println("是否是文件:"+f5.isFile());
		System.out.println("文件中内容的字节数:"+f3.length());
		
	}
}

通过File对象创建空文件或目录(在该对象所指的文件或目录不存在的情况下)

java.io.File类：表示一个文件或文件夹对象。

构造方法：

File(string pathname)通过将给定的路径名字转换为抽象路径名来创建新的File实例。

File(String parent,String child)从父路径名字符串和子路径名字符串创建新的File实例。

File(File parent,String child)从父抽象路径和子路径名字符串创建新的File实例。

使用mkdir和mkdirs创建目录

import java.io.File;
/**
 * 创建文件、删除空文件夹、遍历D盘文件目录
 * 获取绝对路径和相对路径
 */
public class TestDirectory {
	public static void main(String[] args) {
		//创建File类的对象
		File f = new File("D:"+File.separator+"test");
		f.mkdir();//用于创建目录，单层目录
		System.out.println("目录是否存在"+f.exists());
		System.out.println("是目录还是文件:"+f.isDirectory());
		System.out.println("是目录还是文件:"+f.isFile());
		
		File f2 = new File("D:aabbcc");
		f2.mkdirs();//用于创建目录，多层目录
		f2.delete();
		File parent=f2.getParentFile();//获取cc目录的父级目录
		System.out.println(parent);
		parent.delete();//delete删除目录时，只允许删除空目录
		f2.delete();//删除cc
		parent.delete();//删除bb
		
		
		File f3 =new File("D:");
		String[] strFile=f3.list();
		System.out.println(strFile.length);//数组中的元素的个数
		for(String s:strFile) {
			System.out.println(s);
		}
		System.out.println("----------------------");
		File[] filst = f3.listFiles();
		for(File file:filst) {
			System.out.println(file);
		}
	}
}

public class TestDirectory3 {
	public static void main(String[] args) throws IOException {
		File path = new File("D:百度网盘");//  转义字符
	//	File path = new File("D:/百度网盘");//表示一个目录
	//	File file = new File("D:百度网盘3第三章");//表示一个文件
	//	File file = new File("D:/百度网盘","3第三章");//表示D:/百度网盘/3第三章文件
		File file = new File(path,"3第三章");//表示D:/百度网盘/3第三章文件
		System.out.println("文件或文件夹是否存在:"+path.exists());
		if(!path.exists()) {//如果目录不存在，则创建该目录
			path.mkdir();//创建目录，只能创建一级目录
			path.mkdirs();//创建目录，可以创建多级目录
		}
		System.out.println("是否是目录:"+path.isDirectory());
		System.out.println("是否是文件:"+path.isFile());
		File file2 = new File("D:/百度网盘/aa.txt");
		if(!file2.exists()) {
			file2.createNewFile();//创建文件
		}
		file2.delete();//删除文件或目录
		//获取指定目录下的所有文件或文件夹
		File[] fs = path.listFiles();
		for(File file3:fs) {//遍历
			String fileName = file3.getName();//获取文件名称
			long fileSize = file3.length();//获取文件的大小，单位字节
			String filePath = file3.getAbsolutePath();//获取文件的路径
			System.out.println(fileName+"---"+fileSize+"---"+filePath);
		}
	}
}

删除指定的目录及子文件

import java.io.File;
/**
 * 删除指定的目录及其子文件
 * delete()只能删除文件或目录(空目录)
 */
public class TestDelete {
	public static void main(String[] args) {
		File path = new File("D:/新建文件夹 (2)");
		deleteFile(path);	
	}
	/**
	 * 使用递归删除指定文件夹
	 * @param path
	 */
	public static void deleteFile(File path) {
		File[] files = path.listFiles();//获取指定目录的子文件或子目录
		for (File file : files) {
			if(file.isDirectory()) {//如果当前File对象代表目录，递归删除
				deleteFile(file);
			}else{//如果当前File对象代表文件，直接删除
				file.delete();
			}
		}
		//删除当前文件夹
		path.delete();
	}
}

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

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。

递归结构包括两个部分：

1.定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。

2.递归体。解答：什么时候需要调用自身方法。

使用递归算法，以树状结构展示目录树

/**
 * 使用递归打印输出指定目录下的目录结构
 * D:/mycode
 * -aa
 * --bb
 * ---bb.txt
 * -aa.txt
 * -cc
 * --cc.txt
 * -dd
 * --dd.txt 
 */
public class TestFile3 {
	public static void main(String[] args) {
		File f = new File("D:/mycode");
		printFile(f,0);
	}
	/**
	 * 打印文件信息
	 * @param file   文件名称
	 * @param level  层次数（实际就是：第几次递归调用）
	 */
    static void printFile(File file,int level) {
    	//输出层数
		for(int i=0;i<level;i++) {
			System.out.print("-");
		}
		//输出文件名
		System.out.println(file.getName());
		//如果file是目录，则获取子文件列表，并对每个子文件进行相同的操作
		if(file.isDirectory()) {
			File[] files =file.listFiles();
			for(File temp:files) {
				//递归调用该方法，注意+1
				printFile(temp,level+1);
			}
		}
	}
}

15. 枚举

JDK1.5引入了枚举类型。枚举类型的定义包括枚举声明和枚举体。格式如下：

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

创建枚举类型

enum Season {
    SPRING, SUMMER, AUTUMN, WINDER 
}

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

枚举的使用

public class TestEnum {
	public static void main(String[] args) {
		System.out.println("遍历枚举");
		for(Right r:Right.values()) {
			System.out.println(r);
		}
		int index =(int)(Math.random()*3);//随机生成一个[0,2)之间的数，作为访问枚举的下标
		Right[] rights = Right.values();
		Right right = rights[index];//随机获取红绿灯
		System.out.println("当前是"+right+"灯");
		switch(right) {
		   case RED:
			   System.out.println("红灯停..");
			   break;
		   case GREEN:
			   System.out.println("绿灯行...");
			   break;
		   case YELLOW:
			   System.out.println("黄灯等一等...");
			   break;
		}
	}
}
enum Right{
	RED,GREEN,YELLOW
}

注意：枚举不是类，没有构造方法

建议：

1. 当你需要定义一组常量时，可以使用枚举类型。

2. 尽量不要使用枚举的高级特性，事实上高级特性都可以使用普通类来实现，没有必要引入枚举，增加程序的复杂性!