内部类和常用类

1、内部类

• 成员内部类 - 直接将一个类的定义放在另外一个类的类体中。
• 静态内部类 - 使用static关键字修饰的内部类，隶属于类层级。
• 局部内部类 - 直接将一个类的定义放在方法体的内部时。
• 匿名内部类 - 就是指没有名字的内部类。本质:其实是继承该类或者实现接口的子类匿名对象。

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

作用：数据安全。如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这样我们就无法通过创建对象的途径来访问，想要访问只需要在外部类中定义一个public修饰的方法，间接调用。这样做的好处就是，我们可以在这个public方法中增加一些判断语句，起到数据安全的作用。

2、0bject类

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

3、Object类的常用方法

getClass方法：

package com.xuchong;
/*Object*/
public class Demo1 {
    
    
    public static void main(String[] args) {
    
    
        Object o =new Object();
        System.out.println(o.getClass());
    }
}

hashCode方法：

package com.xuchong;
/*Object*/
public class Demo1 {
    
    
    public static void main(String[] args) {
    
    
        Object o =new Object();
        Object o1 =new Object();
        System.out.println(o.hashCode()==o.hashCode());
        System.out.println(o.hashCode()==o1.hashCode());
        System.out.println(o.hashCode());
        System.out.println(o1.hashCode());
    }
}

toString方法：

package com.xuchong;
/*Object*/
public class Demo1 {
    
    
    public static void main(String[] args) {
    
    
        Object o =new Object();
        System.out.println(o.toString());
        System.out.println(o.toString());
    }
}

equals方法：

package com.xuchong;

import java.util.ArrayList;

/*Object*/
public class Demo1 {
    
    
    public static void main(String[] args) {
    
    
        int[] a={
    
    1,2,3};
        int[] b={
    
    4,5,6};
        System.out.println(a.equals(b));

    }
}

finalize方法：

System.gc();//手动回收

垃圾对象：没有有效引用指向此对象，释放数据存储空间。

垃圾回收。

4、包装类

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

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

装箱与拆箱

拆箱：Number、Value0f()
装箱：构造

