Java的常用类

一、基本数据类型包装类

​ Java是一种纯面向对象语言，但是java中有8种基本数据类型，破坏了java为纯面向对象的特征。为了承诺在java中一切皆对象，java又给每种基本数据类型分别匹配了一个类，这个类我们称之为包装类/封装类。

注意：每个基本数据类型都有一个与之匹配的包装类。

1.1 八大基本数据类型的包装类

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

注意：

1. 数值型都继承Number
2. int的包装类的写法为Integer
3. char的包装类的写法是：Character
4. 其余基本数据类型的包装类均是基本类型的首字母大写。

1.2 包装类中的常用方法

装箱：基本数据类型 --> 包装类

Integer i1 = new Integer(10); // 利用构造方法

Integer i2 = Integer.valueOf(10); //利用包装类中的静态方法

int i = 100;
Integer integer1 = Integer.valueOf(i);//利用包装类中的静态方法装箱
Integer integer2 = new Integer(100);//利用构造方法装箱
System.out.println(integer1);  //100
System.out.println(integer2);  //100

拆箱：包装类 --> 基本数据类型

Integer integer = new Integer(100);
int i = integer.intValue();//拆箱
System.out.println(i);

自jdk1.5开始，java增加了对基本数据类型的自动装箱和自动拆箱操作。

自动装箱：可以直接把一个基本数据类型赋值给包装类

int i = 100;
Integer integer = i;//自动装箱（底层实现:Integer.valueOf(i);）
System.out.println(integer);

自动拆箱：可以直接把一个包装类对象赋值给基本数据类型

Integer integer = new Integer(100);
int i = integer;//自动拆箱（底层实现：integer.intValue();）
System.out.println(i);

自动装箱和自动拆箱，简化了对包装类的操作。

应用场景：集合(类似数组的容器)，但是集合只能存引用数据类型，如果想存储基本数据类型，就可以把基本数据类型转换为对应的包装类对象

举例：

需求：把字符串数组{“1”,“2”,“3”,“4”,“5”,“6”}转换为int数组

package com.dream.package_class;

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

		String[] ss = {"1","2","3","4","5"};
		
		int[] is = new int[ss.length];
		
		for (int i = 0; i < is.length; i++) {
			//1.将String转换为Integer对象
			//2.Integer对象自动拆箱成int数据
			int num = Integer.valueOf(ss[i]);
			
			is[i] = num;
		}
		
		for (int element : is) {
			System.out.println(element);
		}
	}
}
/*
	输出结果：
		1
        2
        3
        4
        5
*/

1.3 深入包装类底层源码

面试题：

Integer integer1 = Integer.valueOf(100);
Integer integer2 = Integer.valueOf(100);
System.out.println(integer1 == integer2);//true

Integer integer3 = Integer.valueOf(200);
Integer integer4 = Integer.valueOf(200);
System.out.println(integer3 == integer4);//false

Integer底层有个缓存类，缓存类中有个数组，存储了-128~127的Integer对象 Integer.valueOf(num)底层会判断num是否在-128~127这个区间，如果在内就从缓存数组中获取数据，如果不在这个区间就new对象

自己写一个类似的底层源码

package com.dream.package_class;

public class MyInteger {
	
	private int value;

	public MyInteger(int value) {
		this.value = value;
	}
	
	public static MyInteger valueOf(int i){
		if(i >= MyIntegerCache.low && i <= MyIntegerCache.high){
			return MyIntegerCache.cache[i - MyIntegerCache.low];
		}
		return new MyInteger(i);
	}
	
	//MyInteger的缓冲类
	private static class MyIntegerCache{
		
		private static final int low = -128;
		private static final int high = 127;
		private static final MyInteger[] cache; 
		
		static{
			//初始化缓冲数组
			cache = new MyInteger[high - low + 1];
			int j = low;
			for (int i = 0; i < cache.length; i++) {
				cache[i] = new MyInteger(j++);
			}
		}
	}
	@Override
	public String toString() {
		return Integer.toString(value);
	}
}

二、字符串相关类

1. String类

1.1 什么是String

1、String是不可变类, 也就是说一旦一个String对象被创建, 包含在这个对象中的字符序列是不可改变的, 直至该对象被销毁。

