常用类、包装类

包装类

基本数据类型的包装类:  
 * 	 Byte      
 * 	 Short
 *   Integer
 *   Long
 *   Character
 *   Float
 *   Double
 *   Boolean
    
 *   将基本数据类型,放到包装类的过程, 装箱--> 拥有了很多新增的功能
         int  --> Integer
 *    将包装类 转成 基本数据类型的过程, 拆箱  ---> 回归到基本数据类型
        Integer --> int 

String / int / Integer 之间的转换

// 1、String --> Interger
	String s = "10";
	Integer i = Integer.valueOf(s);  // 调用了Integer类中的静态方法
	
// 2、Integer --> int  
	int c = i.intValue();  // 手动拆箱   类转换 调方法
	int c = i;   //  自动拆箱

// 3、int --> Integer（手动装箱）
	Integer n = new Integer(c);  // 传构造
	Integer n = c;

// 4、Integer --> String 
	String r = n.toString();

// 5、String --> int
	int t = Integer.parseInt(r);  // 传一个String类型的r  返回int类型的t

// 6、int --> String （两种方法）
	String g = t+""; // 加字符串
	String g = String.valueOf(t);

装箱：

装箱：将基本数据类型包装为对应的包装对象
JDK1.5以后 可以自动装箱和拆箱

手动装箱

 	Integer integer2 = Integer.valueOf(7);
 // 重载方法, 要求参数字符串中只能包含数字  包含其他的就会发生NumberFormatException异常
	Integer integer4 = Integer.valueOf("123");
	 System.out.println(integer4);  

自动装箱

	Integer integer = 5;
	System.out.println(integer);

拆箱：

拆箱：将包装类对象转换成对应的基本数据类型
拆箱的方法：
  		XXXValue()

手动拆箱

	int i4 = integer2.intValue();
	System.out.println(i4);
	byte b = integer2.byteValue();
	short s = integer2.shortValue();
	long l = integer2.longValue();
	float f = integer2.floatValue();
	double d = integer2.doubleValue();

自动拆箱

	int i2 = integer;
	System.out.println(i2);

Integer

多个Integer对象 -128 ~127  之间 地址是相同

	Integer integer = Integer.valueOf(-128);
	Integer integer2 = Integer.valueOf(-128);
	System.out.println(integer==integer2); // -->  true

	Integer integer3 = new Integer(1);
	Integer integer4 = new Integer(1);
	System.out.println(integer3 == integer4);  // --> false

Character

* static boolean isLetter(char ch) 
          确定指定字符是否为字母 
* isLowerCase(char ch) 
          确定指定字符是否为小写字母。
* isUpperCase(char ch) 
          确定指定字符是否为大写字母。
* static char toLowerCase(char ch) 
          使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。       
* static char toUpperCase(char ch) 
          使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为大写。

	Character c = '2';
	char c2 = c;

	System.out.println("是否是字母"+Character.isLetter('好'));		
	System.out.println("判断是否是大写"+Character.isUpperCase('a'));
	System.out.println("判断是否是小写"+Character.isLowerCase('C'));
	System.out.println("转成大写"+Character.toUpperCase('a'));
	System.out.println("转成小写"+Character.toLowerCase('B'));	

String

String 最终类, 内容是不允许修改的, 一旦修改就是会产生新的对象
String 实质上其实是是利用字符数组帮助存储数据的
有很多方法是利用了下标的
StringIndexOutOfBoundsException 字符串下标越界 

	String str = "abc"
	String str2 = new String("abc");
// 取出字符串中下标为0的字符
	char c = str.charAt(0);
	System.out.println(c);

// 将字符串转成数组
	char[] cs = str.toCharArray();
	System.out.println(Arrays.toString(cs));
	
	byte[] bytes = str.getBytes();
	System.out.println(Arrays.toString(bytes));

// 将数组换成 字符串
	byte[] bs = new byte[]{98,99,100};
	String str3 = new String(bs);
	System.out.println(str3);
	String str4 = new String(bs, 1, 2);// offset 从下标为几开始转, length 转几个    下标+length<=数组的长度
	System.out.println(str4);
	
	char[] cs2 = new char[]{'a','b','c'};
	String string = new String(cs2, 1, 2);
	System.out.println(string);
	
	String string2 = new String();
	System.out.println(string2);// --> ""

