java常用类

一、内部类

成员内部类、静态内部类、局部内部类、匿名内部类

1)成员内部类

概念:在一个类的内部再定义一个类

例如:

class Outward{
	class Innner{
	}
}

java文件经过编译后会生成字节码文件也就是 .class文件,上面的代码编译后会生成Outward.class文件
内部类编译之后也会生成 .class文件以外部类名$内部类名组成
上面的代码编译后会生成OutwardInner.class文件

如果想引用内部类对象需要先创建外部类对象
内部类依存于外部类 :

创建外部类对象
Outward outward= new Outward ();
创建内部类
Inner inner= Outward.new Inner();


通过外部类直接创建:
Outward outward = new Outward().new Inner();

需要注意当内部类与外部类属性重名时,内部类优先级更高
内部成员类不能定义静态成员,但可以包含静态常量:

class Outward {
	class Inner{
		private static final String name;
		private static String name;//会报错
	}
}

2).静态内部类

不依赖外部类对象,可以直接创建或通过类名访问

class Outward{
	static class Innner{
		//静态内部类可包含静态变量
    	private static String name;
	}
}

//引用静态内部类对象
Outward.Innner Innner= new Outward.Innner();

只有内部类使用static修饰

3)局部内部类

定义在外部类方法中,作用范围仅限与当前方法

class Outward{
 	private String name = "小明";
	public String show(){
        //注意:局部内部类不能加任何修饰符
        class Inner{
            private int age = 18;
        }        
    }
}

局部内部类的生命周期随着方法执行完毕而结束,访问外部类当前方法中的局部变量时,因无法保证变量的生命周期与自身相同,变量必须修饰为final

4)匿名内部类

没有类名的局部内部类
必须继承一个父类或实现一个接口

class Outward{
 	public String show(){
		class Inner implements interface{
		}
	}
}

二.Object类

超类,基类,所有类的直接或间接父类,位于继承树的最顶层

任何类,如果没有书写extends显式继承某个类,都默认直接继承Object类,否则为间接继承
Object类所定义的所有方法,是所有对象都具备的方法
Object类型可以储存任何对象
作为参数,可以接收任何对象,作为返回值,可以返回任何对象

Object类的常用方法:

getClass()方法:

public final Class<?> getClass(){}

返回引用中存储的实际对象类型

应用:通常用来判断两个引用中实际存储对象类型是否一致

User user1 = new User("张三",18);
User user2 = new User("李四",20);
//判断user1和user2是否为同一个类型
Class class1 = user1.getClass();
Class class2 = user2.getClass();
if(class1 = class2){//进入if 输出为true
    System.out.print("true");
}else{
	System.out.print("false");
}

hashCode()方法:

Public int hashCode(){}
返回该对象的哈希码值
哈希码值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值

一般情况下相同对象返回相同哈希码

User user1 = new User("张三",18);
User user2 = new User("李四",20);
User user3 = user1;
//返回false(地址不同)
System.out.print(user1.hashCode() == user2.hashCode());
//返回true
System.out.print(user1.hashCode() == user3.hashCode());

toString()方法

public String toString(){}

返回该对象的字符串表示(表现形式)
可以根据程序需求覆盖(重写)该方法,如:展示对象各个属性值

User user1 = new User("张三",18);

user1.toString();//返回全类名+哈希值
//重写toString()
public String toString(){
    return "name="+name+"age="+age;
}
//在次调用会返回属性值

equals()方法

public boolean equals(Object obj){

	(this == obj)

}

默认实现为(this == obj),比较两个对象地址是否相同
可进行覆盖,比较两个对象内容是否相等

User user1 = new User("张三",18);
User user2 = new User("李四",20);

user1.equals(user2);//返回false(地址不同)

重写equals()

