10种常用类

1、内部类

顾名思义，内部类是定义在一个类里面的类。

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

• 成员内部类：定义在外部类里面的普通类

  class Outer{
      class Inner{
      }
  }
  

• 静态内部类：定义在外部类里面的静态类，跟外部类同级

  class Outer{
      static class Inner{
      }
  }
  

• 局部内部类：定义在方法里面的普通类,不能加任何访问修饰符

  class Outer{
      public void show(){
          class Inner{
          }
      }
  }
  

• 匿名内部类：无名称的局部内部类，代码量少，可读性较差

  class Outer{
      public void show(){}
  }
  Outer outer = new outer(){
      @Override
      public void show(){}
  }
  

2、Object类

Object类是超类，是所有类直接或间接的父类，可以存储任何对象。

• getClass方法：返回引用中存储的实际对象类型
• hashCode方法：返回该对象的哈希码值
• toString方法：返回该对象的字符串表示，可重写
• equals方法：默认实现为（this == obj），比较两个对象地址是否相等，可重写
• finalize方法：当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
• clone方法：实现浅拷贝
• wait方法：多线程中使用，让当前线程进入等待状态，同时释放当前线程持有的锁。
• notify方法：多线程中使用，唤醒该对象等待的某个线程
• notifyAll方法：多线程中使用，唤醒该对象等待的所有线程

3、包装类

基本数据类型所对应的引用数据类型，可实现自动装箱和自动拆箱。

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

• 自动装箱、自动拆箱

int age = 10;
Integer integer1 = age;  //自动装箱，等同于Integer.valueOf(age)
int age2 = integer1;  //自动拆箱，等同于integer1.intValue(integer1)

• Integer缓冲区(-128~127)

Integer int1 = new Integer(100);
Integer int2 = new Integer(100);
int1 == int2;  //false

Integer int3 = 100;  //自动装箱，等同于Integer.valueOf(100)
Integer int4 = 100;
int3 == int4;  //true

Integer int5 = 200;  //大于127，超出缓冲区，等同于new Integer(200)
Integer int6 = 200;
int5 == int6;  //false

4、String类

字符串是常量，创建之后不可改变；字符串字面值存储在字符串池中，可以共享。

String name1 = "aa";  //在字符串池开辟新空间
name1 = "bb";  //此时并非改变了字符串的值，而是在字符串池开辟了新的空间
String name2 = "bb";  //字符串池中存在bb，指向该字符串，未开辟新空间

• 字符串new创建方式

  String str1 = new String("aa");
  String str2 = new String("aa");
  str1 == str2;  //false，两个不同对象
  str1.equals(str2);  //true，equals比较的是值，两个对象值相等，故为true
  

• 字符串常用方法

  String str = "java";
  //1、int length()方法，返回字符串的长度
  str.length();   //4
  
  //2、char charAt(int index)方法，返回对应下标位置的字符
  str.charAt(2);  //v
  
  //3、boolean contains(String str)方法，返回是否包含str字符串
  str.contains("jav");  //true
  str.contains("jjj");  //false
  
  //4、char[] toCharArray()方法，将字符串转换成数组
  Arrays.toString(str.toCharArray());  //[j,a,v,a]
  
  //5、int indexOf()方法，返回子字符串首次出现的位置
  str.indexOf("ja");  //0
  
  //6、int indexOf(char ch)方法，返回子字符串最后一次出现的位置
  str.lastIndexOf("a");  //3
  
  //7、String trim()方法，去掉字符串的前后空格
  String str2 = "   aaa   ";
  str2.trim();  //aaa
  
  //8、String toUpperCase()方法，把小写转成大写，toLowerCase()把大写转成小写
  str2.toUpperCase();  //AAA
  str2.toLowerCase();  //aaa
  
  //9、boolean endWith(str)方法，判断是否以str结尾
  str.endWith("va");  //true
  str.startsWith("ja");  //true
  
  //10、String replace(String old, String new)方法，用新的字符串替换旧字符串
  str.replace("java", "php");  //php
  
  //11、split()方法，对字符串进行拆分
  String str3 = "a b c d";
  String[] arr = str3.split(" ");  //[a,b,c,d]
  String str4 = "a b,c d";
  String[] arr2 = str4.split("[ ,]");  //[a,b,c,d]
  
  //12、equals()、compareTo()方法,比较大小
  String s1 = "hello";
  String s2 = "HELLO";
  s1.equals(s2);  //false
  s1.equals(s2,equalsIgnoreCase);  //true，忽略大小写
  
  s1.compareTo(s2);  //32，输出两个字符串第一个不相等的字符相差的ascii码值
  String s3 = "hello";
  String s4 = "helloaa";
  s3.compareTo(s4);  //-2，两个字符串前缀相等，输出两个字符串的长度差
  
  

5、StringBuffer类和StringBuilder类

StringBuffer(使用缓冲区)

可变长字符串，JDK1.0提供，线程安全，运行效率较低。

StringBuilder(使用缓冲区)

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

与String区别：(1)比String效率高；(2)比String节省内存

• StringBuffer常用方法(StringBuilder与StringBuffer方法一样)

  StringBuffer sb = new StringBuffer();
  //1、append();追加
  sb.append("aaa");  
  sb.toString();  //aaa
  
  //2、insert();添加
  sb.insert(0,"bb");
  sb.toString();  //bbaaa
  
  //3、replace();替换，可指定位置,左闭右开
  sb.replace(0,3,"hello");
  sb.toString();  //helloaa
  
  //4、delete();删除
  sb.delete(0,5);
  sb.toString();  //aa
  //清空: delete(0,sb.length());
  
  //5、reverse();反转
  sb.append("bb");  //aabb
  sb.reverse();  //bbaa
  