* concat  拼接字符串  
* equals  判断两个字符串内容是否相同
* contains 判断字符串中是否包含指定的字符串
* startsWith  字符串是否以指定的字符串开头
* endsWith     字符串是否以指定的字符串结尾
* indexOf   查找参数在调用者字符串中第一次出现的下标
* lastIndexOf   查找参数在调用者字符串中最后一次出现的下标
* toUpperCase   转成大写
* toLowerCase   转成小写
* length   得到字符串的长度
* trim   去除字符串中  前面和后面的空白

	String string = "a"+"b";
	String string2 = string.concat("cdeccc");// 拼接字符串
	System.out.println(string2);
	
	// 判断方法
	// equals  判断两个字符串内容是否相同
	// contains 判断字符串中是否包含指定的字符串
	boolean b = string2.contains("adb");
	System.out.println(b);
	// startsWith  字符串是否以指定的字符串开头
	boolean b2 = string2.startsWith("abcde");
	System.out.println(b2);
	// endsWith     字符串是否以指定的字符串结尾
	boolean b3 = string2.endsWith("cde");
	System.out.println(b3);
	
	// 查找参数在调用者字符串中第一次出现的下标
	int index = string2.indexOf("c");
	System.out.println(index);
	 查找参数在调用者字符串中最后一次出现的下标
	int index2 = string2.lastIndexOf("c");
	System.out.println(index2);

	// 转成大写
	String upperCase = string2.toUpperCase();
	System.out.println(upperCase);
	// 转成小写
	String lowerCase = upperCase.toLowerCase();
	System.out.println(lowerCase);
	
	// length 得到字符串的长度
	System.out.println(lowerCase.length());
	
	// 去除字符串中前边和后面空白
	lowerCase = "  a b  c  ";
	String string3 = lowerCase.trim();
	System.out.println(string3);

* boolean matches(String regex) 
			告知此字符串是否匹配给定的正则表达式。 
* String replace(char oldChar, char newChar) 
          	返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 
* String replace(CharSequence target, CharSequence replacement) 
          	使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。 
* String replaceAll(String regex, String replacement) 
        	使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 
* String replaceFirst(String regex, String replacement) 
          	使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。 
          
* String[] split(String regex) 
          	根据给定正则表达式的匹配拆分此字符串 
          
* String substring(int beginIndex) 
          	返回一个新的字符串，它是此字符串的一个子字符串。 
* String substring(int beginIndex, int endIndex) 
          	返回一个新字符串，它是此字符串的一个子字符串。 

	String  str = "abcaaabdaabaa#def#ff#hhh";
	String string = str.replace("#", "?");//replace("#", "?"); 将所有符合条件的字符串全部替换, 不支持正则表达式
	System.out.println(string);

	// 只替换第一个符合正则表达式的部分
	String first = str.replaceFirst("[abcdef]+", "?");
	System.out.println(first);
	
	// 替换所有符合正则表达式的部分
	String all = str.replaceAll("[abcdef]+", "?");
	System.out.println(all);

	String string2 = "aaaa";
	boolean matches = string2.matches("[a]+");
	System.out.println(matches);
	
	// subString 截取
	String string3 = "abcdefg";
	String s = string3.subString(0,1);
	System.out.println(s);

StringBuffer/StringBuilder

字符串缓冲区，必须通过new来创建对象

StringBuffer

	StringBuffer  buffer = new StringBuffer();
	buffer.append("abc");
	buffer.append("def");
	buffer.append("fff");	
	System.out.println(buffer);

// 删除 左闭右开
	buffer.delete(0, 3);
	System.out.println(buffer);
	
//插入 
	buffer.insert(1, "zz");
	System.out.println(buffer);
	
//翻转
	buffer.reverse();
	System.out.println(buffer);
	
	String string = buffer.toString();
	System.out.println(string);