@Override
public boolean equals(Object obj){
    //1.判断两个对象是否同一个引用
    if(this == obj){
        return true;
    }
    //2.判断obj是否为空
    if(obj == null){
        return false;
    }
    //3.判断是否为同一类型
    /**if(this.getClass() == obj.getClass()){
        
    }*/
    //instanceof 判断对象是否是某种类型
    if(obj instanceof User){
        //4.强制类型转换
        User u = (User)obj;
        //5.比较属性
        if(this.name.equals(u.getName() && this.age==obj.getAge)){
            return true;
        }
    }
}

finalize()方法

当对象为判定为垃圾对象时,由JVM自动调用此方法,用于标记垃圾对象,进入回收队列

java有垃圾回收机制,不需要程序员手动调用

垃圾回收机制:JVM内存耗尽,一次性回收所有垃圾对象
手动回收机制:使用System.gc();通知JVM执行垃圾回收

重写该方法便于观察:

@Override
protected void finalize() throws Throwzble{
    System.out.println(this.name+"被回收");
}

User user1 = new User("张三",18);
User user2 = new User("李四",20);
user3 = new User("王五",18);
user4 = new User("赵六",20);
//回收垃圾
System.gc();

三.包装类

java提供了八大基础数据类型:byte short int long double flout boolean char,但是这些基础类型没有属性或方法,也就是说只能用来进行一些基本的逻辑判断
在需要进行复杂操作时就需要用到包装类,每个基本类型都对应一个引用类型:

基本类型	引用类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

Object 可统一所有数据，包装类的默认值是null

装箱与拆箱的概念:
基本类型转换为引用类型叫做装箱,引用类型转换为基本类型叫做拆箱
基本类型存放在栈中 引用类型存放在堆中 基本类型指向堆中的引用类型的引用

//装箱
int int1 = 66;
Integer integer1 = new Integer(int1);
Integer integer2 = Integer.valueOf(int1);
//拆箱
Integer integer3 = new Integer(66);
int num2 = integer3.intValue();
//jdk1.5之后，java提供了自动装箱拆箱
int a= 30;
// 自动装箱
Integer b= a;
// 自动拆箱
int c= b;

基本类型和字符串之间转换, .parseXXX()方法

//String类型转boolean,只有"true"会转为true其他任何字符串都会转为false
String str1 = "true";
String str2 = "joajoaijcnv";
if(Boolean.parseBoolean(str1)){
	//输出true
	System.out.print("true");
	//输出false
	System.out.print(Boolean.parseBoolean(str2));
}

//  基本类型转成字符串
int n1 = 100;
// 使用+号
String s1 = n1 + "";
// 2 使用Integer中的toString()方法
String s2 = Integer.toString(n1);
String s2 = Integer.toString(n1, x); // x为进制要求

// 字符串转成基本类型
String str = "150";
// 使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
// boolean 字符串形式转成基本类型，"true" ---> true 非“true ———> false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);

思考题

psvm(String[] args){
  // 面试题
  Integer integer1 = new Integer(100);
  Integer integer2 = new Integer(100);
  sout(integer1 == integer2); // false  地址不同
  Integer a = 100;
  Integer b = 100;
  sout(a == b); // true
  
  //new Integer(100) 相当于调用构造 Integer.valueOf(100);
  Integer integer3 = new Integer(100);// 自动装箱
  Integer integer4 = new Integer(100);
  sout(integer3 == integer4); // true
  
  Integer integer5 = new Integer(200);// 自动装箱
  Integer integer6 = new Integer(200);
  sout(integer5 == integer6); // false
  
  // 因为缓存区数组 [-128, 127] 在这之内地址一样
}

Java预先创建了256个常用的整数包装类型对象
在实际应用当中，对已创建的对象进行复用

String

String是常量,创建后不可改变,字符串字面值储存在字符串池中,可以共享

程序在运行过程中有三块重要的空间:堆(存放对象),栈(基本类型数据),方法区(字符串)

//String的不可变性,当给创建的String类型再次赋值时,会在字符串池中开辟一块新的空间,指向另一个引用
String name = "张三";
name = "李四";
//String的共享,当创建String对象时,回到字符串池中寻找是否有相同的值,如果有就将新的对象指向这个引用
String name1 = "zhangsan";
String name2 = "zhangsan";
//不同的创建方式,开辟空间的方式也不一样
String s = "Hello";//产生一个对象，字符串池中存储  栈指向方法区的引用
String s = new String("Hello"); //产生两个对象，堆、池各一个  栈指向堆的引用