2、String类是final类，不能有子类。

1.2 创建字符串对象

常量池概念：

Java运行时会维护一个常量池， 常量池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。

关于String创建对象的一些问题

package com.dream.string_class;

public class Test05 {
	
	public static void main(String[] args) {
		/**
		 * 知识点：深入String创建对象问题
		 */
		
		String str1 = "abc";
		String str2 = "abc";
        //此时是相等的 因为常量池中有"abc"这个字符串在定义str2的时候会直接从常量池里将这个字符串拿来用 地址是相同的 所以下面这个语句返回true
		System.out.println(str1 == str2);//true
		
		//两个常量字符串直接在编译时拼接
        //同样的 拼接过后是"abc"仍然是从常量池中将字符串拿来赋值
		String str3 = "ab" + "c";
		System.out.println(str3 == str1);//true
		
		//两个常量字符串直接在编译时拼接
		final String s1 = "ab";
		final String s2 = "c";
		String str4 = s1+s2;//和上面一样
		System.out.println(str4 == str1);//true
		
		//两个变量字符串拼接底层是创建StringBuilder对象
		String s3 = "ab";
		String s4 = "c";
		String str5 = s3+s4;//new StringBuilder(s3).append(s4).toString()
		System.out.println(str5 == str1);//false
	}
}

1.3 String类的常用方法

package com.dream.string_class;

public class Test01 {
	
	public static void main(String[] args) {
		
		String str = "123abc";
		
		str = str.concat("DEF123");//在此字符串末尾追加字符串，并返回新的字符串
		str = str.substring(2);//从开始下标处截取到字符串末尾，并返回新的字符串
		str = str.substring(1, 7);//从开始下标处(包含)截取到结束下标处(不包含)，并返回新的字符串
		str = str.toUpperCase();//转大写，并返回新的字符串
		str = str.toLowerCase();//转小写，并返回新的字符串
		
		str = "   123 a  bcD EF 123        ";
		
		str = str.trim();//去除首尾空格，并返回新的字符串
		str = str.replace('2', '-');//替换字符，并返回新的字符串
		str = str.replaceFirst("3", "XXX");//替换第一个出现的字符串，并返回新的字符串
		str = str.replaceAll("1", "xxx");//替换字符串，并返回新的字符串
		str = str.replaceAll(" ", "");//替换字符串，并返回新的字符串
		
		System.out.println("判断两个字符串内容是否相同：(区分大小写)" + str.equals("xxx-XXXabcDEFxxx-3"));
		System.out.println("判断两个字符串内容是否相同：(不区分大小写)" + str.equalsIgnoreCase("XXX-XXXABCdefxxx-3"));
		System.out.println("判断此字符串是否以某个字符串开头：" + str.startsWith("xxx"));
		System.out.println("判断此字符串是否以某个字符串结尾：" + str.endsWith("-3"));
		
		System.out.println("查询此字符串第一次在目标字符串中的下标：" + str.indexOf("-"));
		System.out.println("查询此字符串最后一次在目标字符串中的下标：" + str.lastIndexOf("-"));
		
		System.out.println("获取指定下标上的字符：" + str.charAt(4));
		
		//xxx-XXXabcDEFxxx-3	
		System.out.println(str);	
	}
}

package com.dream.string_class;

public class Test02 {
	
	public static void main(String[] args) {
		
		//将其他类型转换为字符串
		
		int i = 100;
		System.out.println(String.valueOf(i));
		
		boolean bool = true;
		System.out.println(String.valueOf(bool));		
	}
}

练习：完成一个邮箱格式的校验 hhy@qq.com

（1），“@”不能在第一位
（2），“.”不能在最后一位
（3），“@”和“.”中间应该有字符
（4），***@***.***

package com.dream.string_class;

public class Test03 {
	
	public static void main(String[] args) {
		
		String email = "hhy@qq.com";
		
		int index1 = email.indexOf("@");//获取下标
		int index2 = email.indexOf(".");//获取下标
		
		if(index1 == 0 || index2 == email.length()-1 || (index2-index1)<=1){
			System.out.println("邮箱格式错误");
		}	
	}
}

面试题

面试题1：下列代码创建几个String对象(考点：常量池中的值必须是唯一的)

