04_java常用类介绍

1、包装类

1.1 包装类的基本概念及用法

  java是面向对象的语言，但并不是“纯面向对象”的，比如我们经常用到的基本数据类型就不是对象。为了解决这个不足，java设计了8个和基本数据类型对应的包装类。

• 包装类均位于java.lang包，8中基本数据类型和包装类的对应关系如下：

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

包装类的基本作用：

public class TestPackClass {
	public static void main(String[] args) {
		//基本数据类型转为包装类对象
		Integer a = new Integer(100);
		Integer b = Integer.valueOf(100);  //官方推荐使用
		Boolean c = Boolean.valueOf(true);
		
		//把包装类转为基本数据类型
		int d1 = b.intValue();
		double d2 = b.doubleValue();
		boolean e = c.booleanValue();
		
		//把字符串转为包装类
		Integer f = new Integer("9999");
		Integer g = Integer.parseInt("99999");
		
		//把包装类转为字符串
		String h = g.toString();
		
		//常见的常量
		byte min = Byte.MIN_VALUE;  //byte的最小取值
		byte max = Byte.MAX_VALUE;  //byte的最大取值
		System.out.println("byte的取值范围是：" + "[" + min + "~" + max + "}");
	}
}

1.2 自动装箱与自动拆箱

• 自动装箱与拆箱事实上是编译器帮忙弄的，编译器在编译时依据你所编写的语法，决定是否进行装箱及拆箱操作。
• 自动装箱的实现：调用**valueOf()**方法。
• 自动拆箱的实现：调用**xxxValue()**方法。

自动装箱

Integer i = 100; 

相当于编译器自动做出如下语法编译：

Integer i = Integer.valueOf(100);

自动拆箱

Integer i = 100; 
int j = i;

相当于编译器自动做出如下语法编译：

int j = i.intValue();

1.3 包装类的缓存问题

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

• Integer类相关源码：

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
        private IntegerCache() {}
    }

实例：

public class TestPack {
	public static void main(String[] args) {
		Integer a = Integer.valueOf(-128);
		Integer b = -128;
		System.out.println(a == b);  //true,-128在[-128~127]的缓存范围内
		
		Integer c = 128;
		Integer d = 128;
		System.out.println(c == d);  //false,128不在[-128~127]的缓存范围内
	}
}

2、String类

2.1 String类的要点说明

• 为什么String是不可变序列？

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
}

源码中所定义的value[]是一个常量，不可变。

• 比较字符串要使用equals()：

public class TestString {
	public static void main(String[] args) {
		String str1 = "hello" + " java";
		String str2 = "hello java";
		System.out.println(str1 == str2);  //true,编译器能实现字符串拼接
		
		String str3 = "hello";
		String str4 = " java";
		String str5 = str3 + str4;
		System.out.println(str5 == str2);  false,编译器不能实现字符串拼接
		System.out.println(str5.equals(str2));  //true
	}
}

2.2 StringBuilder和StringBuffer

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
 {

 }

public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
 {

 }

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    char[] value;
 }

由以上源码可知：

• StringBuilder和StringBuffer都是可变序列。
• StringBuilder线程不安全，效率高（常用）。
• StringBuffer线程安全，效率低。

2.2.1 StringBuilder和StringBuffer的常用方法：

String中常用的方法在StringBuilder和StringBuffer中基本都可以使用，而且StringBuilder和StringBuffer的方法基本是通用的。

public class TestStringBuilderAndStringBuffer {
	public static void main(String[] args) {
		StringBuilder sb1 = new StringBuilder();
		StringBuffer sb2 = new StringBuffer();
		
		for (int i = 0; i < 26; i++) {
			char temp = (char) ('a'+i);
			//追加
			sb1.append(temp);
			sb2.append(temp);
		}
		System.out.println(sb1);
		System.out.println(sb2);
		
		//倒序
		sb1.reverse();
		sb2.reverse();
		System.out.println(sb1);
		System.out.println(sb2);
		
		//替换
		sb1.setCharAt(0, '赋');
		sb2.replace(0, 3, "糙");
		System.out.println(sb1);
		System.out.println(sb2);
		
		//添加
		sb1.insert(0, "JAVA").insert(10, 'T');
		System.out.println(sb1);
		
		//删除
		sb2.delete(0, 1);
		System.out.println(sb2);
	}
}