常用方法

// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串
String content = "java是最好的语言, java no1";
sout(content.length()); // 10
sout(content.charAt(content.length() - 1)); // 言
sout(content.contains("java")); // true

// 4. toCharArray(); 返回字符串对应数组 
// 5. indexOf(); 返回子字符串首次出现的位置
// 6. lastIndexOf(); 返回字符串最后一次出现的位置
sout(content.toCharArray());
sout(content.indexOf"java")); // 0
sout(content.indexOf("java", 4)); // 从索引4开始找 返回12
sout(content.lastIndexOf("java")); // 12

// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str);  判断是否以str 结尾、开头
String ct = " hello world ";
sout(ct.trim()); // "hello world"
sout(ct.toUpperCase()); // HELLO WORLD
sout(ct.toLowerCase()); // hello world
sout(ct.endWith("world")); // true
sout(ct.startWith("hello")) // true
  
// 10. replace(char old, char new); 用新的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分
sout(content.replace("java", "php")); // php是最好的语言, php no1
String say = "java is the best language";
String[] arr = arr.say.split(" "); // "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
sout(arr.length); // 5
for(String string : arr){
  sout(string);
}
// 打印出 
//java
//is
//the 
//best
//language

// 补充两个equals/compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
sout(s1.equalsIgnoreCase(s2));// 忽略大小写比较true

// compareTo(); 两字符不同时比较字符字典序的ascii码
// 字符相同时比较长度 返回差值

String操作题

已知String str = “this is a text”;
将str中的单词单独获取
将str中的text替换成practice
在text前面插入一个easy
将每个单词的首字母改为大写

psvm(String[] args){
  String str = "this is a text";
  // 2. 
  String[] arr = str.split(" ");
  for(String s : arr){
    sout(s);
  }
  // 3.
 String str2 = str.replace("text", "practice");
  // 4. 
  String str3 = str.replace("text", "easy text");
  // 5. 
  for(int i = 0; i < arr.length; i ++){
    char first = arr[i].charAt(0);
    char upperfirst = Character.toUpperCase(first);
    String new = upperfirst + arr[i].substring(1);
  }
}

可变字符串StringBuffer StringBuilder

StringBuffer : 可变长字符串，运行效率慢、线程安全
StringBuilder : 可边长字符串、运行快、线程不安全
效率都比String高且节省内存

psvm(String[] args){
  // StringBuffer 和 StringBuilder 用法一致
  StringBuffer sb = new StringBuffer();
  // 1. append(); 追加
  sb.append("java no1");
  // 2. insert(); 添加、插入
  sb.insert(0, "在第一个位置插入");
  // 3.replace(); 替换
  sb.replace(0, 9, str); // 左闭右开
  // 4. delete(); 删除
  sb.delete(0, 5); // 左闭右开
  // 5. 清空
  sb.delete(0, sb.length());
}

四.BigDecimal 类

BigDecimal 类在 java.math 包中
主要用于 精确计算浮点数
通过 BigDecimal bd = new BigDecimal(“1.0”); 创建

BigDecimal bd1 = new BigDecimal("1.0"); // 需用字符串
BigDecimal bd2 = new BigDecimal("0.9");
// 减法
BigDecimal r1 = bd1.subtract(bd2);
sout(r1); // 0.1

// 加法
BigDecimal r2 = bd1.add(bd2);

//乘法
BigDecimal r3 = bd1.multiply(bd2);

// 除法
BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"), x, BigDecimal.ROUND_HALF_UP); 
//除不尽时 x填保留位数 后面为四舍五入之意

五.时间操作方面的类

Date ()

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

