Java常用类 -- API的使用(Integer,System,String,Runtime,Date,Random)

首先需要用到API的jdk1.6和jdk1.8版本，最好2个版本都准备一下，1.6的翻译是最好的，但是1.8的版本功能是齐全的。

一、常用类Integer

1.Integer是int的包装类，就是int的引用数据类型

包装类：
int-------->Integer
byte----->Byte
char----->Character
long----->Long
short---->Short
double–>Double
float----->Float

1. 把int看成一个类Integer，具体的值，就是一个对象
   比如：Integer i=new Integer(1);

2. Integer中的常量字段
   public static final int 修饰。比如有PI MAX_VALUE MIN_VALUE等

3. 方法
   常用的：

   • byteValue() 返回byte类型的值
   • intValue() 返回int类型的值
   • static int parseInt(String s) 返回int类型的值，字符串参数作为有符号的十进制整数进行解析。
   • static String toString(int i) 返回一个表示指定整数的 String 对象。

   示例：

public class IntegerTest2 {
	public static void main(String[] args) {
		Integer i1 = new Integer(10);
		Integer i2 = new Integer("10");
		System.out.println(i1.intValue());//调用返回int类型的值，并打印值
		System.out.println(Integer.parseInt("111"));//调用parseInt的方法，打印返回int类型值
		System.out.println(Integer.toString(12));//用int类型的数，打印返回String类型的值
	}
}

4. 自动拆箱和装箱
   Integer 的自动装箱和拆箱：只支持本基本数据类型，和对应的包装类相互的自动拆箱和装箱
   • 自动拆箱和装箱的特点在JDK1.5以后才有。
   • new一个的时候赋值，就是手动装箱
   • Integer i = 1;自动装箱
   • 自动拆箱：
   • int i3=new Integer(2);//手动拆箱
   • int i1=i;自动拆箱

	public static void main(String[] args) {
		Integer integer = new Integer(10);//手动装箱
		Integer i1=12;//自动装箱
		Integer i2=22;//自动装箱
		System.out.println(i2.byteValue());
		int i3=new Integer(2);//手动拆箱
		int i4=i1;//自动拆箱  把i1的值重新转换成int的类型
		System.out.println(i3);
		System.out.println(i4);
	}

5. 享元模式
   堆里面已经创建好了一部分值[-128,127] 是常用的值 使用的时候直接饮用，地址值是一样的
   char的范围是[0,127]
   示例：

public static void main(String[] args) {
	Integer i1=127;
	Integer i2=127;
	System.out.println(i1 == i2);//比较的是地址值，在享元模式内，是相等的 ture
	System.out.println(i1.equals(i2));//比较的是对象，一样的  ture
	Integer i3=222;
	Integer i4=222;
	System.out.println(i3 == i4);//比较的是地址值，超出享元模式，下相当于是new出来的新的 false
	System.out.println(i3.equals(i4));//比较的是对象，一样的  ture
}

6. Java 中基本类型和字符串之间的转换
   1. 包装类的 toString() 方法
   2. String类型的valueof()方法
   3. 最简单的String str=i+"";
      示例：

	String s1=Integer.toString(1);
	String s2=String.valueof(1)；
	String s3=1+"";

二、常用类Runtime

1.概念：每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。

• 可以通过 getRuntime 方法获取当前运行时。
• 应用程序不能创建自己的 Runtime 类实例。

涵义解释：以Runtime为一个类，而每个Java引用程序就是他的具体对象。获得系统环境信息，JVM环境信息 【Java代码都在JVM中】

2.方法：

• static Runtime getRuntime() 返回与当前 Java 应用程序相关的运行时对象。
• int availableProcessors() 向 Java 虚拟机返回可用处理器的数目。
• Process exec(String command) 在单独的进程中执行指定的字符串命令。
• void exit(int status) 通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机。
• long freeMemory() 返回 Java 虚拟机JVM中的空闲内存量。
• void gc() 运行垃圾回收器。
  示例：

	public static void main(String[] args) throws IOException {
		//static Runtime getRuntime()
		Runtime runtime = Runtime.getRuntime();
		System.out.println(runtime);
		
		//int availableProcessors()
		System.out.println(runtime.availableProcessors());//8       指代8线程处理器
		
		//Process exec(String command)  这个是操作电脑系统上面自带的工具
		//调出计算机
		//runtime.exec("calc");// 调出计算机    这里会抛出异常，处理异常  主方法上面添加：throws IOException  
		
		//void exit(int status) 
		//runtime.exit(0);
		
		//long freeMemory()   byte 0000 0000 2进制
		System.out.println(runtime.freeMemory());//124864256
		
		//void gc()
		runtime.gc();
	}

