常用类

常用类

常用类：

1. 内部类

2. object类

3. object类常用方法

4. 包装类

5. string类

6. BigDecimal类

内部类

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

特点

1. 编译之后可以生成独立的字节码文件

2. 内部类可以直接访问外部类（这个内部类的一层外部）的私有成员，而不破坏封装性

3. 内部类可以为外部内提供必要的内部功能组件

分类：

1. 成员内部类

2. 静态内部类

3. 局部内部类

4. 匿名内部类

成员内部类

1.性质：

1. 在类的内部定义，与实例变量，实例方法同级别的类

2. 成员内部类不能包含静态成员，但能包含静态常量（添加final关键词）

3. 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

//依赖外部类创建内部类
package com.yyl.calss;
//外部类
public class Outer {
    //实例变量
    private String name="adeair";
    private int age=20;
    //内部类
    class Inner{
        private String adress="山东";
        private String phone="1234";
        //方法
        public void show(){
            //打印外部类属性
            System.out.println(name);
            System.out.println(age);
            //打印内部类属性
            System.out.println(adress);
            System.out.println(phone);
        }
    }
}

//依赖外部内创建内部类
package com.yyl.calss;
​
public class TestOuter {
    public static void main(String[] args) {
        //创建一个外部类对象
        Outer outer=new Outer();
        //创建一个内部类对象
        Outer.Inner inner=outer.new Inner();
        //一步到位
        //Outer.Inner inner=new Outer().new Inner();
        inner.show();
    }
}

3. 当外部类和内部类存在重名属性时，会优先访问内部类属性

   //包括如何访问重名的外部类属性
   package com.yyl.calss;
   ​
   //外部类
   public class Outer{
       //实例变量
       private String name="adeair";
       private int age=20;
       //内部类
       class Inner{
           private String adress="山东";
           private String phone="1234";
           private String name="李四";//如果内部类属性名和外部类属性名字相同，加上out.this
           //方法
           public void show(){
               //打印外部类属性
               System.out.println(name);//输出“李四”
               System.out.println(Outer.this.name);//输出“adeair”
               System.out.println(age);
               //打印内部类属性
               System.out.println(adress);
               System.out.println(phone);
           }
       }
   }

   package com.yyl.calss;
   ​
   public class TestOuter {
       public static void main(String[] args) {
           //创建一个外部类对象
           Outer outer=new Outer();
           //创建一个内部类对象
           Outer.Inner inner=outer.new Inner();
           //一步到位
           //Outer.Inner inner=new Outer().new Inner();
           inner.show();
       }
   }

静态内部类

1.性质：

1. 不依赖外部类对象，可以直接创建或者通过类名访问，可声明静态成员

2. 只有内部类才可以用static

3. 相当于外部类

   package com.yyl.class01;
   ​
   public class Outer {
       private String name="adeair";
       private String age="18";
       static class Inner{//静态内部类，和外部类相同
           private String adress="山东";
           private String phone="1234";
           //静态成员
           private static int money=1000;
           public void show(){
               //调用外部类属性
               //首先创建外部类对象
               Outer outer=new Outer();
               //调用外部类对象属性
               System.out.println(outer.name);
               System.out.println(outer.age);
               //调用静态内部类属性和方法
               System.out.println(adress);
               System.out.println(phone);
               //调用静态内部类静态属性
               System.out.println(Inner.money);
           }
       }
   }

   package com.yyl.class01;
   ​
   public class TestOuter {
       public static void main(String[] args) {
           Outer.Inner inner=new Outer.Inner();
           //调用方法
           inner.show();
       }
   }

局部内部类

1.性质

1. 定义在外部类方法内，作用范围和创建对象范围仅限于当前范围

2. 局部内部类前不能加任何访问修饰符（相当于方法成员）

3. 不能包含static成员，但可以包含final static成员（常量）