psvm(String[] args){
  // 1 创建Date对象
  Date date1 = new Date();
  sout(date1.toString()); //WED Sept 02 22:25:23 CST 2020
  sout(date1.toLocaleString()); // 已过时 但也能用 2020-9-2
  
  // 创建昨天的
  Date date2 = new Date(date1.getTime() - (60*60*24*1000));
  sout(date2.toLocaleString());
  
  // 2 方法after before
  boolean b1 = date.after(date2);
  sout(b1); //true
  boolean b2 = date1.before(date2);
  sout(b2); //false
  
  // 比较compareTo();
  int d = date1.compareTo(date1);
  sout(d); // 多的为1 少的为 -1 
  
  // 比较是否相等 equals()
  boolean b3 = date1.equals(date2);
  sout(b3); // false
}

Calendar()

提供了获取或设置各种日历字段的方法
构造方法 protected Calendar(); 由于是protected 所以无法直接创建
Calendar类常用方法:

方法名	作用
static Calendar getInstance()	使用默认时区和区域获取日历
void set(int year, int month, int date, int hourofday, int minute, int second)	设置日历的年、月、日、时、分、秒
int get(int field)	返回给定日历字段的值。字段比如年、月、日
void setTime(Date date)	用给定的date设置此日历时间
Date getTime()	返回一个date表示此日历的时间
void add(int field, int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeInMilles()	毫秒为单位返回该日历的时间值

psvm(String[] args){
  // 1. 创建 Calendar 对象
  Calendar calendar = Calendar.getInstance();
  sout(calendar.getTime().toLocaleString());
  // 2. 获取时间信息
  // 获取年
  int year = calendar.get(Calendar.YEAR);
  // 获取月 从 0 - 11
  int month = calendar.get(Calendar.MONTH);
  // 日
  int month = calendar.get(Calendar.DAY_OF_MONTH);
  // 小时
  int hour = calendar.get(Calendar.HOUR_OF_DAY);
  // 分钟
  int minute = calendar.get(Calendar.MINUTE);
  // 秒
  int second = calendar.get(Calendar.SECOND);
  // 3. 修改时间
  Calendar calendar2 = Calendar.getInstance();
  calendar2.set(Calendar.DAY_OF_MONTH, x);
  // 4. add修改时间
  calendar2.add(Calendar.HOUR, x); // x为正就加 负就减
  // 5. 补充方法
  int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);// 月数最大天数
  int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
}

SimpleDateFormat

是一个以与语言环境有关的方式来格式化和解析日期的具体类
进行格式化（日期→文本）、解析（文本→日期）

psvm(String[] args){
  // 1. 创建对象
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
  // 2. 创建Date
  Date date = new Date();
  // 格式化date（日期→字符串）
  String str = sdf.format(date);
  sout(str);
  // 解析（字符串→时间）
  Date date2 = sdf.parse("1948/03/12");
  sout(date2); 
}

System类

主要用于获取系统的属性数据和其他操作，构造方法私有的

方法名	作用
static void arraycopy(…)	复制数组
static long currentTimeMillis();	获取当前系统时间，返回毫秒值
static void gc();	建议jvm赶快启动垃圾回收期器回收垃圾
static void exit(int status);	退出jvm 如果参数是0表示正常退出jvm 非0表示异常退出

psvm(String[] args){
  //arraycopy 复制
  //src-原数组 srcPos-从哪个位置开始复制0 dest-目标数组 destPos-目标数组的位置 length-复制的长度
  int[] arr = {20, 18, 39, 3};
  int[] dest = new int [4];
  System.arraycopy(src, srcPos, dest, destPos, length);
  sout(arr, 4, dest, 4, 4)
    
  // Arrays.copyOf(original, newLength)
}
psvm(String[] args){
  //arraycopy 复制
  //src-原数组 srcPos-从哪个位置开始复制0 dest-目标数组 destPos-目标数组的位置 length-复制的长度
  int[] arr = {20, 18, 39, 3};
  int[] dest = new int [4];
  System.arraycopy(src, srcPos, dest, destPos, length);
  sout(arr, 4, dest, 4, 4)
    
  // Arrays.copyOf(original, newLength)
}