三、常用类String

1.String的常量池

和Integer的享元模式很像
首先赋值一个字符串用变量接收，放在栈中，对应的字符串放在堆中常量池，然后如果重新用变量赋值这个字符串，就会先去常量池找
比如：
String s1=“aaa”; 先放入常量池
String s2=“aaa”; 先去常量池找，如果有，直接就引用了，地址值相同

2.运算拼接

字符串是常量，创建之后不能修改。 【public final char value[]】
注意null和"“的区别，”"表示的还是字符串。

运算拼接：
必须是常量运算拼接，如果有变量，则相当于是new出来的。类似byte必须用常量相加才不能报错

class Test{
	public static void main(String[] args) {
		String s1="this";
		String s2="this";
		System.out.println(s1==s2);//true  直接就引用，地址值相同
		String s3 = new String("this");
		System.out.println(s3==s2);//false   s3是new出来的地址值
		
		//拼接
		byte a=1;
		byte b=2;
		byte c=1+2;
		//byte d=b+c;  这里就会报错了
		String s4="this is";
		String s5="this"+" is";
		String s6=s1+" is";//这里有变量来拼接，就不会检查常量池  相当于就是new出来的新空间了
		System.out.println("=============");
		System.out.println(s4==s5);//true
		System.out.println(s6==s5);//false
	}
}

3.方法

package cn.itsource.String;

public class StringDome2 {
	public static void main(String[] args) {
		/*String concat(String str) 
        将指定字符串连接到此字符串的结尾。 */
		String s1 = new String("abcdef");
		System.out.println(s1.concat("ABC"));
		
		/* boolean endsWith(String suffix) 
        测试此字符串是否以指定的后缀结束。 */
		System.out.println(s1.endsWith("f"));
		
		/*boolean isEmpty() 
        当且仅当 length() 为 0 时返回 true。 */
		System.out.println(s1.isEmpty());
		
		/*int length() 
        返回此字符串的长度。 */
		System.out.println(s1.length());
		
		/*boolean startsWith(String prefix) 
        测试此字符串是否以指定的前缀开始。 */
		System.out.println(s1.startsWith("a"));
		
		/*String substring(int beginIndex) 
        返回一个新的字符串，它是此字符串的一个子字符串。 */
		System.out.println(s1.substring(1));
		
		/*String substring(int beginIndex, int endIndex) 
        返回一个新字符串，它是此字符串的一个子字符串。*/
		System.out.println(s1.substring(1, 3));
		
		/*char[] toCharArray() 
        将此字符串转换为一个新的字符数组。 */
		System.out.println(s1.toCharArray());
		
		/*String trim() 
        返回字符串的副本，忽略前导空白和尾部空白。 */
	    String s2 = new String(" abc bcd def ");
		System.out.println(s2.trim());
		}
}

4.String/StringBuffer/StringBuilder

1. 区别1：
   效率问题：String<StringBuffer<StringBuilder
   示例：

public class StringBuilderDome{
	public static void main(String[] args) {
		//String
		long start1 = System.currentTimeMillis();
		String s1 = "";
		for (int i = 0; i < 10000; i++) {
			s1+=i;
		}
		System.out.println(s1);
		long end1 = System.currentTimeMillis();
		System.out.println(end1-start1);//161
		
		//StringBuffer
		long start2 = System.currentTimeMillis();
		StringBuffer s2 = new StringBuffer();
		for (int i = 0; i < 10000; i++) {
			s2.append(i);
		}
		System.out.println(s1);
		long end2 = System.currentTimeMillis();
		System.out.println(end2-start2);//3
		
		//StringBuilder
		long start3 = System.currentTimeMillis();
		StringBuilder s3 = new StringBuilder();
		for (int i = 0; i < 10000; i++) {
			s3.append(i);
		}
		System.out.println(s3);
		long end3= System.currentTimeMillis();
		System.out.println(end3-start3);//2
	}
}

