JavaSE-常用类

常用类

一、内部类

概念：在一个类内部在定义一个完整的类

特点：

• 编译之后可生成独立的字节码文件
• 内部类可以直接访问外部类的私有成员，而不破坏封装

（一）成员内部类

• 在类内部定义，与实例变量、示例方法同级别的类
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
  • Outer out = new Outer（）；
  • Inner in = out.new Inner()；
• 当外部类、内部类存在重名属性时，会优先访问内部类属性
• 成员内部类不能定义静态成员，private static String country=“中国”;（错误）
• 成员内部类可以定义静态常量，private static final String country=“中国”;

（二）静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
• 静态内部类级别和外部类级别相同
• 只有内部类可以是静态的，普通类不可以用static进行修饰

（三）局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
• 局部内部类：注意不可以加任何访问修饰符
• 局部内部类里面不可以包含静态成员的，但是可以包含静态常量
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final

（四）匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）
• 必须继承一个父类，或者实现一个接口；
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
• 优点：减少代码量
• 缺点：可读性较差

二、常用类举例

（一）Object

• 超类、基类，所有类的直接或间接父类，位于继承树的最顶层
• 任何类如果没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
• Object类中所定义的方法，是所有对象都具备的方法
• Object类型可以存储任何对象
  • 作为参数，可接受任何对象
  • 作为返回值，可返回任何对象
  • 方法：

getClass（）方法

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

• 通常用于判断两个引用中的实际存储对象类型是否一致

• hashCode（）

  • 返回该对象的哈希值
  • 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
  • 一般情况下相同对象返回相同的哈希码

toString()

• 返回该对象的字符串表示
• 可以根据程序需求覆盖该方法，如，展示对象各个属性值

equals（）

• public Boolean equals（Object obj）{}
• 默认实现为（this == obj），比较两个对象地址是否相同
• 可进行覆盖，比较两个对象的内容是否相同
• equal（）方法覆盖步骤：
  • 比较两个引用是否指向同一对象，
  • 判断object是否为null
  • 判断两个引用指向的实际对象类型是否一致
  • 强制类型转换
  • 依次比较各个属性值是否相同

finalize（）

• 当对象被判定为垃圾对象时，有JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象
• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间；
• 自动回收机制：JVM的内存消耗，一次性回收所有垃圾对象
• 手动回收机制：使用System.gc（）；通知JVM执行垃圾回收

（二）包装类

• 基本数据类型所对应的引用类型

• Object可同意所有数据，包装类的默认值是null

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

装箱和拆箱

• 类型转换与装箱、拆箱
  • 栈——》堆：装箱
  • 堆——》栈：拆箱

类型转换

• 装箱：基本类型转换成引用类型的过程

  //装箱
  int nul = 18；
  //使用Integer类创建对象
  Integer integer = new Integer（numl）；
  
  //拆箱
  
  
  

• 拆箱：引用类型转换成基本类型

  //拆箱
  Integer integer = new Integer（100）；
  int num2 = integer.intValue();
  

• 自动装箱和拆箱

  //自动装箱
  int age = 10;
  Integer integer = age;
  //自动拆箱
  int age2 = integer;
  

• 基本类型和字符串之间的转换

  int n1 = 100;
  //基本类型转换成字符串
  //1、使用+号
  String s1 = n1 + “ ”；
  //使用Integer类中的toString方法
  String s2 = Integer.toString(n1);
  String s2 = Integer.toString(n1,16);//把n1转换成16进制的数返回
  			Integer.toBinaryString(int i)
  			
  //字符串转换成基本类型
  String str = "150";
  //使用Integer.parseXXX();
  int n2 = Integer.parseInt(str);
  
  //字符串“boolean”转换成基本类型，“true”——》true，非“true”——》false
  String str2 = "true";
  boolean b1 = Boolean.paraseBoolean(str2);
  
  
  

• 总结

  • 八种包装类提供了不同类型之间的转换方法：
    • Number父类中提供了6个共性方法
    • parseXXX（）静态方法
    • valueOf（）静态方法
  • 需要保证类型兼容，否则抛出NumberFormatException异常

