【JavaSE】Java常用类
前言
本文为Java常用类详细介绍，Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~
一、内部类
- 定义在类的内部的类叫做内部类。
- 内部类的作用一般是用来封装在类的内部使用的类，不希望外部被其他类所使用。
1.分类
- 成员内部类：直接在类的内部定义的类
- 静态内部类：直接在类的内部定义的前面加上static关键字的类
- 局部内部类：在方法中定义的类
- 匿名内部类：没有类的名称，只使用一次的类
2.成员内部类
- 使用方式等同于成员变量的使用方式
public class A {
int i = 3;
public class B{
public String n;
}
public void m() {
B b = new B();
}
}
public class Test {
public static void main(String[] args) {
A a = new A();
a.i = 3;
A.B b = new A().new B();
b.n = "Hello";
System.out.println(b.n);
}
}
- 成员内部类与外部类的相互调用
- 内部类不能定义静态属性，但是可以定义静态常量，需要直接赋值
public class A {
int i = 3;
// 在外部类可以创建对象调用内部类
public void m() {
B c = new B();
System.out.println(i);
System.out.println(c.n);
c.b();
}
public class B{
public String n;
int i = 5;
// 内部类可以直接调用外部类
public void b() {
System.out.println(n);
System.out.println(i); // 调用当前类的i属性
System.out.println(A.this.i); // 如果属性名称相同，调用外部的i属性
// m();
}
}
}
3.静态内部类
- 在类的内部定义的使用static修饰的类
- 注意：静态内部类中无法访问外部类的实例相关的内容
public class StaticA {
public static String count;
public String a;
public static class StaticB{
public String name;
public static int i;
public void m() {
// System.out.println(StaticA.this.a); // 无法访问外部类的成员
System.out.println(count);
}
public static void sm() {
System.out.println(count);
}
}
}
public static void main(String[] args) {
StaticA.count = "5";
StaticA.StaticB staticB = new StaticA.StaticB(); // 使用外部类的类名来引用内部类的构造方法
}
4.局部内部类
- 在一个方法中定义的类，只能在该方法中创建对象并使用
public class C {
public String name = "aaa";
public void m1() {
class D{ // 局部内部类的使用
int n = 5;
public void d() {
System.out.println(n);
System.out.println(name);
}
}
D d = new D(); // 创建对象
d.n = 10;
d.d();
}
public void m2() {
}
}
5.匿名内部类
- 一般是将接口使用new关键字在创建对象时进行一个匿名实现
- 作用：在项目中，有些类只需要创建一个对象，此时可以使用匿名内部类。（单例模式最好的解决方法就是使用此方案<内部类的方式>）
public interface MyInter {
void method();
void m1();
}
public static void main(String[] args) {
MyInter m = new MyInter() {
@Override
public void method() {
System.out.println("method");
}
@Override
public void m1() {
System.out.println("m1");
}
};
m.method();
}
二、Object类
Class Object是类Object结构的根。 每个类都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法
Object中的方法：
- clone()：克隆
- equals(Object obj)：比较
- getClass()：获得对象类型
- hashCode()：返回对象的哈希码值
- finalize()：垃圾回收
- toString()：返回对象的字符串表示形式
- notify()：唤醒正在等待对象监视器的单个线程
- notifyAll()：唤醒正在等待对象监视器的所有线程
- wait()：导致当前线程等待，直到另一个线程调用该对象的notify()或notifuAll()方法
- 注意：其中equals()方法是比较内存地址的，若想比较值需要重写equals()方法!!!
判断一个对象是否某个类型的两种方式：
if(obj3 instanceof Cat) {
System.out.println("obj3是cat类的对象");
}
if(obj2.getClass() == Dog.class) {
System.out.println("obj2是dog类的对象");
}
hashCode():通过对象的地址或者其他信息根据hash算法计算出来的一个数字，有利于对象在内存中的查找、排序、比较等。相同的对象应该保证其hashCode相同，不同的对象尽可能保证hashCode不同。
toString()：默认显示当前对象类型和其hashCode，意义不大。一般情况下，在自定义的类中，需要对toString方法进行重写，以便在输出时能够输出更多的信息。
public class Animal {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Animal [name=" + name + "]";
}
}
equals方法用来比较对象是否相同的对象。不应该使用，因为比较是地址。由于在Object中equals方法是默认为用==比较，所以在实际项目中，应该重写equals方法，然而相同的对象应该有相同的hashCode，所以重写equals方法的同时也应该重写hashCode方法。
public class Animal {
private String id;
private String name;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Animal [name=" + name + "]";
}
@Override
public boolean equals(Object obj) {
if(obj == null) { // 对象是否为空
return false;
}
if(this == obj) { // 是否同一个地址
return true;
}
if(obj instanceof Animal) { // 是否同一个类型
Animal a = (Animal)obj;
if(a.id == null) {
return false;
}
if(this.id .equals(a.id) ) {
return true;
}else {
return false;
}
}else {
return false;
}
}
@Override
public int hashCode() {
return id.hashCode();
}
}
三、包装类
- Java中基本数据类型对应的引用数据类型，叫包装类
public static void main(String[] args) {
// JDK1.5之前的写法
int i = 3;
Integer in = new Integer(i); // 装箱
Object obj = in;
int i2 = in.intValue(); // 拆箱
// JDK1.5之后，自动装箱拆箱
Integer in1 = i; // 自动装箱
int i3 = in1; // 自动拆箱
Double d = 0.3;
double db = d;
// 将字符串转换成基本数据类型
String s = "3";
// 如果该字符串里面不是数字，将会出现NumberFormatException
int n = Integer.valueOf(s); // parseInt()也行
System.out.println(n);
String s1 = "2.04";
double db1 = Double.parseDouble(s1);
System.out.println(db1);
// 如果该字符串中不是true(不区分大小写)，则返回false，不论如何不会报错
String s2 = "TRue";
boolean b = Boolean.parseBoolean(s2);
System.out.println(b);
// 对于char类型，直接使用charAt(index)
String s3 = "ABCD";
char c = s3.charAt(2);
System.out.println(c);
int m = 50;
int m1 = 50;
System.out.println(m == m1);
// Integer常量池（缓冲区）
// 在Integer中，最多会设置-128到127，一共256个常量
// 在使用valueOf或者直接以数字的形式赋值时，会去常量池中查找，如果能找到，则返回该常量，否则或创建一个对象
// 如果是常量池中的常量，使用再多次，也是用的同一个地址
Integer in2 = 100;
Integer in3 = 100;
System.out.println(in2 == in3); // true
Integer in4 = 200;
Integer in5 = 200;
System.out.println(in4 == in5); // false
Integer in6 = new Integer(100);
Integer in7 = new Integer(100);
System.out.println(in6 == in7); // false
Integer in8 = Integer.valueOf(100);
Integer in9 = Integer.valueOf(100);
System.out.println(in8 == in9); // true
Integer in10 = Integer.valueOf(200);
Integer in11 = Integer.valueOf(200);
System.out.println(in10 == in11); // false
}
四、字符串
- String对象创建后不可变，是指String内部使用一个final char[]来存放数据。所以值不能改变。
- String每次重新赋值相当于重新的创建了字符串。
String s = "hello";
s = "world678";
System.out.println(s);
- 字符串的两种赋值方式： String s = “hello”; String s1 = new String(“world”);
- 字符串常量池，在内存中，会分配一块空间，里面存放字符串常量，当使用""来给字符串赋值时，会在常量创建该字符串，如果变量直接用等于接收，即变量中存储的是该常量的地址，而该常量可以复用，所以下面第一个表达式的值为true，即都指向常量池中的同一个区域。
- 而如果通过new String来创建对象，会分配一个块新的空间，所以下面的第二个表达式值为false。
String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // true
String s3 = new String("hello");
String s4 = new String("hello");
System.out.println(s3 == s4); // false
- 字符串的常量优化：(编译期优化)
- 如果字符串在编译时，能确定值，并且不会变化，则会进行优化，直接在编译时直接得到结果，而不会在运行时再计算。
String s5 = "ab";
String s6 = "a" + "b";
System.out.println(s5 == s6); // true
String s7 = "a";
String s8 = s7 + "b";
System.out.println(s5 == s8); // false
final String s9 = "a";
String s10 = s9 + "b";
System.out.println(s5 == s10); // true
- 字符串常用方法如下代码
- 注意： 如果该方法是用来改变字符串，一定会返回一个新的字符串，因为字符串不能直接改变 。
public static void main(String[] args) {
// 得到字符某个位置的字符
String s = "hello";
char ch = s.charAt(1); // 结果为e
String s1 = "oh, hello, hello";
boolean b = s1.contains(s); // 结果是true，s1字符串中包含s
System.out.println(b);
char [] arr = s1.toCharArray(); // 将字符串转换成char数组
System.out.println(Arrays.toString(arr));
int index = s1.indexOf(s); // 判断s1中是否包含s，如果包含则返回s第一次出现的下标，如果不包含，则返回-1
System.out.println(index);
// 注意：数组的长度为length属性，字符串是length方法
System.out.println(s1.length()); // length方法返回字符串的长度
String s2 = " hello ";
System.out.println(s2);
System.out.println(s2.length());
String newS2 = s2.trim(); // 去掉字符串两边的空格
System.out.println(newS2);
System.out.println(newS2.length());
String newS1 = s1.toUpperCase(); // 将字符串全部大写
System.out.println(newS1);
newS1 = newS1.toLowerCase(); // 将字符串全部小写
System.out.println(newS1);
boolean b1 = s1.startsWith("oh,"); // 判断字符串是否以xx开始
System.out.println(b1);
b1 = s1.endsWith("oh,"); // 判断字符串是否以xx结尾
System.out.println(b1);
String newS3 = s1.replace("h", "ooo"); // 将字符串中出现h全部替换成ooo
System.out.println(newS3);
String [] strArr = s1.split(","); // 将字符串根据,切割成一个字符串数组
System.out.println(strArr.length);
System.out.println(Arrays.toString(strArr));
String s4 = "abcdefghijkllmn";
String newS4 = s4.substring(3); // 从第三号位置开始截取，截取后面所有的字符串
System.out.println(newS4);
newS4 = s4.substring(3, 6); // 从第三号位置开始截取，截取到6号位置（不包含6号位置）
System.out.println(newS4);
byte [] bytes = s5.getBytes(); // 得到所有的字节形成的字节数组
System.out.println(Arrays.toString(bytes));
}
五、可变字符串
- 可变字符串可以对字符串进行增删改操作，主要作用是当要大量的操作字符串的时候，应该使用可变字符串，以提升性能，节约空间。
- StringBuffer：JDK1.0提供，线程安全，效率低
- StringBuilder：JDK5.0提供，线程不安全，效率高
// 创建StringBuilder或StringBuffer
StringBuilder sb = new StringBuilder("hello");
// 拼接字符串
sb.append("world");
sb.append("world");
sb.insert(2, "aaa"); // 向第二号位插入内容
sb.delete(3, 6); // 从第3号位删除到第6号位（不包含6号位）
System.out.println(sb.toString());
六、BigDecimal
- 通常用来进行小数精确运算和大数字的计算。
- 注意：构造方法一定要使用字符串的方式。
public static void main(String[] args) {
// System.out.println(1.0-0.9); // 不精确
// System.out.println(2100000000 * 2100000000 * 2100000000); // 超出范围
BigDecimal b = new BigDecimal("1.0");
BigDecimal b1 = new BigDecimal("0.9");
System.out.println(b.subtract(b1)); // 减法
BigDecimal b2 = new BigDecimal("1.0234279243253");
BigDecimal b3 = new BigDecimal("0.91231231234");
System.out.println(b2.multiply(b3)); // 乘法
BigDecimal b4 = new BigDecimal("1.0234279243253");
BigDecimal b5 = new BigDecimal("0.91231231234");
// 参数1，数
// 参数2，保留小数位
// 参数3，此处选择的四舍五入
System.out.println(b4.divide(b5, 2000, BigDecimal.ROUND_HALF_UP));// 除法
// 大数字的运算
BigDecimal b6 = new BigDecimal("428374892734927347892749827498273947298374927344");
BigDecimal b7 = new BigDecimal("548347593754892874823472938748237875984359374859");
System.out.println(b6.multiply(b7));
}
七、Date
- 常用的一个日期时间类，可以得到当前时间，与其他的时间比较早晚。
public static void main(String[] args) {
Date d = new Date(); // 得到当前时间对象，有时区
// 得到距离1970-1-1 GMT 0:0:0 所经过的毫秒数
System.out.println(d.getTime());
d.setTime(1597046465956L); // 设置时间为2020-8-10 16:01:05 CST
System.out.println(d);
Date d1 = new Date();
System.out.println(d.before(d1)); // 判断d是否在d1之前
System.out.println(d.after(d1)); // 判断d是否在d1之后
int n = d.compareTo(d1); // d如果早于d1，返回-1，等于返回0，晚于返回1
System.out.println(n);
}
八、日历类
- 日历类主要作用是对日期进行获取和设置，并进行加减。
public static void main(String[] args) {
// 得到对象，不能使用new创建对象
Calendar c = Calendar.getInstance();
// 获取日期
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);
int date = c.get(Calendar.DATE);
int hour = c.get(Calendar.HOUR_OF_DAY);// 24小时制
int minute = c.get(Calendar.MINUTE);
int second = c.get(Calendar.SECOND);
int weekday = c.get(Calendar.DAY_OF_WEEK); // 日一二三
System.out.println(year + "年" + (month+1) + "月" + date + "日 " +
hour + ":" + minute + ":" + second + " 星期" + weekday);
// 日期计算
// 参数1：日期计算的标准（日，月，年，星期，小时等）
// 参数2：时长（可以使用负数）
c.add(Calendar.WEEK_OF_YEAR, -60);
System.out.println(c);
}
九、SimpleDateFormat
- 主要作用是将日期格式化成字符串，或将字符串转换成日期格式。
public static void main(String[] args) {
String s = "1999年10月10日 14:25:36.175";
// yyyy 年
// MM 月
// dd 日
// HH 24制小时
// hh 12小时制
// mm 分钟
// ss 秒
// SSS 毫秒
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss.SSS");
try {
Date date = sdf.parse(s); // 将字符串转换成日期类型
System.out.println(date);
} catch (ParseException e) {
// 如果出错会执行输出异常原因
e.printStackTrace();
}
Date d = new Date();
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = sdf1.format(d); // 按照提供的格式将日期转换成字符串显示
System.out.println(str);
} = 'bar';
十、System类的常见方法
- arrayCopy() ：数组复制
- currentTimeMillis()：得到当前时间的毫秒数
- gc()：建议JVM启动垃圾回收
- exit(0)：退出系统
public static void main(String[] args) {
// 得到当前时间距离1970-1-1 0:0:0 GMT的毫秒数
System.out.println(System.currentTimeMillis());
for (int i = 0; i < 100; i++) {
if(i == 20) {
System.exit(0); // 退出系统
}
System.out.println(i);
}
}
后记
Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