2. 区别2：
线程安全：
String：线程不安全
StringBuffer：线程安全
StringBuilder：线程不安全
3. 区别3
String是字符串常量，定义之后就不能修改
而StringBuffer和StringBuilder可以通过调用方法修改值

public class StringBuilderDome2 {

	public static void main(String[] args) {
		//链式写法
		StringBuilder s = new StringBuilder("Darling,");
		s.append("You").append(" ").append("are").append(" ").append("my").append(" ").append("honey!!!");
		System.out.println(s);
		
		/*int capacity() 
	返回当前容量。 内部装字符，都是数组.... */
		System.out.println(s.capacity());
		
		/*StringBuilder delete(int start, int end) 
        移除此序列的子字符串中的字符。 */
		System.out.println(s.delete(3, 7));
		
		/*StringBuilder insert(int offset, String str) 
        将字符串插入此字符序列中。 */
		System.out.println(s.insert(1, "e"));
	}

四、常用类System

1.有构造方法，但是不能实例化，是paivate修饰的

2.字段常量 ：

• public final static InputStream in = null;
• public final static PrintStream out = null;
• public final static PrintStream err = null;
• private static volatile SecurityManager security = null;

3.方法（**）

1. arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
   • src - 源数组。
   • srcPos - 源数组中的起始位置。
   • dest - 目标数组。
   • destPos - 目标数据中的起始位置。
   • length - 要复制的数组元素的数量。
2. currentTimeMillis() 返回以毫秒为单位的当前时间。
3. 3.static void exit(int status) 终止当前正在运行的 Java 虚拟机。JVM
4. static void gc() 运行垃圾回收器。
5. static Map getenv() 返回一个不能修改的当前系统环境的字符串映射视图。

	public static void main(String[] args) {
		//arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
		int[] arr={1,2,3,4,5,6,7};
		int[] arr1=new int[10];
		System.arraycopy(arr, 3, arr1, 6, 4);
		System.out.println(Arrays.toString(arr1));//[0, 0, 0, 0, 0, 0, 4, 5, 6, 7]
		StringBuffer s = new StringBuffer();
		
		//currentTimeMillis()
		long star = System.currentTimeMillis();//起始时间
		for (int i = 0; i < 10000; i++) {
			s.append(i);
		}
		System.out.println(s);
		long end = System.currentTimeMillis();//for循环结束时间
		System.out.println(end-star);//输出值：4
		
		/*
		//static void exit(int status)
		//根据惯例，非 0 的状态码表示异常终止。
		System.exit(0);
		
		//static void gc() 
		System.gc();//只是做出了一些努力而已       什么时候回收 还是得看垃圾回收器
		*/		
		//static Map getenv()
		System.out.println(System.getenv());
	}
}

五、常用类Random

Math中的类Random
用于取随机数
java中的区间数，一般是左闭右开原则 [ )

	public static void main(String[] args) {

		/*static double random() 
        返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。 */
		double random = Math.random();
		System.out.println(random);
		
		/*int nextInt() 
        返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。  整个int范围随机取值 */
		Random random2 = new Random();
		System.out.println(random2.nextInt());
		
		/*void setSeed(long seed) 
        使用单个 long 种子设置此随机数生成器的种子。 */
		random2.setSeed(3L);
		System.out.println(random2.nextInt());//设置种子之后，每次调用方法，的运行值都一样
		System.out.println(random2.nextInt());//设置种子之后，每次调用方法，的运行值都一样
		
		/*5  ~    9 */
		/*int nextInt(int origin, int bound) 
	返回一个指定的起点之间的伪随机 int值 从起点（含）到指定的值（不含）。  */
		ThreadLocalRandom current = ThreadLocalRandom.current();
		System.out.println(current.nextInt(1,2));
		
		/*类 UUID
		 *表示通用唯一标识符 (UUID) 的类。 UUID 表示一个 128 位的值
		 *
		 *UUID描述了，唯一标识 的这一类事物
		 *具体的一个UUID对象，就是一个具体的唯一标识
		 *static UUID randomUUID() 
		 * */
		UUID u = UUID.randomUUID();
		System.out.println(u);
	}