4. 局部内部类访问外部类当前方法中的局部变量时，因无法保证生命周期与自己相同，变量必须修饰为final

   package com.yyl.class03;
   ​
   public class Outer {
       private String name="刘德华";
       private int age=35;
       public void show(){
           //定义局部变量
           final String adress="山东";//finnal可以省略，jdk1.8默认自动添加final
                                       /*为什么加final
                                       因为函数执行完之后adress变量会消失，
                                       而Inner类和inner对象不会消失，所以
                                       在最后的输出adress时，adress只有声
                                       明为final常量才行（因为常量会在运行时
                                       被替代为对应常量，例如adress被替换为
                                       ”山东“）*/
           //局部内部类不能加访问修饰符
           class Inner{
               private String phone="1234";
               private String email="xxxxx@qq.com";
   ​
               public void show2(){
                   //访问外部类属性
                   System.out.println(Outer.this.name);
                   System.out.println(Outer.this.age);
                   //访问内部类
                   System.out.println(this.phone);
                   System.out.println(this.email);
                   //访问局部变量，jdk1.7要求变量必须是常量
                   //jdk 1.8自动添加final
                   //局部变量不能修改
                   System.out.println(adress);
               }
           }
           //创建局部内部类对象
            Inner inner=new Inner();
           inner.show2();
       }
   }

   package com.yyl.class03;
   ​
   public class TestOuter {
       public static void main(String[] args) {
           //不能直接调用Inner
           //直接调用Outer.show没有输出
           //在class inner外创建局部内部类对象之后可以直接调用函数打印结果
           Outer outer=new Outer();
           outer.show();
   ​
       }
   }

匿名内部类

性质

1. 没有类名的内部类

2. 必须继承一个父类或者实现一个接口

3. 匿名内部类实际上是定义类、实现类、创建对象的语法合并，只能创建一个该类的对象

4. 优点：减少代码量

5. 缺点：可读性差

//接口
package com.yyl.class04;
​
public interface USB {
    void service();
}

//接口的实现（重写接口内的函数）
package com.yyl.class04;
​
public class Mouse implements USB{
    @Override
    public void service() {
        System.out.println("鼠标连接成功...");
    }
}

package com.yyl.class04;
​
public class TestUSB{
    public static void main(String[] args) {
        //创建一个接口类型变量
       /* USB usb=new Mouse();
        usb.service();*/
​
        /*class Fan implements USB{
            @Override
            public void service() {
                System.out.println("风扇成功连接电脑");
            }
        }
        //使用局部内部类创建对象
        USB usb=new Fan();
        usb.service();//创建局部内部类只用一次，浪费
        */
        //使用匿名内部类（相当于创建一个局部内部类）
        USB usb=new USB() {//局部内部类只能创建一个对象
            @Override
            public void service() {
                System.out.println("风扇成功连接电脑");
            }
        };
        usb.service();
    }
}

Object类

1. object类是类层次结构的根类，每个类都使用object作为超类，所有对象（包括数组）都实现这个类的方法

2. 任何类不是直接继承object类就是间接继承

3. object中定义的方法是所有对象都能调用的方法

4. object类型可以储存任何对象，作为参数可以接收任何对象，作为返回值可以返回任何对象

getclass方法

1. public final Class<?> getClass(){} (s1.getClass())

2. 返回引用中存储的实际类型

3. 通常应用于判断两个应用中实际存储对象类型是否一致

    

hashcode()方法

1. public int hash code(){}

2. 返回该对象哈希吗值

3. 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值

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

to String方法

1. public String toString(){}

2. 返回该对象的字符串表示（表现形式）

3. 可根据程序需求，覆盖该方法，如：展示对象各个属性值

equals方法

1. public boolean equals(Object obj){}

2. 默认实现为(this==obj),比较两个对象地址是否相同

3. 可进行覆盖，比较两个对象的内容是否相同

   1. euqals方法覆盖的步骤

   2. 比较两个引用是否指向同一个对象

   3. 判断obj是否为null

   4. 判断两个引用实际指向对象类型是否一致

   5. 强制类型转换

   6. 依次比较各个属性值是否相同

       @Override
       public boolean equals(Object obj) {
           //判断两个对象是否诶同一个引用
           if(this==obj){
               return true;
           }
           //判断obj是否为null
           if(obj==null){
               return false;
           }
           //判断是否为同一个类型
           if(obj instanceof Student){
               //4.强制类型转换
               Student s=(Student)obj;
               //比较属性
               if(this.name.equals(s.getname())&&this.age==s.getAge()){
                   return true;
               }
           }
           return false;
       }
   }

finalize方法

1. 当对象被当做垃圾时，由JVM自动调用这个方法，用以标记垃圾对象，进入回收队列

2. 垃圾对象：没有有效引用指向此对象时，为垃圾对象

