java常用类

java常用类

内部类

1.成员内部类：在一个类的内部定义一个完整的类

例如：外部类public class Body{

内部类class Header{

}

}

内部类可以直接访问外部类的私有成员，而且不破坏封装

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

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

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

Outer outer = new outer();

Inner inner = new Inter();

一步到位： Inner inner = new Outer().new Inner();

inner.show();

当外部类、内部类存在重命名属性时、会优先访问内部类属性 例如（外部类 .this.属性）

成员内部类不能定义静态成员static、但可以定义静态常量final。

private static final String name ="li";

private static String name ="li"; 错误

打印外部类属性时 内部类属性和外部类的名字相同，要想访问外部类属性Outer.this . name

2. 静态内部类

   相当于在成员内部类的基础上 加上一个static关键字 也当相当于外部类

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

   package aa;
   //外部类
   public class Outer {
           private String name = "ww";
           //静态内部类;和外部类相同
           static class Inner{
               private String address="上海";
               private String phone="888";
               //静态成员
               private static String maths = "数学";
               public void show() {
                   //调用外部类的属性
                   //1.先创建外部类对象 
                   Outer outer = new Outer();
                   System.out.print(outer.name);
                   //调用静态内部类属性方法
                   System.out.print(address);
                   //调用静态内部类的静态属性
                   System.out.print(Inner.maths);
               }
   ​
   }
   ​
   }

   只能直接访问外部类的静态成员（实例化成员需实例化外部类对象）

   Outer.Inner inner = new Outer.Inner();

   Outer.Inner.show();

   public class TestOuter {
   public static void main(String[] args) {
       Outer.Inner inner= new Outer. Inner();
       inner.show();
   }
   }

   3.局部内部类 （定义在方法内的）

   package com.jun.li.pritact;
   //外部类
   public class Outer {
       private String name ="刘德华";
       private int age =55;
       public void show() {
           // 定义局部变量、局部变量是不能带修饰符的
           String address = "上海";
           //局部内部类 注意前面不能加任何访问修饰符 
           class Inner{
               //局部内部类的属性
               private String phone="19999999";
               private String email="999999@.qq.com";
               public void show2() {
                   //访问外部类的属性
                   System.out.println(Outer.this.name);
                   System.out.println(Outer.this.age);
                   System.out.println(address);
               }
           }
           步骤(1)  //在此方法内创建内部类对象
           Inner inner = new Inner();
           inner.show2();
       }
   }

   package com.jun.li.pritact;
   public class OuterTest {
       public static void main(String[] args) {
           Outer outer = new Outer();
           outer.show();
           //想运行show方法中的局部内部类 需只能在其方法内创建对象 上步骤 (1) 
   }
   }
   ​
   ​

   局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，

   变量必须修饰为final final String address = "上海";

   有限的范围 当前方法内

   4.匿名内部类（接口 抽象类用的多）

   *没有类名的局部内部类(一切特征都与局部内部类相同)

   *继承一个父类或者实现一个接口常使用

   Usb usb = new Usb(){
       //Usb()可以是父类，抽象类 再重写方法就行
       @Override
       public void service(){
       System.out.println("连接成功");
       
       }
   }；

    

object类

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

任何类、没有写extends继承某个类 都默认继承Object类，否则间接继承

Object类的所定义的方法，是所继承对象都具备的

Object类可以存储任何对象 1.作为参数：接收任何对象

2.作为返回值：可以返回任何对象

 

object类常用方法

1.getClass()方法 返回当前类的实际对象类型

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

Class class1=s1.getclass();
Class class2=s2.getclass();
if(class1==class2){
    System.out.print("相同类型")
}else{
    System.out.print("不相同类型")
}

2.hashCode()方法 返回int类型

public int hashCode（）{}
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());//s1与s2地址不同所以hash值不同
Student s3=s1 //把s1地址赋给s3 所以相同
System.out.println(s3.hashCode());//相同

返回哈希码值、根据对象的地址或字符串或者数字使用hash算法计算出来的int类型的数值

3.toString()方法

eclipse中重写方法 Alt+Enter+s

public String toString(){
    return name+":"+age;
}

4.equals()方法 默认实现为（this==obj）。比较两个对象地址是否相同。可覆盖 为比较两个对象的内容是否为相同、通过重写。

重写equals方法 改变equals的判断条件方法