package com.xuchong;
/*装箱、拆箱*/
public class Demo2 {
      
      
    public static void main(String[] args) {
      
      
        //装箱
        int a=5;
        Number integer=new Integer(a);
        Integer of = Integer.valueOf(a);
        //拆箱
        int i = integer.intValue();
        int intValue = of.intValue();
        System.out.println(integer);
        System.out.println(i==intValue);
        System.out.println(i);
        System.out.println(a==i);
        System.out.println(integer.equals(i));
        System.out.println(integer==of);
        //JDK1.5之前是这样装箱拆箱的
        //自动装箱
        int b=10;
        Integer c=b;
        //自动拆箱
        int d=c;
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

基本类型和字符串的转换

parseInt（）：实现基本类型和字符串的转换

package com.xuchong;
/*基本类型和字符串的转换*/
public class Demo2 {
    
    
    public static void main(String[] args) {
    
    
        //基本类型转换成字符串
        int n1=100;
        String s= n1+"5";
        String s1 =Integer.toString(n1);
        System.out.println(s);
        System.out.println(s1);
        //字符串转换成基本类型
        int i1 = Integer.parseInt(s);
        System.out.println(i1);
        //boolean类型转化成字符串zhuab
        String s2="true";
        String s3="t";
        boolean b2 = Boolean.parseBoolean(s3);
        boolean b1 = Boolean.parseBoolean(s2);
        System.out.println(b1);
        System.out.println(b2);
        //转换成16进制
         String hex = Integer.toHexString(bytes[i] & 0xFF);
         stringBuffer.append(hex).append(" ");
    }
}

整数缓冲区

package com.xuchong;
/*装箱、拆箱*/
public class Demo2 {
    
    
    public static void main(String[] args) {
    
    
        //面试题
        Integer integer=new Integer(100);
        Integer integer1=new Integer(100);
        System.out.println(integer==integer1);

        Integer integer2=Integer.valueOf(100);//自动装箱ValueOf方法 边界：-128~127
        System.out.println(integer==integer2);
        Integer integer3=100;
        System.out.println(integer2==integer3);
        Integer integer4=200;
        Integer integer5=200;
        System.out.println(integer4==integer5);
    }
}

5、String类

字符串是常量，创建之后不可改变。不是改变值，而是重新开辟一片空间。
字符串字面值存储在字符串池中，可以共享。在方法区中。

package com.xuchong;

import java.util.ArrayList;

/*Object*/
public class Demo1 {
    
    
    public static void main(String[] args) {
    
    
        String s ="hello";//存在方法区中
        s="BYE";// 不是改变值，而是重新开辟一片空间 "hello"成垃圾
        String s1="BYE";
        String s2=new String("bye");//堆里面和方法区各有一个 这时候指向堆里面 运行时会合成一个 浪费空间
        String s3=new String("bye");
        System.out.println("s和s1的位置比较:"+(s==s1));
        System.out.println("s2和s3的位置比较:"+(s2==s3));
        System.out.println(s);
    }
}

基本类型比较用**，比较的是他们的值**。默认下，对象用**比较时，比较的是内存地址**，如果需要比较对象内容，需要重写equal方法。
如果两个对象根据equal()方法比较相等，那么调用这两个对象中任意一个对象的hashCode()方法必须产生相同的哈希值。
如果两个对象根据eqaul()方法比较不相等，那么产生的**哈希值不一定相等(**碰撞的情况下还是会相等的。)
hashCode是用于查找使用的，而equals是用于比较两个对象的是否相等的

常用方法：

package com.xuchong;

import java.util.Arrays;

public class Demo3 {
    
    
    public static void main(String[] args) {
    
    
        String s ="无敌最俊朗 无  ";//存在方法区中 空格也算
        System.out.println("长度:"+s.length());
        System.out.println("首个字符:"+s.charAt(0));
        System.out.println("最后一个字符:"+s.charAt(s.length()-1));
        System.out.println(s.contains("无敌"));//判断字符串是否存在字符串s中
        char[] chars = s.toCharArray();//不能修改
        System.out.println(Arrays.toString(chars));//以数组的形式输出
        String s1 = String.valueOf(chars);
        System.out.println(s1);
        System.out.println(s.indexOf("最"));//查找
        System.out.println(s.indexOf("无",3));//从3的位置开始找无
        System.out.println(s.lastIndexOf("无"));//返回指定子字符串在此字符串中最右边出现处的索引，如果此字符串中没有这样的字符，则返回-1。
        //lastIndexOf(String str, int fromIndex): //返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索，如果此字符串中没有这样的字符，则返回 -1。
        String trim = s.trim();//去除前后空格
        System.out.println("去掉空格的长度:"+trim.length());
        s.toUpperCase();//小写转大写
        s.toLowerCase();//大写转小写
        System.out.println(s.endsWith("无"));//用于测 试字符串是否以指定的后缀结束
        System.out.println(s.startsWith("shi"));
        String replace = s.replace("最", "且");//替换
        System.out.println(replace);
        String[] split = s.split("最");//拆分
        for (String s2 : split) {
    
    
            System.out.println(s2);
        }
        int i = s.compareTo(s);//比较在编码表中的顺序  有时候比较长度
        System.out.println(i);
        s.equalsIgnoreCase(s);//不区分大小写
        s.subString();//返回字符串的子字符串
    }
}

可变字符串：

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

package com.xuchong;
/*StringBuffer StringBuilder
* 和String区别:效率快、节省内存*/
public class Demo4 {
    
    
    public static void main(String[] args) {
    
    
        StringBuffer stringBuffer=new StringBuffer();
        //追加
        stringBuffer.append("我是世界第一");
        System.out.println(stringBuffer);
        stringBuffer.append("无敌且俊朗");
        System.out.println(stringBuffer);
        //添加
        stringBuffer.insert(6,"徐冲");
        System.out.println(stringBuffer);
        //replace
        stringBuffer.replace(0,1,"徐冲");//含头不含尾
        System.out.println(stringBuffer);
        //delete
        stringBuffer.delete(7,9);
        System.out.println(stringBuffer);
        //clear
        stringBuffer.delete(0,stringBuffer.length());
        System.out.println(stringBuffer.length());
        //反转
        StringBuffer replace = stringBuffer.reverse();
        System.out.println(replace);
    }
}

6、BigDecimal类

package com.xuchong;

public class Demo5 {
    
    
    public static void main(String[] args) {
    
    
        double a=1.0;
        double b=0.9;
        System.out.println(a-b);
        double c=1.4;
        double d=0.5;
        System.out.println((c-d)/0.9);
    }
}

原因：在double和float类型的存储都是近似值。

BigDecimal概述：

位置：java.math包中
作用：精确计算浮点数
DecimalFormat

java.text.DecimalFormat是一个用于对数值类型数据格式化处理的类，该类从java.text.NumberFormat类继承，里面提供了一些用于将数值类型表示为不同格式字符串转换方法(货币，百分比，千分数等)；

package com.xuchong;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.math.BigDecimal;

public class Demo5 {
    
    
    public static void main(String[] args) {
    
    
        //BigDecimal,大型浮点数计算
        BigDecimal b1=new BigDecimal("1.0");
        BigDecimal b2=new BigDecimal("0.9");
        BigDecimal b3 = b1.subtract(b2);//减法
        System.out.println(b3);
        BigDecimal b4 = b1.add(b2);//加法
        System.out.println(b4);
        BigDecimal b5 = b1.multiply(b2);//乘法
        System.out.println(b5);
        BigDecimal b6 = b3.divide(b3);//除法
        System.out.println(b6);
        BigDecimal divide = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));//除法
        System.out.println(divide);
        BigDecimal divide1 = new BigDecimal("1.5")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.3"),3,BigDecimal.ROUND_HALF_UP);
        //除法 保留小数 BigDecimal.ROUND_HALF_UP:四舍五入
        System.out.println(divide1);
    }
}