应用比如：设计一个方法产生验证码，给定位数int a 的a个随机验证码

public class RandonDemo1 {
	/*随机验证码   设计
	 * 1.设计一个字符串，需要哪些字符
	 * 2.用String charAt(int index)传入随机值 在索引的范围内
	 * 3.需要几个验证码  比如8个
	public static void main(String[] args) {
		code(8);
	}
	static void code(int a){//设计的一个方法根据需要的验证码位数，调用使用
		String s="qwertyuiopasdfghjklzxcvbnm0123456789";
		Random random = new Random();
		int l=s.length();
		String str="";
		for (int i = 0; i < a; i++) {
			int nextInt = random.nextInt(l);
			char c = s.charAt(nextInt);
			str+=c;
		}
		System.out.println(str);
	}
}

六、常用类Date

1.Date类

获取时间–>根据当前系统获取的

		System.out.println(new Date());//Fri Apr 19 19:12:29 CST 2019
		//Date(long date) 
		//分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”
		//即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
		System.out.println(new Date(4567890000000L));//Tue Oct 02 10:20:00 CST 2114

2.SimpleDateFormat

SimpleDateFormat就是简单的日期格式
根据每个国家的不同，可以使用一个方法让日期显示成我们需要的格式
方法：

1. SimpleDateFormat()用【默认的模式】和【默认语言】环境的日期格式符号构造 SimpleDateFormat
2. SimpleDateFormat(“y-M-d HⓂ️s E”)固定格式 注意大小写 【年，月，日，小时，分钟，秒，星期几】
3. parse(String str) 根据已知的年月日文本 转换成系统的日期格式

public class SimpleDateFormatDemo {
	public static void main(String[] args) throws ParseException {
		Date date = new Date();
		
		/*SimpleDateFormat()   对象     格式器对象....
        用【默认的模式】和【默认语言】环境的日期格式符号构造 SimpleDateFormat。*/
		SimpleDateFormat format = new SimpleDateFormat();
		System.out.println(format.format(date));//输出值：19-4-19 下午7:21   还要修改
		
		
		//SimpleDateFormat("y-M-d H:m:s E")固定格式  注意大小写 【年，月，日，小时，分钟，秒，星期几】
		format = new SimpleDateFormat("y年M月d日 H:m:s E");
		System.out.println(format.format(date));//2019年4月19日 19:23:33 星期五
		
		//根据已知的年月日文本   转换成系统的日期格式
		//parse(String str)
		format = new SimpleDateFormat("y年M月d日 H:m:s");
		String str="2019年4月19日 20:00:00";
		System.out.println(format.parse(str));//Fri Apr 19 20:00:00 CST 2019	
	}
}

3.Calendar

对时间日期，字段值设置，修改操作

import java.util.Calendar;
public class CalendarDemo {
	public static void main(String[] args) {
		/*static Calendar getInstance() 
        使用默认时区和语言环境获得一个日历。 
		 * */
		Calendar c = Calendar.getInstance();
		int i = c.get(Calendar.MONTH);
		System.out.println(i+1);//4月    欧美是0~11月 所以要加1

		//Calendar.MONTH 或者YEAR 这些 就表示初始值
		//set(Calendar.MONTH,int i)   i表示要修改的月份 或者年份  前面对象MONTH 和YEAR
		c.set(Calendar.YEAR, 1991);
		System.out.println(c.get(Calendar.YEAR));//1991
		
		//add(Calendar.MONTH,int i)  i对应前面常量的MOUTH或者YEAR
		c.add(Calendar.YEAR, 2);
		System.out.println(c.get(Calendar.YEAR));//1993
		
		//getTime() 通过日历对象，修改这些数据之后，获得新时间
		System.out.println(c.getTime());//Mon Apr 19 21:17:28 CST 1993	
	}
}