public class Outer {
    @Override
    public boolean equals(Object obj) {
        //1.判断两个对象是否为同一个引用 一样就不需要比ture
        if(this==obj) {
            return true;
        }//2.判断是否为空值
        if(obj==null) {
            return false;   
        }//3.判断是否为同一类型
//      if(this.getClass()==obj.getClass()) {   
//      }
        if(obj instanceof Student ) {
            //4.强制类型转换
            Student s =(Student)obj;
            //5.比较属性
            if(this.name.equals(s.getName())&&this.age==s.getAge()) {
                return true;
            }
        }
        return false;
    }
}

5.finalize（）方法

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

垃圾对象：指没有有效引用指向此对对象

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

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

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

Student s1 = new Student("aaa",20);//不会被当作垃圾回收
new Student("aaa",20);//会被当做垃圾回收
System.gc();

 

包装类

基本数据类型 byte、char、short、int、long、float、double、boolean，

基本数据类型都存在栈中，引用类型都在堆中

从而只能通过运算符对基本数据类型操作，

为了让基本数据类型提供更强大的功能所以创造出：基本数据类型所对应的引用数据类型

包装类 是 引用类型默认值为null

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

包装类将对应的基本数据类型包装在一个对象中(对象则变为堆中，就可以使用方法。。。)

类型转换与装箱、拆箱

装箱：把栈(基本类型)拿到堆(引用类型)中，反之拆箱。

装箱：
//基本类型
int n =18;
//使用Integer类创建对象、valueof()方法返回一个 Integer指定的 int值的 Integer实例
1.Integer integer = new Integer(n);//把传入的数字
2.Integer integer1 = Integer.valueof(n);
拆箱：
//intvalue()方法返回int值
Integer integer2 = new Integer(n);
int num2 = integer2.intvalue();
JDk1.5后自动提供装箱拆箱
 //自动装箱
 int a = 15;
Integer integre1=a;
//自动拆箱
int a2=integer1;

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

//基本类型转换字符串转
    int n1 =100;//使用toString（）方法
    1.String s1 = n1+"";
    2.String s2 = Integer.toString(n1);
