java 常用类讲解

---

  Object 类，也叫超类，基类，所有类的直接或间接父类，位于继承树的最顶层。
  Object 类中所定义的方法，是所有对象都具备的方法。
  Object类型可以存储任何对象。作为参数，可接受任何对象；作为返回值，可返回任何对象。

public class A {

}

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

		// Object a = new A();
		A a = new A();
		//向上转
		Object obj = a;
		
		//向下转
		if (obj instanceof A) {
			A aa = (A)obj;
		}
	}
}

  Object 类中方法的使用。

public class Student {

	private String name;
	private int age;
	
	public Student() {
		
	}
	
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "name " + name + " age " + age;
	}
}

public class Test1 {
	public static void main(String[] args) {
		Student s1 = new Student();
		Student s2 = new Student();
		// 包名.类名
		System.out.println(s1.getClass());
		
		// 默认打印 toString() 方法
		System.out.println(s1);
		System.out.println(s1.toString());

		// 2018699554， 打印 hash 值
		System.out.println(s1.hashCode());
		// 1311053135
		System.out.println(s2.hashCode());
		
		// 2112
		System.out.println("Aa".hashCode());
		// 2112 ， hash 值并不唯一
		System.out.println("BB".hashCode());
	}
}

   比较类是否相等。

		// false，比较的地址 不一样
		System.out.println(s1 == s2);
		
		// false， 默认比较地址
		System.out.println(s1.equals(s2));

   如果对类的属性值进行相等的比较，需要重写方法。

public class Student {
	@Override
	public boolean equals(Object obj) {
		
		if (this == obj) {
			return true;
		}
		
		if (obj instanceof Student) {
			Student stu = (Student) obj;
			
			if (stu.name != null
				&& name!= null) {
				
				if (name.equals(stu.name)
					&& age == stu.age) {
					return true;
				}
			} else if (stu.name == null
					&& name == null) {
				if (age == stu.age) {
					return true;
				}
			}
			
		}
		
		return false;
	}
}

public class Test1 {
	public static void main(String[] args) {
		Student s1 = new Student("张三", 20);
		Student s2 = new Student("张三", 20);

		// true
		System.out.println(s1.equals(s2));
	}
}

  java 的垃圾回收机制。
  没有有效引用指向此对象时，为垃圾对象。自动回收机制，JVM 的内存耗尽，一次性回收所有垃圾对象；手动回收机制，使用 System.gc() 通知 JVM 执行垃圾回收或者主动触发 finalize()方法。

public class Student {
	@Override
	protected void finalize() throws Throwable {
		// TODO Auto-generated method stub
		super.finalize();
		
		System.out.println(name + " 被垃圾回收了");
		
	}
}

public class Test1 {
	public static void main(String[] args) throws Throwable {
		// 没有有效引用指向的垃圾对象
		new Student("e", 11);
		new Student("d", 11);
		new Student("g", 11);
		new Student("h", 11);
		// d 被垃圾回收了
		// h 被垃圾回收了
		// g 被垃圾回收了
		// e 被垃圾回收了
		System.gc();
		Thread.sleep(5000);
		
		Student s1 = new Student("a", 11);
		Student s2 = new Student("b", 11);
		Student s3 = new Student("c", 11);
		Student s4 = new Student("d", 11);
		// a 被垃圾回收了
		s1.finalize();
	}
}

  包装类，基本数据类型所对应的引用数据类型。默认值是null。

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

  类型转换与装箱、拆箱。

// 最好使用字符串初始化
Long l = Long.valueOf("1");
long l2 = Long.parseLong("1");
//把Long类型转换为int类型
int int1 = l.intValue();

//Boolean的valueOf转换的时候,不管大小写,只要是true就为true，否则都是 false
Boolean flag = Boolean.valueOf("abc");
System.out.println(flag);
boolean flag2 =Boolean.parseBoolean("abc");
//Character 没有 parse 方法。
Character c = Character.valueOf('a');

  整数缓冲区概念。Java预先创建了256（-128至127）个常用的整数包装类型对象，创建对象时，会在缓冲区找是否存在，不存在就在堆中开辟新的空间存储，否则复用。

Integer i1 = 10;
Integer i2 = 10;
// true
System.out.println(i1==i2);

Integer i3 = 199;
Integer i4 = 199;
// false， 另开辟了存储空间
System.out.println(i3==i4);
// true 值比较
System.out.println(i3.equals(i4));

//不管是否在缓冲区范围内,都会在堆中开辟空间存放数据
Integer i5 = new Integer(10);
// false
System.out.println(i1.equals(i5));

  String、StringBuilder 和 StringBuffer。
  运行速度 StringBuilder > StringBuffer > String。StringBuilder 是可变长字符串，JDK5.0 提供，运行效率快，线程不安全；StringBuffer 是可变长字符串，JDK1.0 提供，运行效率慢，线程安全。String 是不可变字符串，每次更改都会实例化一个新的对象。