3. 垃圾回收：由GC销毁垃圾对象，释放数据储存空间

4. 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象

5. 手动回收机制：使用System.gc();通知JVM执行垃圾回收

包装类

 

1. 包装类对应类型

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

2. 将栈中的基本类型包装在一个对象中，存放到堆中

类型转换与装箱、拆箱

注意：需保证类型兼容，否则抛出NumberFormatException异常

package com.yyl.packetclass;
​
public class Demo01 {
    public static void main(String[] args) {
        //类型转换：装箱，基本类型转换成引用类型
        //基本类型
        int num=18;
        //使用Integer类创建对象
        Integer integer1=new Integer(num);
        Integer integer2=Integer.valueOf(num);
        //类型转换，拆箱，引用类型转化为基本类型
        Integer integer3=new Integer(100);
        int num3=integer3.intValue();
​
        //JDK1.5之后，java提供了自动装箱和拆箱
        //自动装箱
        int num4=10;
        Integer integer4=num;
        //自动拆箱
        int age=integer4;
    }
}

String类型与基本类型转换

package com.yyl.packetclass;
​
public class Demo02 {
    public static void main(String[] args) {
        //基本类型和字符串之间转换
        //1基本类型转化成字符串
        int n1=255;
        //1.1使用+符号
        String s1=n1+"";
        System.out.println(s1);//输出字符串的100
        //1.2使用Integer中的toString方法
        String s2=Integer.toString(n1);
        String s3=Integer.toString(n1,16);//toString方法的重载,以radix进制输出
        System.out.println(s2);//输出字符串的100
        System.out.println(s3);
        //2字符串转化成基本类型
        String str="150";
         //String str="150a"; 抛出异常NumberFormatException
        //使用Integer.parseXXX();
        int num2=Integer.parseInt(str);//str不能有非数字符号
        System.out.println(num2);
​
        //boolean类型字符串转化成基本类型  “true”——>true   非“true”——>false
        String str2="true";
        boolean b1=Boolean.parseBoolean(str2);
        System.out.println(b1);
    }
}

整数缓冲区间

package com.yyl.packetclass;
​
public class Demo03 {
    public static void main(String[] args) {
        //面试题
        Integer integer1=new Integer(100);
        Integer integer2=new Integer(100);
        System.out.println(integer1==integer2);//输出false
        //解释:两个都为引用类型，存放在堆中，而integer1==integer2比较的是栈区的两个地址（指向对象），两者不相等
​
        Integer integer3=100;//自动装箱
        Integer integer4=100;//自动装箱实际调用Integer.valueOf();
        System.out.println(integer3==integer4);//true
        /*原因：查看Integer.valueOf()方法可知：在-128~127的整数在堆中有一个缓冲数组，引用对象如果在-128~127
        * 会直接指向缓冲数组，两个都为100故指向缓冲数组同一个地址*/
​
        Integer integer5=200;//自动装箱
        Integer integer6=200;//自动装箱实际调用Integer.valueOf();方法，
        System.out.println(integer5==integer6);//false
    }
}

String类

1. 字符串是常量，创建后不可以改变

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

3. 字符串池在方法区（常量池）中

4. 给字符串赋值，没有修改数据，而是分配了新的空间

5. String s="hello";

6. String s=new String("hello");//产生两个对象，堆，池中各储存一个

package com.yyl.Stringclass;
​
public class Demo01 {
    public static void main(String[] args) {
        //字符串不可修改性
        String name="deair";//adeair常量存储在字符串池中，name就像一个指向该常量的指针
        name="zhangsan";//在字符串池中开辟新空间存放"zhangsan",name指向zhangsan,hello变为垃圾
        String name2="zhangsan";//没有创建新的空间，将name2指向字符串池中的zhangsan
        String s=new String("java");//在堆，池中开辟空间，将栈中的s指向堆中java
        //实际运行时堆中没有“java”，堆指向常量池
        //面试题
        String s1=new String("hello");
        String s2=new String("hello");
        System.out.println(s1==s2);//false    ==比较数据
        System.out.println(s1.equals(s2));//true  equals比较数据
        //s1,s2指向堆中两个不同空间，堆中两个不同空间指向池中同一常量
​
    }
}

String常用方法

1. public int length();返回字符串长度

2. public char charAt(int index);根据下标获取字符

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