//字符串转换成基本类型
`   String str ="100";
    //使用Integer.parseXXX（）
    int n2 = Integer.parseInt(str);
//boolean字符串行式转换成基本类型 "true"都是true 非 true 都是false
    String str2 = "false";
    boolean b = Boolean.parseBoolean(str2);

Integer缓冲区

//面试题
    Integer integer1 = new Integer(100);
    Integer integer2 = new Integer(100);
    System.out.printin(integer1==integer2);//false
//比的是地址
    Integer integer3 = 100;//自动装箱 =Integer integer3 = Integer.valueof(100);
    Integer integer4 = 100;//从在Cache[] 数组-128——127中找到 直接给栈内的对象 堆地址相同唯一
    System.out.printin(integer3==integer4);//true
    Integer integer5 = 200;
    Integer integer6 = 200;
    System.out.printin(integer5==integer6);//false
//Intrger.valueof(i) i 是有范围的-128——127 超出范围会 new Integer(i); 从而使地址不同

String类

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

字符串字面值存储在字符串池(方法区内的)中，可以共享。

实例：
String name ="Hello";//"hello"常量存储在常量池中
name ="zhangsan";    //把zhangsan赋值给name变量，给字符赋值时，并没有修改数据，而是重新开辟空间
String name2 = "zhangsan"; 

String s ="Hello"; 产生一个对象，字符串池中存储。

String s = new String(“Hello”)；产生两个对象，堆、常量池个存储一个。

//展示字符串的另一个创建方式
String str = new Strinf("java");     //new 在堆中一个对象
String str2 = new Strinf("java");
System.out,printin(str==str2);       //false 都在堆中new 所以地址不同
System.out,printin(str.equals(str2));//true 因为这是比的是数据而不是地址

字符串常用的方法

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

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

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

String name = "java最好";
System.out.printin(name.length()); //6
System.out.printin(name.charAt(name.length()-1));  //好
System.out.printin(name.contains("java"));  //true

4.public char[ ] toCharArray( ) :将字符串转换成数组

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

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

String name = "java最好,java真香";
System.out.printin(Arrays.toString(name.toCharArray()));// [j,a,v,a,......]
System.out.printin(name.indexOf("java"));// 0
System.out.printin(name.lastIndexOf("java"));//7

split() 方法中 拆分split（“[ ,]+”）可以表示多个空格或 , 都能拆分

equalsIgnoreCase( )忽略大小写的比较

比较大小 两个字符串依次相同位置且依次往后比较，直至没有则比较长度

案例演示

toUpperCase（ ）可以变为大写

截取 ：subString(int beginIndex )

subString(int beginIndex ，int endIndex)

String增强类 StringBuffer：可变长字符串，运行效率慢，线程安全

(单线程）StringBuilder： 可变长字符串，运行效率快，线程不安全

/**
* StringBuffer和StringBuilser的使用
* 比String 1.效率高
           2.节省内存
*/
    StringBuffer sb = new StringBuffer();
1.//append（）;追加
    sb.append("java世界第一");
    System.out.print(sb.toString()); 
2.//insert（）;添加 可以在某个位置添加
    sb.insert(0,"dddddd");
3.// replace(); 可以再指定位置替换
    sb.replace(0,5,"DDDDDD");
4.// delete();删除 也可指定位置
    sb.delete(0,5);

 

BigDecimal类

位置：java.math包中

作用：精确计算浮点数。

创建方式： BigDecimal bd = new BigDecimal（“字符串”）；字符串精确

//面试题
double result =(1.4-0.5)/0.9;
//求结果 却为0.0999999999...
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法 subtract()
BigDecimal r1 = bd1.subtract(bd2);
//加法 add()
BigDecimal r2 = bd1.add(bd2);
//乘法 multiply()
BigDecimal r3 = bd1.multiply(bd2);
//除法 divide() 面试题例题
BigDecimal r4 = new Bigdecimal("1.4")
    .subtract(new Bigdecimal("0.5"))
    .divide(new Bigdecimal("0.9"));
//除不尽保留几位小数 divide(Bigdecimal bd,int scal（保留几位）,RoudingMode mode（取舍模式                                                                               四舍五入等等）)
    四舍五入：Bigdecimal.ROUND_HALF_UP

Date类

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

时间单位

1秒=1000毫秒

1毫秒=1000微秒

1微秒= 1000纳秒

toLocalString() 时间格式 xxxx - x - x

Calendar类

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

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

1.//创建Calendar对象
    Calendar calendar = Calendar.getInstance();
    System.out.println(calendar.getTime().toLocalString());//现在时间2020-10-1
    System.out.println(calendar.getTimeInMillis());//获取毫秒值
2.//获取时间信息
    年、月、日、时、分、秒
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH); //  月是从0-11开始 所以要加1
    int day = calendar.get(Calendar.DAY_OF_MONTH);
    int hour = calendar.get(Calendar.HOUR_OF_DAY);// HOUR 12小时、HOUR_OF_DAY24小时
    int minute = calendar.get(Calendar.MINUTE);
    int second = calendar.get(Calendar.SECOND);
3.//修改时间
    Calendar calendar2 = Calendar.getInstance();
    calendar2.set(Calendar.DAY_OF_MONTH,5)//修改当日为5
    calendar2.add(Calendar.HOUR,+/-1);//增加或减少1个小时 
4.//获取最大值最小值
    int max = claendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
    int min = claendar2.getActualMinimum(Calendar.DAY_OF_MONTH);  

SimpleDateFormat类

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

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

常用的时间模式字母

字母	日期或时间	示例
y	年	2019
M	年中月份	08
d	月中天数	10
H	一天中小时数	24
m	分钟	25
s	秒	60
S	毫秒	666

1.//创建SimpleDateFormat对象 y年M月s天H时m分s秒
    SimpleDateFormat sdf =new SimpleDateFormat(patter);//pattern表示参数
                            ↓
                            ↓
    SimpleDateFormat sdf =new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
2.//创建Date
    Date date = new Date();
  //格式化date，把日期转成字符串
    String str = sdf.format(date);
    System.out.print(str);
  //解析，把字符串转成日期
    Date date = sdf.parse("1990/5/1")

System类

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

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

1.
//src :源数组
//srcPos:从哪个位置开始复制
//dest ：目标数组
//destPos：目标位置
    public class Test1 {
        public static void main(String[] args) {
            int[] arr1 = {2,5,6,4,5};
            int [] arr2 = new int[10];
      //System.arraycopy(src, srcPos, dest, destPos, length);
            System.arraycopy(arr1, 0, arr2, 1, 2);
            for (int i = 0; i < arr2.length; i++) {
                System.out.print(arr2[i]+",");
            }
        }
    }
2.
// System.out.println(System.currentTimeMillis());
// 也可以用来计时
    long start = System.currentTimeMIllis();
    long end = System.currentTimeMIllis();
3.
//System.gc();垃圾回收
4.System.exit(0)    

#