String str1 = "abc";
String str2 = "abc";
//答案一个

面试题2：下列代码创建几个String对象(考点：常量池中的值必须是唯一的)

String str1 = new String("abc");
String str2 = new String("abc");
//答案：三个

2. StringBuffer类

1、StringBuffer代表可变的字符序列。

2、StringBuffer称为字符串缓冲区

3、它的工作原理是：预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。

4、StringBuffer是可变对象，这个是String最大的不同

5、继承关系：StringBuffer extends AbstractStringBuilder

6、默认字符串缓冲区：16个字符

package com.dream.stringbuffer_class;

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

		//StringBuffer sb = new StringBuffer();
		
		//自定义字符串缓冲区：100个字符
		//StringBuffer sb = new StringBuffer(100);
	
		//自定义字符串缓冲区："123abc".length() + 16 : 22个字符
		StringBuffer sb = new StringBuffer("123abc");
	
		sb.append("DEF123");//在末尾追加字符串
		sb.insert(6, "xxx");//在指定下标处插入字符串
		sb.setCharAt(3, 'A');//替换指定下标上的字符
		sb.replace(6, 9, "aaaa");//从开始下标处(包含)替换到结束下标处(不包含)的字符串
		
		sb.deleteCharAt(1);//删除指定下标上的字符
		sb.delete(5, 11);//从开始下标处(包含)删除到结束下标处(不包含)的字符串
		sb.reverse();//反转字符串
		//321FcbA31
		System.out.println(sb);	
	}
}

3. StringBuilder

StringBuilder和StringBuffer使用上面一模一样因为两个类都继承AbstractStringBuilder且里面的方法都是调用的父类的方法。

package com.dream.stringbuilder_class;

public class Test01 {
	
	public static void main(String[] args) {
		//默认字符串缓冲区：16个字符
		//StringBuilder sb = new StringBuilder();
		
		//自定义字符串缓冲区：100个字符
		//StringBuilder sb = new StringBuilder(100);
	
		//自定义字符串缓冲区："123abc".length() + 16 : 22个字符
		StringBuilder sb = new StringBuilder("123abc");
	
		sb.append("DEF123");//在末尾追加字符串
		sb.insert(6, "xxx");//在指定下标处插入字符串
		sb.setCharAt(3, 'A');//替换指定下标上的字符
		sb.replace(6, 9, "aaaa");//从开始下标处(包含)替换到结束下标处(不包含)的字符串
		sb.deleteCharAt(1);//删除指定下标上的字符
		sb.delete(5, 11);//从开始下标处(包含)删除到结束下标处(不包含)的字符串
		sb.reverse();//反转字符串
		
		//321FEDcbA31
		System.out.println(sb);

	}
}

StringBuffer和StringBuilder的区别

StringBuffer：线程安全的，效率低
StringBuilder：线程不安全的，效率高

三、正则表达式

含义：用来描述或匹配一系列符合某个语句规则的字符串

Patter：代表正则表达式的匹配模式

Matcher：提供了对正则表达式的分组支持，以及正则表达式的多次匹配支持

字符
x	字符 x
\\	反斜线字符
\t	制表符 ('/u0009')
\n	新行（换行）符 ('/u000A')
\r	回车符 ('/u000D')
\e	转义符 ('/u001B')
.	任意字符

字符类
[abc]	a、b 或 c（简单类）
[^abc]	任何字符，除了 a、b 或 c（否定）
[a-zA-Z]	a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]	a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]	d、e 或 f（交集）
[a-z&&[^bc]]	a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]	a 到 z，而非 m 到 p：[a-lq-z]（减去）

预定义字符类
.	任何字符（与行结束符可能匹配也可能不匹配）
\d| 数字：[0-9]`
\D| 非数字：[^0-9]`
\s| 空白字符：[ /t/n/x0B/f/r]`
\S| 非空白字符：[^/s]`
\w| 单词字符：[a-zA-Z_0-9]`
\W| 非单词字符：[^/w]`