4. public char toCharArray();将字符串转化成数组

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

6. public int indexOf(String str,int fromIndex),从第fromIndex个下标寻找str首次出现的下标

7. public int lastIndexOf(String str);查找字符串在当前字符串中最后一次出现的下标索引

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

9. public String toUpperCase();将小写转化成大写

10. public String toLowerCase();大写转化为小写

11. public boolean endWith/startWith(String str);判断字符是否以str结尾/开始

12. public String replace(char oldChar,char newChar);将旧字符串替换为新字符串（局部某一节替换为另一节）

13. public int compareTo(String s1);从第一个字符开始比较ascII值，返回两个字符的assII的差

14. public String[] split(String str);根据str做拆分

15. 补充：equals,compareTo

public class Demo02 {
    public static void main(String[] args) {
        String say = "java is the best language,java xiang";
        String say2 = "java is the best     language,java xiang";
        String[] arr = say.split("[ ,]");//同时以逗号和空格进行拆分
        for (String string : arr) {
            System.out.println(string);
        }
        String[] arr2 = say.split("[ ,]+");//同时以一个或多个逗号或者空格进行拆分
        for (String string1 : arr2) {
            System.out.println(string1);
        }
        String s5="hello";
        String s6="HELLO";
        System.out.println(s5.equalsIgnoreCase(s5));//不区分大小写比较字符串内容
        String s3="abc";
        String s4="ayz";
        System.out.println(s3.compareTo(s4));//从第一个字符开始比较，返回两个字符的差值
        String s1="abc";
        String s2="abcxyz";
        System.out.println(s1.compareTo(s2));//特殊情况返回两个字符串的长度差
    }
}

案例演示

需求：已知String str="this is a text";

1.将str中的单词获取出来

2.将str中的text替换为practice

3.在text前添加easy

4.将每个单词首字母改为大写

package com.yyl.Stringclass;
​
public class example {
    public static void main(String[] args) {
        String str="this is a text";
        //1.
        String[] str1=str.split(" ");
        for (int i = 0; i < str1.length; i++) {
            System.out.println(str1[i]);
        }
        //2.
        System.out.println(str.replace("text","practice"));
        //3.
        System.out.println(str.replace("text","easy text"));
        //4.
        for(int i=0;i<str1.length;i++){
            char first=str1[i].charAt(0);
            char upperfirst=Character.toUpperCase(first);
            System.out.println(upperfirst+str1[i].substring(1));
            //substring(),从第i个下标截取之后的字符串
        }
    }
}

可变字符串StringBuffer和StringBulider

1. StringBuffer,jdk1.0提供，运行效率慢，线程安全

2. StringBuilder,jdk5.0提供，运行效率快，线程不安全

3. 重要函数

   package com.yyl.Stringclass;
   /**
    *StringBuffer和StringBuilder的使用
    * 和String的区别:1.效率比String高2.比string节省空内存
    *
    * */
   ​
   public class Demo03 {
       public static void main(String[] args) {
           StringBuffer sb=new StringBuffer();
           //1.append，追加
           sb.append("java世界第一");
           System.out.println(sb.toString());
           sb.append("java真香");
           System.out.println(sb.toString());
           sb.append("java不错");
           System.out.println(sb.toString());
           //2.insert,添加
           sb.insert(1,"我在最前面");
           System.out.println(sb.toString());
           //replace,指定对应位置的进行替换左闭右开
           sb.replace(0,5,"hello");
           System.out.println(sb.toString());
           //4.delete,删除
           sb.delete(0,5);
           System.out.println(sb.toString());
           //reverse,反转
           //StringBuilder同样
       }
   }

4. 验证StringBuilder的快速

   package com.yyl.Stringclass;
   //验证StringBulider效率高于String
   public class Demo04 {
       public static void main(String[] args) {
           long start=System.currentTimeMillis();
   /*        String string="";
           for (int i = 0; i < 99999; i++) {
               string+=i;//字符串的拼接，而不是累加
           }
           System.out.println(string);
           long end=System.currentTimeMillis();
           System.out.println("用时"+(end-start));//39396
    */
           StringBuilder sb=new StringBuilder();
           for (int i = 0; i < 99999; i++) {
               sb.append(i);//字符串的拼接，而不是累加
           }
           System.out.println(sb);
           long end=System.currentTimeMillis();
           System.out.println("用时"+(end-start));//27
       }
   }