• Integer整数缓冲区

  //
  //栈空间中存储的是在堆空间中的地址信息，因为是开辟的不同的堆空间，所以integer1和integer2中存储的内容是不一样的
  Integer integer1 = new Integer(100);		//构造方法
  Integer integer2 = new Integer(100);
  System.out.println(integer1 == integer2);	//false
  
  //
  //
  Integer integer3 = 100;			//自动装箱机制，使用Integer.valueOf(100)
  Integer integer4 = 100;
  System.out.println(integer3 == integer4);	//true		-128——127
  
  
  Integer integer5 = 200;			//自动装箱机制
  Integer integer6 = 200;
  System.out.println(integer3 == integer4);	//false
  
  
  //在堆里面有一个数组，保存了-128——127之间的数，如果是在这之间的数值，那么久直接把这个数值在堆中数组的位置传给栈中的变量，所以在这之间的数的地址值是一样的，指向的都是同一块堆空间的的一个地址，如果没在这个范围内，那么就会另外创建
  

• 整数缓冲区

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

（三）String类

性质

• 字符串是常量，创建之后不可改变

  String name = "hello";	//“hello”常量存储在字符串池中
  name = "zhangsan";
  String name2 = "zhangsan";
  

  给字符串重新赋值的时候并没有修改源数据，而是重新开辟一个空间——不可变性

  当重新给name进行赋值的时候，并不会吧原先的“hello”清空，而是在字符串池里面重新开辟一个空间来存储“张三”，，然后“hello”就变成了垃圾，当触发垃圾回收的时候就会回收“hello”。

  当重新定义一个字符串变量name2的时候，如果新字符串被赋值已经在字符串池中存在，那么name2就指向之前已经存在的那片区域，而不会重新再开辟空间。

• 字符串字面值存储在字符串池中，可以共享

• 创建

  • String s = “hello”；产生一个对象，字符串池中存储
  • String s = new String（“Hello”）；产生两个对象，堆、池各存储一个；这种情况会浪费空间

  //字符串的另一种创建方法
  String str = new String("Java");
  String str2 = new String("Java");
  System.out.println(str==str2);				//false
  //字符串比较正确的方式
  System.out.println(str.equals(str2));		//true，比较的不是地址，而是数据
  

常用方法

length（）

public int length（）：		//返回字符串长度

charAt（）

public char charArt(int index);		//根据下标获取数据

contains（）

public boolean contains(String str);		//判断当前字符串中是否包含str

toCharArray()

public char[] toCharArray();				//将字符串转换成数组

indexOf（String str）

public int indexOf(String str);				//查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1；

lastIndexOf（String str）

public int lastIndexOf(String str);			//查找字符串在当前字符串中的位置

trim

public String trim();			//去掉字符串前后的空格

toUpperCase()

public String toUpperCase();		//将小写转换成大写

endWith（）

public boolean endWith(String str);				//判断字符串是否以str结尾

replace（）

public String replace(char oldChar, char newChar);			//将旧字符串替换成新的字符串

split（）

public String[] split(String str);			//根据str做拆分，对字符串进行拆分

String str = "java is the best programing language,java xiang";
String[] arr = str.split("[ ,]");//用“ ”和“，”来进行分割		str.split("[ ,]+")
System.out.println(arr.length);
for(String string:arr){
    System.out.println(string);
}

equals（）和compare（）比较

String s1 = "hello";
String s2 = "HELLO";

String content = "java 是世界上最好的编程语言";
System.out.println(content.length());
System.out.println(content.charAt(content.length()-1));
System.out.println(content.contains("java"));
System.out.println(content.contains("php"));
s1.equals(s2)		//false
s1.equalsIgnorseCase(s2)		//false
    
String s3 = "abc";	//a	97
String s4 = "xyz";	//x	120
s3.compareTo(s4);	//-23

String s5 = "abc";	//长度是3
String s6 = "abcxyz";	//长度是6
s5.compareTo(s6);	//-3

StringBuffer

• StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全

StringBuilder

• 可变长字符串，JDK5.0提供，运行效率快、线程不安全。

• 和String的区别：

  • 效率比String高
  • 比String节省内存

  StringBuffer sb = new StringBuffer();
  
  //append（）
  sb.append("java 世界第一");
  sb.append("java 不错");
  
  //insert()
  sb.insert(0,"我在最前面");
  
  //replace(),可以指定位置，在哪里开始，在哪里结束
  sb.replace(0,4,"hello");		//包含头，不包含尾巴
  
  //delete()
  sb.delete(0,5);
  System.out.println(sb.toString);
  
  //清空
  sb.delete(0,sb.length());
  
  