Stringbuilder

	StringBuilder builder  = new StringBuilder();
	builder.append("aaa");
	builder.append("aaa");
	builder.append("aaa");
	
// 删除 左闭右开
	builder.delete(0, 3);
	
// 插入
	builder.insert(0, "zzz");
	System.out.println(builder);

// 翻转
	builder.reverse();
	
// 第一次出现的下标
	builder.indexOf(str)
// 最后一次出现的下标
	builder.lastIndexOf(str)
	
// 指定下标的字符
	builder.charAt(index)
	
// 长度
	builder.length();

// 替换指定下标从哪到哪的位置
	builder.replace(0, 3, "fff");

// 截取
	builder.substring(start);

Math

求随机数公式：
		(int)(Math.random()*(最大值-最小值+1)+最小值)

Math.round
		四舍五入
Math.random
		随机数
Math.max / Math.min
		最大值最小值

// random随机数
	double d = Math.random();// [0,1); 0.99999999999
	System.out.println(d);
// 10~20
	int num = (int)(Math.random()*(20-10+1)+10);
	System.out.println(num);

long l = Math.round(4.4);
		System.out.println(l);

Random

	Random random = new Random();
// 在int的取值范围内进行随机获取
	int num = random.nextInt();
	System.out.println(num);
	
	int num2 = random.nextInt(10);// 左闭右开[0,10);
	System.out.println(num2);
	
	// 10~20
	int num3 = random.nextInt(20-10+1)+10;
	System.out.println(num3);

Date

	Date date = new Date();
	SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd  HH:mm:ss SSS WW ");
	String string = dateFormat.format(date);
	System.out.println(string);

	System.out.println("年"+date.getYear());// 从1900开始算
	System.out.println("月"+date.getMonth());// 0~11
	System.out.println("日"+date.getDate());
	System.out.println("星期:"+date.getDay());
	
	System.out.println("时:"+date.getHours());
	System.out.println("分:"+date.getMinutes());
	System.out.println("秒:"+date.getSeconds());
	
	// 从1970年1月1日凌晨 到现在的经历的毫秒数
	System.out.println(date.getTime());

Calendar

	Calendar calendar = Calendar.getInstance();
	int year = calendar.get(Calendar.YEAR);
	System.out.println(year);
	System.out.println("月"+calendar.get(Calendar.MONTH));// 月是从0开始的
	System.out.println("日"+calendar.get(Calendar.DAY_OF_MONTH));
	System.out.println("小时"+calendar.get(Calendar.HOUR_OF_DAY));
	System.out.println("分"+calendar.get(Calendar.MINUTE));
	System.out.println("秒"+calendar.get(Calendar.SECOND));
		
	System.out.println(calendar);

Date例题

2012年03月09日入职的 , 计算这个人从入职到现在惊了多少天
也可以将String 存储的时间, --> Date

	String string2 ="2012年03月09日";
	SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年M月dd日");
	try {
	// 将字符串转成Date类型
		Date date2 = simpleDateFormat.parse(string2);
		//计算这个人从入职到现在过了多少天 
		long t = date2.getTime();// 从1970年到date2时间经历的毫秒数     123
		System.out.println(t);
		
		Date date3 = new Date();// 当前时间
		long t2 = date3.getTime();// 当前时间和1970的差值      256
		System.out.println(t2);
		
		long t3 = t2-t;// t3代表的是从2021-2012时间差
		System.out.println(t3);
		// 将毫秒数转成天数:
		long day = t3/(24*60*60*1000);
		System.out.println("从入职到现在经历的天数:"+day);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

System类

所有属性和方法都是static的
常用方式：
		获取标准输入，输出和错误输出流： in/out/err
		获取当前时间值：  currentTimeMillis()  /毫秒
		获取或设置属性：  getProperties / getProperty / setProperty
		获取操作系统的环境变量 ：   genv(String name);

枚举

固定值、有限个
使用enum关键字来定义 如：
	public enum Year{SPRING,SUMMER,AUTUMN,WINTER}

所有枚举类型对应的类是  java.lang.Enum类的子类
在枚举定义中 可添加属性，构造器和方法，并可以实现任意接口