2.2.2 使用字符串拼接时的注意事项

public class TestStringAndStringBuilder {
	public static void main(String[] args) {
		/**
		 * 使用String进行字符串拼接
		 */
		long num1 = Runtime.getRuntime().freeMemory();  //系统剩余内存
		long time1 = System.currentTimeMillis();
		String str = "";
		for (int i = 0; i < 5000; i++) {
			str = str + i;  //相当于产生了10000个对象
		}
		long num2 = Runtime.getRuntime().freeMemory();
		long time2 = System.currentTimeMillis();
		System.out.println("String占用内存：" + (num1- num2));  
		System.out.println("String占用时间：" + (time2 - time1));
		
		/**
		 * 使用StringBuilder进行字符串拼接
		 */
		long num3 = Runtime.getRuntime().freeMemory();  //系统剩余内存
		long time3 = System.currentTimeMillis();
		StringBuilder sb1 = new StringBuilder("");
		for (int i = 0; i < 5000; i++) {
			sb1.append(i);
		}
		long num4 = Runtime.getRuntime().freeMemory();
		long time4 = System.currentTimeMillis();
		System.out.println("StringBuilder占用内存：" + (num3- num4));  
		System.out.println("StringBuilder占用时间：" + (time4 - time3));
	}
}

• 由以上结果可知：在进行大量字符串拼接时，使用String会占用大量的内存且浪费时间，不推荐使用。这种情况下，一般使用StringBuilder。

3、时间相关类

在计算机中，把1970年1月1日00:00:00定为基准时间，时间以毫秒为单位。

3.1 Date类

相关源码：

public Date() {
        this(System.currentTimeMillis());
 }
 
 public Date(long date) {
        fastTime = date;
    }

public class TestDate {
	public static void main(String[] args) {
		//获取当前时刻
		Date d1 = new Date();
		System.out.println(d1);
		
		//获取指定时刻
		Date d2 = new Date(7000);
		System.out.println(d2);
		
		//获取某个时刻对应的毫秒数
		System.out.println(d1.getTime());
	}
}

3.2 DateFormat和SimpleDateFormat类

• DateFormat类的作用：实现时间对象和字符串之间的相互转化。
• DateFormat是一个抽象类，一般使用它的子类SimpleDateFormat来实现。

格式化字符的含义：

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());
		System.out.println(str);
		
		//把指定格式的字符串转为时间对象
		DateFormat df1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		Date d1 = df1.parse("1996-07-07 10:25:46");
		System.out.println(d1);
		
		//获取某个时刻是当年的第几天
		DateFormat df2 = new SimpleDateFormat("D");
		String str2 = df2.format(new Date());
		System.out.println(str2);
		
		//获取某个时刻是当年的第几周
		DateFormat df3 = new SimpleDateFormat("w");
		String str3 = df3.format(new Date());
		System.out.println(str3);
	}
}

3.3 Canlendar类和Gregorian类

• Calendar类提供了关于日期计算的相关功能（日历）。
• Calendar是一个抽象类，它的实现类是GregorianCalendar类。
• 月份的表示：1月 ~ 12月 ： 0 ~ 11 。
• 星期的表示：周日 ~ 周六 ： 1 ~ 7 。

public class TestCalendar {
	public static void main(String[] args) {
		//获取日期的相关元素
		Calendar c1 = new GregorianCalendar(1996, 1, 2, 10, 11, 12);
		int year = c1.get(Calendar.YEAR);
		int month = c1.get(Calendar.MONDAY);
		int day = c1.get(Calendar.DAY_OF_MONTH);
		System.out.println(year + "年" + month + "月" + day + "日");
		
		//设置日期相关元素
		Calendar c2 = new GregorianCalendar(2008,8,8); 
		c2.set(Calendar.YEAR, 2018);
		System.out.println(c2);
		
		//日期的计算
		Calendar c3 = new GregorianCalendar();  //默认为当前时间
		c3.add(Calendar.YEAR, -100);  //100年前的日期
		System.out.println(c3);
		
		//日期和时间对象的转化
		Date d = c3.getTime();  //日期转时间对象
		System.out.println(d);
		Calendar c4 = new GregorianCalendar();  //时间对象转日期
		c4.setTime(new Date());
		//使用自己的封装类打印
		printCalendar(c4);
	}
	