BigDecimal类

1. double是近似值储存，不准确，借用BigDecimal

   package com.yyl.Big;
   ​
   import java.math.BigDecimal;
   import java.math.RoundingMode;
   ​
   public class Demo01 {
       public static void main(String[] args) {
           //double近似值
           double d1=1.0;
           double d2=0.9;
           System.out.println(d1-d2);
           //面试题
           double d3=(1.4-0.5)/0.9;
           System.out.println(d3);
           //BigDecimal
           BigDecimal bd1=new BigDecimal("1.0");
           BigDecimal bd2=new BigDecimal("0.9");
           //减法
           BigDecimal r1=bd1.subtract(bd2);
           System.out.println(r1);
           //加法
           BigDecimal r2=bd1.add(bd2);
           System.out.println(r2);
           //乘法
           BigDecimal r3=bd1.multiply(bd2);
           System.out.println(r3);
           //除法
           BigDecimal r4=new BigDecimal("1.4")
                   .subtract(new BigDecimal("0.5"))
                   .divide(new BigDecimal("0.9"));
           System.out.println(r4);
           //除不尽，无限循环用重载函数
           /*
           BigDecimal r5=new BigDecimal("10")
                   .divide(new BigDecimal("3"));//ArithmeticException
            */
           BigDecimal r5=new BigDecimal("10")
                   .divide(new BigDecimal("3"),2, RoundingMode.HALF_UP);//舍入模式，四舍五入RoundingMode.HALF_UP
           System.out.println(r5);
       }
   }

Date类

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

2. 时间单位1s=1000ms=1000 000us=1000 000 000ns

public class Date {
    public static void main(String[] args) {
        java.util.Date date1=new java.util.Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        java.util.Date date2=new java.util.Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());
        //方法after，before
        boolean b1=date1.after(date2);
        System.out.println(b1);
        boolean b2=date2.before(date1);
        System.out.println(b2);
        //比较compareTo();比较两者的毫秒值大小,返回二者天数的差值
        int d=date1.compareTo(date2);
        System.out.println(d);
        //eqyals();比较二者时间是否相等
    }
}

Calendar类

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

2. 构造方法：protect Canlendar();由于修饰符是protect，所以无法直接创建该对象

方法名	说明
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 getTimelnMilies()	毫秒为单位返回该日历的时间值

package com.yyl.day;
​
import java.util.Calendar;
​
public class Calendar1 {
    public static void main(String[] args) {
        //创建一个Calendar类
        Calendar calendar=Calendar.getInstance();//用方法代替声明类
        //System.out.println(calendar.toString());//打印信息特别多
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());//
        //获取时间信息
        //获取年
        int year=calendar.get(Calendar.YEAR);
        System.out.println(year);
        int month=calendar.get(Calendar.MONTH);
        System.out.println(month+1);//从0-11
        int date=calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(date);
        int hour=calendar.get(Calendar.HOUR_OF_DAY);
        System.out.println(hour);
        int min=calendar.get(Calendar.MINUTE);
        System.out.println(min);
        int second=calendar.get(Calendar.SECOND);
        System.out.println(second);
        //修改时间
        Calendar calendar2=Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,26);//修改成指定数值
        System.out.println(calendar2.getTime().toLocaleString());
        //4.add方法修改时间
        calendar2.add(Calendar.HOUR,1);//在原基础上加1
        System.out.println(calendar2.getTime().toLocaleString());
​
        //5.补充方法
        int max=calendar2.getMaximum(Calendar.DAY_OF_MONTH);//该月最后一天
        int min1=calendar2.getMinimum(Calendar.DAY_OF_MONTH);//该月第一天
        System.out.println(max);
        System.out.println(min1);
    }
}

SimpleDateFormat

package com.yyl.day;
​
import java.text.SimpleDateFormat;
​
public class simple {
    public static void main(String[] args) {
        //1.创建对象
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");//以不同的形式显示时间
        //创建Date
        Date date=new Date();
        //格式化date(把日期转化成字符串)
        String str = sdf.format(date);
        System.out.println(str);
        //解析：把字符串转化成日期
        Date date2=sdf.parse("1990/05/01");//与上边sdf格式相同
    }
}

System类

1. System系统类，主要用于获取系统的属性数据和其它操作，构造方法私有的，静态的

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