7、Date类

package com.xuchong;

import java.util.Date;

/*Date*/
public class Demo6 {
    
    
    public static void main(String[] args) {
    
    
        Date date =new Date();
        System.out.println(date.toLocaleString());
        Date date1=new Date(date.getTime()-60*60*24*1000);
        System.out.println(date1.toLocaleString());
        //方法
        System.out.println(date1.after(date));
        System.out.println(date1.before(date));
        //比较
        System.out.println(date.compareTo(date1));
        //equals
        System.out.println(date.equals(date));
    }
}

8、Calendar类

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

构造方法：protected Calendar（）；

package com.xuchong;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.util.Calendar;
import java.util.Date;

/*Calendar*/
public class Demo6 {
    
    
    public static void main(String[] args) {
    
    
        //创建对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        //获取时间信息
        int year=calendar.get(Calendar.YEAR);//获取年
        System.out.println(year);
        int mouth=calendar.get(Calendar.MONTH);//0-11
        System.out.println(mouth);
        int day=calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        int hour=calendar.get(Calendar.HOUR_OF_DAY);
        System.out.println(hour);
        int minute = calendar.get(Calendar.MINUTE);
        System.out.println(minute);
        int second= calendar.get(Calendar.SECOND);
        System.out.println(second);
        //修改时间
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH,10);
        System.out.println(calendar1.get(Calendar.DAY_OF_MONTH));
        //add方法
        calendar1.add(Calendar.HOUR_OF_DAY,2);
        System.out.println(calendar1.get(Calendar.HOUR_OF_DAY));
        System.out.println(calendar1.getTime().toLocaleString());
        //获取当前的最大值
        System.out.println(calendar1.getActualMaximum(Calendar.DAY_OF_MONTH));
    }
}