6、BigDecimal类

精确计算浮点数

• 浮点数减法

  //new的时候要使用字符串，若使用数字的话可能会跟double一样有误差
  BigDecimal bd1 = new BigDecimal("1.0");
  BigDecimal bd2 = new BigDecimal("0.9");
  //减法
  bd1.subtract(bd2);  //0.1，bd1的值减去bd2的值
  
  //加法
  bd1.add(bd2);  //1.9
  
  //乘法
  bd1.multiply(bd2);  //0.90
  
  //除法
  bd2.divide(bd1);  //0.9
  /*除不尽时会报错，要使用重载的方法
  divide(BigDecimal bd,int scal,RoundingMode mode)
  参数scal:指定精确到小数点后几位
  参数mode:指定小数部分的取舍模式，通常采用四舍五入的模式ROUND_HALF_UP
  */
  

7、Date类

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

//创建对象
Date date1 = new Date();  
date1.toString();  //返回当前时间
date1.toLocaleString();  //返回当前时间，格式为年-月-日 时-分-秒
Date date2 = new Date(date1.getTime()-(24*60*60*1000)); //返回昨天的当前时间
//getTime()返回从1970年1月1日0时0分0秒（历元）至今的毫秒数

//方法after、before
boolean b1 = date1.after(date2);  //true
boolean b2 = date1.after(date2);  //false

//比较毫秒值compareTo()
date1.compareTo(date2);  //1
date2.compareTo(date1);  //-1

//equals()比较是否相等
date1.equals(date2);  //false

8、Calendar类

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

构造方法：protected Calendar()；由于修饰符是protected，所以无法直接创建对象。

//1、创建Calendar对象
Calendar calendar = Calendar.getInstance();
calendar.getTime().toLocaleString();  //获取当前时间

//2、获取时间信息
//年
int year = calendar.get(Calendar.YEAR);
//月 从0开始到11
int month = calendar.get(Calendar.MONTH);
//日
int day = calendar.get(Calendar.DAY_OF_MONTH);
//时，HOUR12小时，HOUR_OF_DAY24小时
int hour = calendar.get(Calendar.HOUR_OF_DAY);
//分
int minute = calendar.get(Calendar.MINUTE);
//秒
int second = calendar.get(Calendar.SECOND);

//3、set方法修改时间
calendar.getInstance.set(Calendar.DAY_OF_MONTH,5);  //将当前日期改为5日

//4、add方法修改时间
calendar.add(Calendar.HOUR,1);  //加1小时
calendar.add(Calendar.HOUR,-1);  //减1小时

/*5、getActualMaximum方法获取给定日历字段的可能最大值
     getActualMaximin方法获取给定日历字段的可能最小值
*/
getActualMaximum（Calendar.DAY_OF_MONTH);  //获取对应月份有多少天
getActualMaximin（Calendar.DAY_OF_MONTH);  //获取对应月份的最小天数，一般为1

9、SimpleDateFormat类

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

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

字符对应的含义：
yyyy：年
MM：月
dd：日
hh：1~12小时制(1-12)
HH：24小时制(0-23)
mm：分
ss：秒
S：毫秒
E：星期几
D：一年中的第几天
F：一月中的第几个星期(会把这个月总共过的天数除以7)(不靠谱)
w：一年中的第几个星期
W：一月中的第几星期(会根据实际情况来算)
a：上下午标识
k：和HH差不多，表示一天24小时制(1-24)。
K：和hh差不多，表示一天12小时制(0-11)。
z：表示时区
这些字母(不被单引号包围的)会被特殊处理替换为对应的日期时间

//1、创建SimpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat sdf1 = new SimpleDateFormat("W");

//2、创建Date
Date date = new Date();

//3、格式化date(把日期转成字符串)
String str = sdf.format(date);
System.out.println(str);  //输出sdf对应格式的时间
String str1 = sdf1.format(date);
System.out.println(str1);  //sdf1对应格式，输出当前时间为一个月中的第几个星期

//4、解析(把字符串转成日期)
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd");
Date date2 = sdf2.parse("1999/01/01");  //parse方法要try-catch捕获异常
System.out.println(date2);  //输出日期

10、System类

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

/*1、arraycopy(src,srcPos,dest,destPos,length)方法,用于复制数组
	该方法有native修饰符，即由JVM实现，使用C/C++算法，执行效率高
    src,源数组
    srcPos，从哪个位置开始复制
    dest，目标数组
    destPos，目标数组的位置
    length，复制的长度
*/
int[] arr = {1,2,4,5,7,3,2,8};
int[] dest = new int[8];
//从0位置开始将arr复制到dest
System.arraycopy(arr,0,dest,0,arr.length);  
//Arrays.copyOf(original,newLength),内部使用的是System.arraycopy()

/*2、System.currentTimeMillis()方法，获取当前时间离1970年1月1日的毫秒数
	一般用于计算程序执行时间，由执行后的时间减去执行前的时间得到执行时间
*/
long start = System.currentTimeMillis();
for(int i = 0; i < 99; i++){
    int j = 2 ** i;
}
long end = System.currentTimeMillis();
System.out.println(end - start);

//3、System.gc()方法，告诉垃圾回收器回收垃圾

//4、System.exit()方法，退出JVM
System.exit(0);  //0参数表示正常退出
System.out.println("hello");  //已经退出JVM，该语句不执行