边界匹配器
^	行的开头
$	行的结尾
\b`	单词边界
\B`	非单词边界
\A`	输入的开头
\G	上一个匹配的结尾
\Z`	输入的结尾，仅用于最后的结束符（如果有的话）
\z`	输入的结尾

Greedy 数量词
X?	X，一次或一次也没有
X*	X，零次或多次
X+	X，一次或多次
X{n}	X，恰好 n 次
X{n,}	X，至少 n 次
X{n,m}	X，至少 n 次，但是不超过 m 次

案例：把一个字符串中带电话号码替换成130***1111

package com.dream.regex_class;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

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

		String str = "小红15922254658 小绿13366482269";
		
		//正则表达式的字符串
		String regex = "(\\d{3})(\\d{4})(\\d{4})";
		
		String replaceAll = str.replaceAll(regex, "$1****$3");
		
		//底层原理：
//		Pattern pattern = Pattern.compile(regex);//获取正则表达式的对象
//		Matcher matcher = pattern.matcher(str);//匹配结果
//		String replaceAll = matcher.replaceAll("$1****$3");//替换	
		System.out.println(replaceAll);
	}
}
/*
	输出结果：
		小红159****4658 小绿133****2269
*/

案例：校验QQ邮箱

package com.dream.regex_class;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

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

		String str = "456123789@qq.com";
		
		//正则表达式的字符串
		String regex = "\\d{5,10}@qq.com";
		
		boolean matches = str.matches(regex);
		//底层原理：
//		Pattern pattern = Pattern.compile(regex);//获取正则表达式对象
//		Matcher matcher = pattern.matcher(str);//获取匹配结果
//		boolean matches = matcher.matches();//判断是否完全匹配
		System.out.println(matches);
	}
}

案例：分隔路径

package com.dream.regex_class;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test03 {
	
	public static void main(String[] args) {
		
		String str = "C:\\资源\\日韩\\天天学习.avi";
		
		//正则表达式的字符串
		String regex = "\\\\";
		
		String[] split = str.split(regex);
		//底层原理
//		Pattern pattern = Pattern.compile(regex);//获取正则表达式的对象
//		String[] split = pattern.split(str);//分隔
		
		for (String string : split) {
			System.out.println(string);
		}	
	}
}
/*
    输出结果
        C:
        资源
        日韩
        天天学习.avi
*/

案例：找到代码中的图片路径

package com.dream.regex_class;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

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

		String str = "<img src='hhy/aaa.jpg'/><div><div/> <input type='image' src='submit.gif' /><img src='bbb.jpg'/>";
		
		//正则表达式的字符串
		String regex = "<img\\b[^>]*\\bsrc\\b\\s*=\\s*('|\")?([^'\"\n\r\f>]+(\\.jpg)\\b)[^>]*>";
		
		//获取正则表达式对象
		Pattern pattern = Pattern.compile(regex);
		//获取匹配结果的对象
		Matcher matcher = pattern.matcher(str);
		
//		System.out.println("在字符串中是否整个匹配：" + matcher.matches());  false
//		System.out.println("在字符串中是否开头就匹配：" + matcher.lookingAt()); true
//		System.out.println("在字符串中是否有包含匹配：" + matcher.find()); true
		
		//遍历查找
		while(matcher.find()){
			String group = matcher.group(2);//获取匹配结果
			System.out.println(group);
		}
	}
}
/*
	输出结果：
		hhy/aaa.jpg
		bbb.jpg
*/

总结：
Pattern与Matcher一起合作
Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持.
单独用Pattern只能使用Pattern.matches(String regex,CharSequence input)一种最基础最简单的匹配。
1.正则表达式在工作中实际应用在验证邮箱、验证手机号码、替换字符串
2.正则表达式几乎不用我们自己写，百度即可

四、时间类

1. Date类

java.util.Date类表示特定的瞬间，精确到毫秒。

package com.dream.datetime_class;

import java.util.Date;

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

		Date date = new Date();
		//星期 月 日期 时:分:秒  时区 年份
		//Thu Aug 05 11:23:00 CST 2021
		System.out.println(date); //输出当前的时间
		
		//自1970.1.1 0:0:0 往后推1000毫秒的时间
        //Date date = new Date(1000);
        //System.out.println(date);  输出结果为：Thu Jan 01 08:00:01 CST 1970
	}
}

2. SimpleDateFormat类

将显示的日期信息格式化

package com.dream.datetime_class;

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

public class Test02 {
	
	public static void main(String[] args) throws ParseException {

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		
		//将Date 转 字符串
		String format = sdf.format(new Date());
		System.out.println(format);  // 2021年08月05日 14:36:12
		
		///将字符串 转 Date
		Date date = sdf.parse(format);
		System.out.println(date); //Thu Aug 05 14:36:12 CST 2021
	}
}

3. Calendar类

package com.dream.datetime_class;

import java.util.Calendar;

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

		//获取日历类的对象
		Calendar c = Calendar.getInstance();
		
		//获取单个的日历信息
		int year = c.get(Calendar.YEAR);
		int month = c.get(Calendar.MONTH)+1;//月份0~11
		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);
		
		System.out.println(year);
		System.out.println(month);
		System.out.println(day);
		System.out.println(hour);
		System.out.println(minute);
		System.out.println(second);		
	}
}

五、Math类

Math 类提供了一序列基本数学运算和几何函数的方法。

Math 类是类，并且它的所有成员变量和成员方法都是静态的。

1. Math类的常量和常用方法

常量：

常量修饰	常量名
static double	E 比任何其他值都更接近 e（即自然对数的底数）的 double 值。
static double	PI 比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。

常用方法：Math内的所有方法均为静态的。

方法名	含义
double sin (double a)	计算角a的正弦值
double cos (double a)	计算角a的余弦值
double pow (double a, double b)	计算a的b次方
double sqrt (double a)	计算给定值的平方根
int abs (int a)	计算int类型值a的绝对值，也接收long、float和double类型的参数
double ceil (double a)	返回大于等于a的最小整数的double值
double floor (double a)	返回小于等于a的最大整数的double值
int max (int a, int b)	返回int型值a和b中的较大值，也接收long、float和double类型的参数
int min(int a, int b)	返回int型值a和b中的较小值，也接收long、float和double类型的参数
int round(float a)	四舍五入返回整数
double random()	返回带正号的double值，该值大于等于0.0且小于1.0

package com.dream.math_class;

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

		System.out.println("求平方：" + Math.pow(3, 2));//9.0
		System.out.println("求平方根：" + Math.sqrt(9));//3.0
		System.out.println("求绝对值：" + Math.abs(-100));//100
		System.out.println("向上取整：" + Math.ceil(1.001));//2.0
		System.out.println("向下取整：" + Math.floor(1.99));//1.0
		System.out.println("求最大值：" + Math.max(10, 20));//20
		System.out.println("求最小值：" + Math.min(10, 20));//10
		System.out.println("四舍五入：" + Math.round(1.4));//1
		System.out.println("获取随机值（0包含~1不包含）：" + Math.random());
	}
}

需求：随机出1~100的整数

System.out.println((int)(Math.random()*100) + 1);

面试题：Math.abs() 有可能返回负数吗？

System.out.println(Math.abs(Integer.MAX_VALUE+1)); //输出-2147483648

2. 静态导入

​ 当使用一个类里面的静态方法或者静态变量时,每次都需要写类名。如果不想写类名，想直接写方法名或者变量名，则可以考虑使用静态导入

语法：import static 包名.类名.*; //导入该类下的所有静态方法和常量

例如：import static java.lang.Math.*; //导入Math下的所有方法和变量(包括常量)
则代码中可以直接使用方面和变量名，而不需要前缀Math。

package com.dream.math_class;

//静态导入：将Math类中所有的静态属性和静态方法都导入Test04这个类中，把导入的静态属性和静态方法都认为是Test04自己的内容
import static java.lang.Math.*;

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

		System.out.println("求平方：" + pow(3, 2));//9.0
		System.out.println("求平方根：" + sqrt(9));//3.0
		System.out.println("求绝对值：" + abs(-100));//100
		System.out.println("向上取整（天花板）：" + ceil(1.001));//2.0
		System.out.println("向下取整（地板）：" + floor(1.99));//1.0
		System.out.println("求最大值：" + max(10, 20));//20
		System.out.println("求最小值：" + min(10, 20));//10
		System.out.println("四舍五入：" + round(1.4));//1
		//静态导入缺点：可读性不高
		//如果本类中有和静态导入类相同的方法，会就近调用本类中的方法
		System.out.println("获取随机值（0包含~1不包含）：" + random());//此时输出的不再是随机数而是100
	}
	private static int random() {
		return 100;
	}
}

六、Random类

创建Random类对象

此类用于生成随机数：
Random(); //创建一个新的随机数生成器
Random(long seed); //seed种子数

package com.dream.random_class;

import java.util.Random;

public class Test01 {
	
	public static void main(String[] args) {
		//创建随机类的对象
		Random ran = new Random();
		
		int nextInt1 = ran.nextInt();
		System.out.println("随机出int取值范围内的数字：" + nextInt1);
		
		int nextInt2 = ran.nextInt(10);
		System.out.println("随机出0~9的数字：" + nextInt2);
		
		boolean nextBoolean = ran.nextBoolean();
		System.out.println("随机出boolean值：" + nextBoolean);
	}
}

案例：随机点名器

package com.dream.random_class;

import java.util.Random;

public class Test02 {
	
	public static void main(String[] args) {
		
		//创建随机类的对象
		Random ran = new Random();
		
		String[] names = {"张三","李四","王五","小明","小胖","阿坤","阿凡"};
		
		int index = ran.nextInt(names.length);

		System.out.println(names[index]);
	}
}

深入Random

写一个简单的随机数类(计算随机数的算法只是测试)

package com.dream.random_class;

public class MyRandom {
	
	//种子数
	private long seed;
	
	public MyRandom() {
		//seedUniquifier() ^ System.nanoTime() 获取到相对随机的种子数
		this(seedUniquifier() ^ System.nanoTime());
	}
	public static long seedUniquifier(){
		long current = System.currentTimeMillis();
		for(;;){
			current += current*5/3+3;
			if(current%4==0 || current%7==0){
				return current;
			}
		}
	}	
	public MyRandom(long seed){
		this.seed = seed;
	}	
	public int nextInt(){
		return (int) seed;
	}	
	public int nextInt(int i){
		return Math.abs((int) seed) % i;
	}
}

package com.dream.random_class;

import java.util.Random;

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

		//注意：随机全靠种子数，种子数固定，随机出的数据也是固定的
		
		Random ran = new Random();
		System.out.println(ran.nextInt());
		System.out.println(ran.nextInt(100));
		
		System.out.println("--------------");
		
		MyRandom myRandom = new MyRandom();
		System.out.println(myRandom.nextInt());
		System.out.println(myRandom.nextInt(10));	
	}
}

七、Runtime类

1、Runtime代表Java程序的运行时环境，可以通过 getRuntime 方法获取当前运行时。

2、应用程序不能自己创建Runtime对象，可以通过Runtime的静态方法getRuntime()获得Runtime对象。

3、Runtime类可以访问的相关信息，如处理器数量，内存信息等

package com.dream.runtime_class;

public class Test01 {
	
	public static void main(String[] args) {
        
		//获取运行环境对象
		Runtime run = Runtime.getRuntime();
		
		System.out.println("获取最大内存数(字节)：" + run.maxMemory());
		System.out.println("获取闲置内存数(字节)：" + run.freeMemory());
		System.out.println("获取处理数：" + run.availableProcessors();	
	}
}

八、System类

package com.dream.system_class;

import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;

public class Test01 {
	
	public static void main(String[] args) {
		
		//系统标准的输入流（方向：控制台 -> 程序）
		InputStream in = System.in;
		
		Scanner scan = new Scanner(in);
		String next = scan.next();
		
		//系统标准的输出流（方向：程序 -> 控制台）
        PrintStream out = System.out;
        out.println(next);
		
		//系统标准的错误输出流（方向：程序 -> 控制台）
		PrintStream err = System.err;
		err.println(next);
		
		//关闭资源
		scan.close();		
	}
}

System的out和err

out和err是两个线程，谁先抢到CPU资源谁就运行

说明了多线程的程序随机性很强

package com.dream.system_class;

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

		System.out.println("小明");
		System.err.println("小红");
		System.out.println("小强");
	}
}
/*
	这个输出结果是很随机的
	但是小明会比小强先输出
	out和err相当于两个线程，这两个线程会抢占CPU资源 如果err先抢到那么先输出小红，反之则先输出小明，而小明输出过后小红如果抢到了那么输出结果可能就是 小明 小红 小强，可能尝试运行看看结果
*/