9、SimpleDateFormat类

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

package com.xuchong;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.jar.JarOutputStream;

/*SimpleDateFormat*/
public class Demo6 {
    
    
    public static void main(String[] args) throws ParseException {
    
    
        //创建对象
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        //创建时间
        Date date = new Date();
        //格式化
        String format = simpleDateFormat.format(date);
        System.out.println(format);
        //解析
        Date date1 = simpleDateFormat.parse("2017-12-30");
        System.out.println(date1.toLocaleString());
    }
}

10、System类

System 类提供了以下功能：

标准输入，标准输出和错误输出流；
访问外部定义的属性和环境变量；
加载文件和库的方法；
以及用于快速复制数组的实用方法。

System 类不能被实例化，只可以使用其静态方法。

常用方法

public static void arraycopy(Object src,int srcPos, Object dest,int desPos,int length): 从指定的源数组中复制一个数组，从源数组指定的位置开始，到目标数组指定的位置。
public static long currentTimeMillis(): 返回以毫秒为单位的当前时间(从1970年到现在的毫秒数)。
public static void exit(int status): 终止当前正在运行的Java虚拟机，status为 0时退出。
public static void gc(): 运行垃圾收集器。
public static Properties getProperties(): 取得当前系统的全部属性。
public static String getProperty(String key): 获取指定键的系统属性。

import java.util.Arrays;

public class SystemDemo {
    
    
    public static void main(String[] args) {
    
    
        int[] a = {
    
    7, 8, 9, 10, 11};
        int[] b = {
    
    1, 2, 3, 4, 5, 6};
        //从数组a的第二个元素开始，复制到b数组的第三个位置 复制的元素长度为3
        System.arraycopy(a, 1, b, 2, 3);
        //输出结果
        System.out.println(Arrays.toString(b));
        System.out.println("当前时间：" + System.currentTimeMillis());
        System.out.println("java版本信息：" + System.getProperty("java.version"));
        //运行垃圾收集器
        System.gc();
        //退出
        System.exit(0);
    }
}/* 打印：
[1, 2, 8, 9, 10, 6]
当前时间：1544670501472 */

11、java.util.Arrays类

Arrays 类包含用于操作数组的各种方法（例如排序和搜索）。还包含一个静态工厂，允许将数组转为 List。

常用方法

List asList(T... a): 返回由指定数组构造的 List 。
void sort(Object[] a): 对数组进行排序
void fill(Object[] a, Object val): 为数组的所有元素都赋上相同的值
boolean equals(Object[] a, Object[] a2): 检查两个数组是否相等
int binarySearch(Object[] a, Object key): 对排序后的数组使用二分法查找数据

import java.util.Arrays;
import java.util.Random;

public class ArraysDemo {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = new int[10];
        //将数组元素都设为9
        Arrays.fill(arr, 9);
        System.out.println("fill:" + Arrays.toString(arr));
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
    
    
            //使用100以内的随机数赋值数组
            arr[i] = random.nextInt(101);
        }
        //重新赋值后的数组
        System.out.println("重新赋值：" + Arrays.toString(arr));
        //将索引为5的元素设为50
        arr[5] = 50;
        //排序
        Arrays.sort(arr);
        //排序后的数组
        System.out.println("sort排序后：" + Arrays.toString(arr));
        //查找50的位置
        int i = Arrays.binarySearch(arr, 50);
        System.out.println("值为50的元素索引："+i);
        //复制一份新数组
        int[] newArr = Arrays.copyOf(arr, arr.length);
        //比较
        System.out.println("equals:"+Arrays.equals(arr, newArr));
    }
}/* 打印：
fill:[9, 9, 9, 9, 9, 9, 9, 9, 9, 9]
重新赋值：[2, 19, 48, 40, 95, 72, 69, 18, 12, 51]
sort排序后：[2, 12, 18, 19, 40, 48, 50, 51, 69, 95]
值为50的元素索引：6
equals:true  */