// 在字符串池里面找是否已存在,如果不存在就创建一个新的，否则复用。
String a = "java";
String b = "java";
// true
System.out.println(a == b);
// 这个创建了几个对象 1个或者2个
// 在堆中开一个新的空间,指到字符串池中的java字符的位置
String c = new String("java");
// false
System.out.println(a == c);
//编译做了优化,只会创建 1 个对象
String d = "a" + "b" + "c" + "d";

// 获取字符
System.out.println(a.charAt(2));
// 是否包含
System.out.println(a.contains("jv"));
// 获取字符数组
char[] ch = a.toCharArray();
// 2， 首次出现的下标
System.out.println(a.indexOf("a"));
System.out.println(a.indexOf("av"));
// 2， 从后往前找		
System.out.println(a.lastIndexOf("av"));
// 去掉两边的空格
System.out.println(b.trim());
// 转换大学
System.out.println(b.toUpperCase());	
// 判断以什么结束
System.out.println(a.endsWith("va"));		
// 替换
System.out.println(b.replace(" ", ""));
		
// 拆分成数组
String e = "j,a,v,a";
String[] Arre = e.split(",");

// 从下标（包含）到结束
String sub1 = a.substring(2);		
// 从下标（包含）到结束下标(不包含)
String sub2 = a.substring(2, 3);

StringBuilder sbd = new StringBuilder(a);
sbd.append(1.8);
// java1.8
System.out.println(sbd);

  BigDecimal 类。精确计算浮点数。很多实际应用中需要精确运算，而double是近似值存储，不在符合要求，需要借助BIgDecimal。

public Double mul(Double i, Double j) {
	// 最好用字符串实例化
	BigDecimal a = new BigDecimal(i.toString());
	BigDecimal b= new BigDecimal(j.toString());
	// 转为 Double 类型。
	return a.multiply(b).doubleValue();
}

public BigDecimal div(Double i, Double j) {
	BigDecimal a = new BigDecimal(i.toString());
	BigDecimal b= new BigDecimal(j.toString());
	// 小数点位数、四舍五入
	return a.divide(b, 2, BigDecimal.ROUND_HALF_UP);
}

  Date 日期类。Date表示特定的瞬间，精确到毫秒。Date 类中的大部分方法都已经被 Calendar 类中的方法所取代。

//日期类型, 可以获取年月日时分秒 
Date date = new Date();
System.out.println(date.getYear()+1900);
// 时间戳，毫秒 所有的时间类型,都可以使用
System.out.println(date.getTime());
		
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//日期转字符串
String s = sdf.format(date);
//字符串转日期,要注意字符串的日期格式必须和Format设置格式一致
Date dd = sdf.parse("2019-12-12 16:30:23");
System.out.println(dd);

  Calendar 日历类。 提供了获取或设置各种日历字段的方法。protected Calendar() 构造方法为 protected 修饰，无法直接创建该对象。

public class Test1 {
	
	public static void main(String[] args) throws ParseException {
		// TODO Auto-generated method stub
		
		// 当前日历
		Calendar c1 = Calendar.getInstance();
		
		Date d1 = new Date();
		// 日期时间戳
		System.out.println(d1.getTime());
		// 日历时间戳
		System.out.println(c1.getTimeInMillis());
		
		// 修改时间
		c1.add(Calendar.YEAR, 1);
		c1.add(Calendar.DAY_OF_MONTH, 8);
		
		System.out.println(c1.get(Calendar.YEAR));
		System.out.println(c1.get(Calendar.MONTH) + 1);
		System.out.println(c1.get(Calendar.DAY_OF_MONTH));
		
		SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日");
		Calendar c2 = Calendar.getInstance();
		// 日历转日期
		Date d2 = c2.getTime();
		
		String s2 = format.format(d2);
		System.out.println(s2);
		
		String s3 = "2000年12月20日";
		Date d3 = format.parse(s3);
		Calendar c3 = Calendar.getInstance();
		// 日期转日历
		c3.setTime(d3);
		System.out.println(c3);
		System.out.println(c3.get(Calendar.YEAR));
		System.out.println(c3.get(Calendar.MONTH) + 1);
		System.out.println(c3.get(Calendar.DAY_OF_MONTH));
	}

}

  System 类。

public class Test {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		int[] arr1 = {1,2};
		int[] arr2 = {3,4,5};
		
		/**
		 * 1
		 * System.arraycopy(src, srcPos, dest, destPos, length); 无返回值
		 * Object src  源数组
		 * int srcPos  从源数组的下标开始复制
		 * Object dest 目标数组
		 * int destPos 从目标数组下标接受值
		 * int length  从源数组的srcPos开始接收多少长度的数据，注意源数组的srcPos + length 不能大于 src.length,否则数组越界报错
		 */
		System.arraycopy(arr1, 0, arr2, 1, arr1.length);
		for (int i = 0; i < arr2.length; i++) {
			System.out.println(arr2[i]);
		}
		// 当前系统时间戳 毫秒
		System.out.println(System.currentTimeMillis());
		
		// 垃圾回收
		System.gc();
		// 退出jvm ，0 正常退出， 非 0 异常退出
		System.exit(1);
		System.out.println("退出了吗");
	}

}

---