	//封装一个日期显示类
	public static void printCalendar(Calendar c) {
		int year = c.get(Calendar.YEAR);
		int month = c.get(Calendar.MONDAY)+1;
		int day = c.get(Calendar.DAY_OF_MONTH);
		int hour = c.get(Calendar.HOUR);
		int minute = c.get(Calendar.MINUTE);
		int second = c.get(Calendar.SECOND);
		int weekday = c.get(Calendar.DAY_OF_WEEK)-1;
		String str = "";
		switch (weekday) {
		case 0:
			str = "日";
			break;
		case 1:
			str = "一";
			break;
		case 2:
			str = "二";
			break;
		case 3:
			str = "三";
			break;
		case 4:
			str = "四";
			break;
		case 5:
			str = "五";
			break;
		case 6:
			str = "六";
			break;
		default:
			break;
		}
		System.out.println("java.util.GregorianCalendar[year=" + year + ",month=" + month + ",day=" + day
				+ ",hour" + hour + ",minute=" + minute + ",second" + second + "\t" +"星期" + str);
	}
}

4、Math类和Random类

• Math类主要用于数学计算。
• Random类主要用于生成随机数。

4.1 Math类常用方法

public class TestMath {
	public static void main(String[] args) {
		//取整
		System.out.println(Math.ceil(3.3));  //向上取整，4.0
		System.out.println(Math.floor(3.7)); //向下取整,3.0
		System.out.println(Math.round(3.2)); //四舍五入,3
		System.out.println(Math.round(3.7)); //4
		
		//常量
		System.out.println(Math.PI);  //3.141592653589793
		System.out.println(Math.E);   //2.718281828459045
		
		//随机数
		System.out.println(Math.random()); //[0,1)
		
		//其他运算
		System.out.println(Math.abs(-45));  //绝对值，45
		System.out.println(Math.sqrt(49));  //开方，7.0
		System.out.println(Math.pow(2, 5)); //2的5次幂，32.0
	}
}

4.2 Random类常用方法

public class TestRandom {
	public static void main(String[] args) {
		Random random = new Random();
		//随机生成true和false
		System.out.println(random.nextBoolean());
		
		//随机生成[0,10)之间的整数
		System.out.println(random.nextInt(10));
		
		//随机生成[10,20)之间的整数
		System.out.println(10 + random.nextInt(10));
		System.out.println(10 + (int)(random.nextDouble()*10));
	}
}

5、File类

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

public class TestFile {
	public static void main(String[] args) throws IOException {
		System.out.println(System.getProperty("user.dir"));  //默认当前路径
		File f1 = new File("aa.txt"); //存放在user.dir下
		//创建文件
		f1.createNewFile();
		File f2 = new File("F:/project/cc.txt");
		f2.createNewFile();
		
		System.out.println("File是否存在：" + f2.exists());
		System.out.println("File是否是目录：" + f2.isDirectory());
		System.out.println("File是否是文件：" + f2.isFile());
		System.out.println("File最后修改时间：" + new Date(f2.lastModified()));
		System.out.println("File文件大小：" + f2.length());
		System.out.println("File名称：" + f2.getName());
		System.out.println("File相对路径：" + f2.getPath());
		System.out.println("File绝对路径：" + f2.getAbsolutePath());
		
		//创建目录
		File f3 = new File("F:/project/cc/aa");
		boolean flag = f3.mkdir();  //若project或cc不存在，则目录无法创建
		System.out.println(flag);
		
		File f4 = new File("F:/电影/华语/动作");
		boolean flag2 = f4.mkdirs();  //若没有则自动创建
		System.out.println(flag2);
		
		//删除文件及目录
		f1.delete();
		f4.delete();
	}
}

6、枚举

当需要定义一组常量时，可以使用枚举。格式如下：

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

public class TestMenu {
	public static void main(String[] args) {
		Season season = Season.SPRING;
		switch (season) {
		case SPRING:
			System.out.println("春天到了");
			break;
		case SUMMER:
			System.out.println("夏天到了");
			break;
		case AUTUMN:
			System.out.println("秋天到了");
			break;
		case WINTER:
			System.out.println("冬天到了");
			break;
		default:
			break;
		}
	}
}

enum Season {
	SPRING,SUMMER,AUTUMN,WINTER
}