BigDecimal

• 在很多实际应用中需要精确运算，而double是近似值存储，不符合要求，需要借助BigDecimal

BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法
BigDecimal r1 = bd1.subtract(bd2);

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

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

//除法
new BigDecimal("1.4")
	.subtract(new BigDecimal("0.5"))
	.divide(new BigDecimal("0.9"));

BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BIgDecimal.ROUND_HALF_UP);

• 除法
  • devide(BigDecimal bd, int scal, RoundingMode mode)
  • 参数scal：指定精确到小数点后几位
  • 参数mode
    • 指定小数部分的取舍模式，通常采用四舍五入的模式
    • 取值为BigDecimal，ROUND_HALF_UP

Date

• Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。
• 时间单位
  • 1秒 = 1000毫秒；
  • 1毫秒 = 1000微妙
  • 1微妙 = 1000纳秒

//1创建Date对象
//今天
Date date1 = new Date();
System.out.println(date1.toString());
System.out.println(date1.toLocaleString());

//昨天
Date date2 = new Date(date1.getTime()-(60*60*24*1000));

//after before
boolean b1 = date1.after(date2);
boolean b2 = date1.before(date2);

//比较compareTo
date1.compareTo(date2)

Calendar

• Calendar提供了获取或设置各种日历字段的方法

• 构造方法

  • protected Calendar（）：由于修饰符是protected，所以无法直接创建该对象

• 其他方法

  方法名	说明
  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-Calendar
  Date getTime（）	返回一个Date表示此日历的时间。Calendar-Date
  void add（int field，int amount）	按照你离得规则，给指定字段天骄或减少时间量
  long getTimeInMillies()	毫秒为单位，返回该日历的时间值

  //创建Calendar对象
  Calendar calendar = Calendar.getInstance();
  
  //获取时间信息
  //获取年
  int year = calendar.get(Calendar.YEAR);
  //月 0-11
  int mounth = calendar.get(Calendar.MOUNTH);
  //日
  int day = Calendar.get(Calendar.DAY_OF_MOUNTH);
  //小时,HOURSE12小时，HOUR_OF_DAY24小时
  int hour = calendar.get(Calendar.HOUR_OF_DAY);
  //分钟
  int minute = calendar.get(Calendar.MINUTE);
  //秒
  int second = calendar.get(Calendar.SECOND);
  //修改时间
  Calendar caleddar2 = Calendar.getInstance();
  claendar2.set(Calendar.DAY_OF_MONTH,5);
  
  //add方法修改时间
  calendar2.add(Calendar.HOUR,1);//添加1小时
  
  //补充方法
  int max = calendar.getActualMaximun(Calendar.DAY_OF_MONTH);
  int min = calendar.getActualMinimun(Calendar.DAY_OF_MONTH);
  
  

SimpleDateFormate

• SimpleDateFormate是一个与语言环境有关的方式来格式化和解析日期的具体类

• 进行格式化（日期-》文本）、解析（文本-》日期）。

• 常用的时间模式

  字母	日期或时间	实示例
  y	年	2019
  M	年中月份	08
  d	月中天数	10
  H	1天中小时数（0-23）	22
  m	分钟	16
  s	秒	59
  S	毫秒	367

• 代码

//创建SimpleDateFormat对象y年M月
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年M月dd日HHmm:ss");
//创建Date
Date date = new Date();
//格式化date(把日期转换成字符串)
String str = sdf.format(date);
//解析（把字符串转成日期）
Date date2 = sdf.parse("1990/05/01")

Systeml

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

• 方法

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

  //arraycopy
  //src：原数组；	srcPos:从哪个位置开始复制，0
  //dest:目标数组；destPos：目标数组的位置
  //length:复制长度
  int[] arr = {2.,18,15,8,35,26,45,90};
  int[] dest = new int[8];
  System.arraycopy(arr,0,dest,0,arr.length);
  
  //可以用来计算程序运行的时间
  System.out.println(System.currentTimeMillis());
  long start = System.currentTimeMills();
  ...
  long end = System.currentTimeMills();