java常用类

摘要：本篇文章主要讲解java常用类（补Array）

写在开头：

调用类方法：如果本身是类对象的话，直接调用即可。如果本身是基本类型，可以通过类来调用

char A = 'a';
A = Character.toUpperCase(A);
//静态方法通过类直接调用即可

一、内部类

0、分类：

成员内部类

静态内部类

局部内部类

匿名内部类

1、概念：

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

class Body{
    private String name;
    class head{
        public void show(){
            System.out.println(name);
        }
    }
}

特点：

• 编译之后会生成独立的字节码文件

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

2、成员内部类（？？？）

在类的内部定义的，与属性、方法同级别的类

在自己内部用：

因为成员内部类的的地位和成员一样，所以如果是成员方法的话，可以直接调用。而如果是static方法的话，先创建外部类实例

？？

拿出去用：

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

Outer outer = new Outer();
Inner inner = outer.new Inner();
//简化
Inner inner = new Outer().new Inner();

注：如果要在其他文件中创建内部类对象，必须显示地导入内部类

外部类与内部类的属性重名时，优先访问内部类属性

//重名时，如果想访问外部属性，前面加上Outer.this.
//this.其实是每个属性前面默认都有的，只不过调用外部类属性时，需要显示
System.out.println(Outer.this.name);
System.out.println(this.name);

注：内部类不能包含静态变量，但可以包含静态常量

3、！静态内部类

静态内部类=静态（成员内部类）

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

静态内部类直接当外部类使用即可，注意创建的时候要导入

public class StaticClass {
    private String name = "xxx";
    private int age = 10;
    //级别和外部类相同，外部类怎么用，这个类就怎么用
    static class Inner{
        //普通成员
        private String address="shanghai";
        //静态成员
        private static int count=1000;
        public void show(){
            //先创建外部类对象，再访问外部类属性
            System.out.println(new StaticClass().name);
            //访问内部类对象
            //成员方法可以直接访问类方法、成员方法（从加载先后考虑）
            System.out.println(address);
            System.out.println(count);
        }
        public static void showw(){
            System.out.println(count);
        }
    }
    
    public static void main(String[] args){
        //不拿出去用：因为是静态的内部类，所以可以直接被方法调用
		Inner inner = new Inner();
    	inner.show();
    }
}

//拿出去用：
StaticClass.Inner inner = new StaticClass.Inner();

注！只有内部类才可以static修饰，外部类不可

4、局部内部类

定义在外部类方法中，甚至可以定义在方法的某个条件中，作用范围和创建对象仅限于当前方法

局部内部类的生命周期与方法的局部变量生命周期不相同，所以要求变量为final

public class LocalClass {

    private String name = "mars";
    private int age=25;

    public void show(){
        //定义局部变量
        String address = "local";
        //不能加任何访问修饰符，其地位等价于局部变量
        class Inner{
            //类内属性可以加访问修饰符
            private String phone = "155555999";
            private String email = "dangzichen@163.com";

            public void show(){
                //类的地位和局部变量相同，局部变量可以访问name，因为都是成员，所以类内也可以访问
                //外部
                System.out.println(LocalClass.this.name);
                //内部
                System.out.println(phone);
                //只能访问常量，JDK1.8默认为被调用变量增加final
                System.out.println(address);
            }
        }
        //必须在方法内部创建局部内部类对象！
        Inner inner = new Inner();
        inner.show();

    }
}

5、！匿名内部类

匿名内部类=匿名的局部内部类（一切特征与局部内部类相同）

通常用于继承父类或者实现接口

只能实例化一次，减少代码量，增加阅读复杂度

public interface USB {
    //服务方法
    void service();
}

public class Mouse implements USB{
    @Override
    public void service() {
        System.out.println("ok");
    }
}

public class Test {
    public static void main(String[] args){

        /*
        USB usb = new Mouse();
        usb.service();
         */

        /*
        //局部内部类
        class Fan implements USB{
            @Override
            public void service() {
                System.out.println("Fan is ready!");
            }
        }

        USB usb = new Fan();
        usb.service();
        */

        //如果类只使用一次，完全没必要给他名字！
        //使用匿名内部类优化

        //匿名内部类：相当于创建了一个局部内部类
        USB usb = new USB() {
            @Override
            public void service() {
                System.out.println("Fan is ready!");
            }
        };
        usb.service();
        
    }

}

二、Object类

1、definition

• 是所有类的直接或间接超类。位于继承树的最顶层

• Object类中所定义的方法，是所有对象（包括数组）都具备的方法（通常也不会去重写Object方法）

• Object类型可以存储任何对象

  作为参数：接收任何对象

  作为返回值：可返回任何对象

  hashCode()方法：返回内存地址

2、func

2.1 getClass方法

返回一个类class：即对象的实际类型

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

public class People {}
public class Student extends People{}

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
//      System.out.println(s1.getClass().equals(s2.getClass()));

        People s3 = new Student();
        System.out.println(s1.getClass().equals(s3.getClass()));
//	    即使变量不一样，只要指向的内容一样，就返回true

    }
}

2.2 hashCode方法

返回对象的哈希码值

哈希值：根据对象的地址或字符串或数字使用hash算法计算出来的int类型数值，不是内存地址！！

一般情况下相同对象返回相同哈希码，可以用哈希码来判断是不是相同对象

System.out.println(s1.hashCode());

2.3 toString方法

返回对象的字符串表示（默认是）

可以根据程序需求重写方法

System.out.println(s1.toString());
//结果：
//com.mars.ClassInCommonUse.Object.Student@2f4d3709

2.4 equals方法

判断当前对象和传入对象是否是同一个对象，注意不是比较对象属性是否相同，而是比较对象本身是否相同

equals方法可以重写，用来比较两个对象的内容是否相同

2.5 finalize()方法 （已弃用）

当对象被判断为垃圾对象时，由JVM自动调用，用以标记垃圾对象，进入回收队列

• 垃圾对象：没有有效引用指向此对象时，为垃圾对象
• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间
• 自动回收：JVM内存耗尽时，一次性回收所有垃圾对象
• 手动回收：使用Ststem.gc()；通知JVM回收

public class Stu{
    String name = "xx";
    
    public Stu(String name){
        this.name = name;
    }
    
    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name + "is gone");
    }
    
}

psvm(){
    new Stu("aa");
    new Stu("bb");
    System.gc();
}

三、包装类

思想：八大基本类型没有方法，操作起来不方便，为此设计了对应的封装类

Object可统一所有数据（都可以用Object来接收）。包装类的默认值是null

一旦基本类型数据包装后放在对象中，存储位置就在堆中了！

Integer构造方法中传入字符串，可以构造对应的值

1、类型转换&装箱&拆箱

类型转换：引用类型转换为基本类型

装箱：基本类型转引用类型（构造方法，valueof）

拆箱：引用类型转基本类型（Number下的byteValue等）

   int num = 10;
   //装箱：基本→引用
   Integer integer1 = new Integer(num);
   Integer integer2 = Integer.valueOf(num);
   //拆箱：引用→基本
   Integer integer3 = new Integer(100);
   int num1 = integer3.intValue();

   //JDK 1.5之后：自动装拆箱
   int age = 30;
   //自动装箱
   Integer integer4 = age;
//实质是Integer.valueOf方法
//new Integer已经弃用

   //自动拆箱
   int age2 = integer4;

1.1、ParseXXX()静态方法

//1、基本类型转成字符串
int n1 = 255;
//1.1 使用+号
String s1 = n1+"";//255
//1.2 使用Integer中的toString(int a，int index)方法，index表示进制
//转成对应进制的字符串
String s2 = Integer.toString(n1,16);//ff

//2、字符串转成基本类型
String str = "150";
int n = Integer.parsseInt(str);//不能出现非数字字符

//boolean转成boolean
//"true" → true ： 其他→false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);//true

1.2、整数缓冲区

//引入

Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1==integer2);

Integer integer3 = 100;
Integer integer4 = 100;
//两个integer指向的都是内存中cache数组中值为100的地址
System.out.println(integer3==integer4);


Integer integer5 = 200;
Integer integer6 = 200;
System.out.println(integer5==integer6);

如果 num 处于-128~127之间，直接从cache数组中取值赋给它，否则再新建一个integer对象赋给它

优点：节省内存消耗

四、String类

引：

字符串放在方法区中，但方法区不一定在堆中

三种情况：
1、 java7之前，方法区位于永久代(PermGen)，永久代和堆相互隔离，永久代的大小在启动JVM时可以设置一个固定值，不可变；

2、 java7中，字符串常量池从永久代移到堆中；

3、 java8中，取消永久代，方法区存放于元空间(Metaspace)，元空间仍然与堆不相连

没人要的字符串就变成垃圾了

给字符串赋值时，会去字符串池里面找有无对应值，有就指，没有就新建。

String详细分析（存疑–→JVM）

1.1 String对象创建两种方式

a) String str1 = "abcd";
b) String str2 = "abcd";

c) String str3 = new String("mmm");
d) String str4 = new String("mmm");

第一种创建方式：

1. 先在栈中创建一个str1变量
2. 在字符串池（in方法区）中寻找有无指定的字符串“abcd”，发现没有，则在字符串池中创建一个，然后让str1指向该字符串

e) str1 = "efgh"

注：如果给str1赋一个新值“efgh”，原字符串“abcd”不会被回收，而是在方法区新建一个字符串常量“efgh”，然后让str1重新指向之。

第二种

1. 先在栈中创建str3变量

2. 在字符串池中创建一个“mmm”，然后在堆中创建一个String对象，其内容也是“mmm”（实质上是指向字符串池中的字符串常量）

   >//str3和str4指向的堆地址是不同的
   >//str3和str4堆内容是相同的（相同的地址）

   由此可知

   >str3==str4//false：比较的是堆内存地址
   >str3.equals(str4)//true：比较的是实际内容

   另外

   >str1==str2//true，因为都指向字符串常量值同一片地址

1.2 String常用方法

Arrays类要导入，String类不用导

//1	length();返回字符串长度，空格算字符
//2 charAt(int index);返回某个位置的字符，脚标从0开始
//3 contains(String str);判断是否包含某个子字符串

//4 toCharArray();将字符串转为数组
//5 indexOf(String str);查找str首次出现的下标
//6 lastIndexOf(String str);查找字符串在当前字符串中最后一次出现的下标索引

String str = "mars";
System.out.println(Arrays.toString(str.toCharArray()));
System.out.println(str.indexOf("ar"));
//结果为1，说明返回的是目标字符串第一个字符在原字符串中的位置，last就是最后一次

//7 trim();去掉字符串前后的空格
//8 toUpperCase();将小写转换为大写 toLowerCase();
//9 endsWith(String str)判断字符串是否以str结尾 startsWith();

String str = "  mars  ";
str.trim();//str没有改变,除非str = str.trim();
str.toUpperCase();//str没有改变
str.toLowerCase();//str没有改变
System.out.println(str);

String filename = "hello.java";
System.out.println(filename.endsWith(".java"));
System.out.println(filename.startsWith("hello"));

//10 replace(char oldChar, char newChar)将旧字符（串）替换成新字符（串）
//11 split(String str)根据str做拆分，结果会返回一个字符串数组
//除非把这些方法的返回值赋回给原字符串，否则原字符串不会发生变化

String str = "java是世界上最好的编程语言";
System.out.println(str.replace("java","php"));
    
String content = "java is the best";
String[] arr = content.split(" ");
for(String string: arr) {
    System.out.println(string);
}

关于split的技巧

//[ ,.]表示遇到这三个字符都会分开，解决了只能用一个字符的问题，不能用字符串
//[ ,]+表示遇到多个空格或者多个逗号，也会分开
//""这种普通表示可以用字符串或者字符切

补充：

1. equalsIgnoreCases()：忽视大小写比较

2. compare()：从两个字符串首字符开始比较，返回第一个不相同字符的ascii差

   A.compare(B)：返回A-B

   a = "abc";
   b = "abcdef";
   //当一个字符串用完了还没出现不同字符，则返回长度差，a.compare(b)=-3
   //当两个字符串完全相同时，返回0（每一位差都是0）

3. replace和replaceAll是JAVA中常用的替换字符的方法,它们的区别是:

   1.replace即可以支持字符的替换,也支持字符串的替换
   2.replaceAll的参数是regex或者char,即基于规则表达式的替换,比如,可以通过replaceAll(“\d”, “*”)把一个字符串所有的数字字符都换成星号;

   相同点是都是全部替换,即把源字符串中的某一字符或字符串全部换成指定的字符或字符串。

   如果只想替换第一次出现的,可以使用replaceFirst(),这个方法也是基于规则表达式的替换,但与replaceAll()不同的时,只替换第一次出现的字符串;

   另外,如果replaceAll()和replaceFirst()所用的参数据不是基于规则表达式的,则与replace()替换字符串的效果是一样的,即这两者也支持字符串的操作;

Exercise：

public static void main(String[] args) {
    //返回给定字符串的每个单词首字母大写后的结果
    String str = "java is the best language in the world";
    String[] strArr = str.split(" ");
    for (int i = 0; i < strArr.length; i++) {
        char first = strArr[i].charAt(0);
        char upFirst = Character.toUpperCase(first);
        String news = upFirst+strArr[i].substring(1);
        strArr[i] = news;
    }
    String nn = " ";
    for (String s : strArr) {
        nn = nn.concat(s);
        nn = nn.concat(" ");
    }
    nn=nn.trim();
    System.out.println(nn);
}

1.3 可变字符串

String局限：

• 出现大量垃圾
• 效率低

StringBuffer：提前开辟缓冲区，线程安全，效率慢（快于String）

StringBuilder：提前开辟缓冲区，线程不安全，运行效率快

//StringBuffer StringBuilder的操作
//StringBuffer StringBuilder操作完全一致
//推荐在单线程情况下使用StringBuilder

StringBuilder sb = new StringBuilder();
//1.append(String str)
sb.append("java!!");
System.out.println(sb);
//2.insert(int index, String str) 在指定位置上插入字符串
sb.insert(0,"i am first");
System.out.println(sb);
//3.replace(int start, int end, String str) 把从start(含)到end(不含)的字符替换成str
//str不具有把指定字符串替换成特定字符串的能力，只能把从start到end的内容替换掉
sb.replace(0,2,"jj");
System.out.println(sb);
//4.delete()
sb.delete(0,5);
System.out.println(sb);
//sb的每个操作都会在原字符串上进行修改，而不用像String一样，str = str.xxx;
//清空
sb.delete(0,sb.length());
System.out.println(sb.length());

含头不含尾原则：StringBuffer(Builder)的含有首尾参数的方法，都遵循含头不含尾原则。

五、其他常用类

1、BigDecimal类

引入：double存在的问题

double d1=1.0;
double d2=0.9;
System.out.println(d1-d2);
//0.09999999999999998

double result = (1.4-0.5)/0.9;
System.out.println(result);
//0.9999999999999999

double的结果是不准确，可以采取保留若干位小数来精确，但总体是不准确的。

double f = 0.012324;
f = new BigDecimal(f).setScale(2,RoundingMode.HALF_UP).doubleValue();

1.0、Intro

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

1.1、用法

注意初始化的时候用字符串，因为1.0，0.9本身在计算机中还是不准确的

//BigDecimal

         BigDecimal b1 = new BigDecimal("1.0");
         BigDecimal b2 = new BigDecimal("0.9");
         //一定要用字符串构建
		//减 b1-b2
         System.out.println(b1.subtract(b2));
		//加 b1+b2
		System.out.println(b1.add(b2));
		//乘 b1*b2
		System.out.println(b1.multiply(b2));
		//除 b1÷b2
		System.out.println(b1.divide(b2));	
		BigDecimal r = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
		//除法如果除不尽，需要给出保留几位小数，否则会报错
		BigDecimal r = new BigDecimal("10").divide(new BigDecimal("3"), 2, RoundingMode.HALF_UP);
		//scale表示保留几位小数，最后一位选择舍入方式 HALF_UP为四舍五入

2、Date类

    //Date类来封装时间
    public static void main(String[] args) {
        //
        Date d1 = new Date();
//        System.out.println(d1); 直接打印Date对象会得到当前时间
//        getTime方法返回从1970年1月1日起的毫秒数
        Date d2 = new Date(d1.getTime()-(60*60*24*1000));
//        System.out.println(d2);

        //方法
        // 判断d1是否在d2之前，之后 after() before()，毫秒数大就是之前，否则就是之后
        System.out.println(d1.after(d2));
        // compareTo 大为正，小为负，同为0
        // equals 判断是否相等

        System.out.println(d1.compareTo(d2));
    }

3、Calendar类

Date类许多方法已经弃用，建议使用Calendar类

public static void main(String[] args) {
    //1、创建 calendar 对象
    Calendar calendar = Calendar.getInstance();
    System.out.println(calendar.getTime());
    System.out.println(calendar.getTimeInMillis());//自1970毫秒数
    //2、获取时间信息
    //获取年月日时分秒
    //以下的各个字段本质都是int，get方法根据值不同返回不同字段的值
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH);
    int date = calendar.get(Calendar.DATE);//DAY_OF_MONTH 等价
    int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR 12小时制度
    int minute = calendar.get(Calendar.MINUTE);
    int second = calendar.get(Calendar.SECOND);
    System.out.println("year " + year + " month " + month);
    //3、修改时间
    //修改指定字段为特定值
    calendar.set(Calendar.DATE,6);
    System.out.println(calendar.getTime());
    //4、add
    //在指定字段上加
    calendar.add(Calendar.DATE,1);
    System.out.println(calendar.getTime());
    calendar.add(Calendar.DATE, -1);
    System.out.println(calendar.getTime());
    //返回当前月份最大、最小天数
    System.out.println(calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
    System.out.println(calendar.getActualMinimum(Calendar.DAY_OF_MONTH));

}

4、SimpleDateFormat类

DateFormat 和SimpleDateFormat 的区别

1.DateFormat 可以直接使用，但其本身是一个抽象类，可以根据Locate指定的区域得到对应的日期时间格式

2.SimpleDateFormat 类是DateFormat 类的子类，一般情况下来讲 DateFormat 类很少会直接使用。而都使用SimpleDateFormat 类完成。

public static void main(String[] args) {
    //1、创建格式化对象
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd");
    //2、创建日期对象
    Date date = new Date();
    //格式化日期对象为字符串

    //格式化对象的意义就是可以为不同的格式化对象设置不同的格式，然后用这种格式来格式化目标
    String str = simpleDateFormat.format(date);
    System.out.println(str);

    //字符串解析为Date,一定要按照格式化对象的格式传参，否则会抛出异常
    Date date1 = null;
    try {
        date1 = simpleDateFormat.parse("2021/11/1");
    } catch (ParseException e) {
        e.printStackTrace();
    }
    System.out.println(date1);

}

模式：

y：年 M：月 d：天数 H：小时 m：分钟 s：秒 S毫秒

5、系统（System）类

System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有（不能实例化对象）

System中方法都是静态的，直接用即可。

public class Sys {
    public static void main(String[] args) {
        //arraycopy方法
        int[] arr = {23,45,14,25,67,88,2,3};
        int[] dest = new int[8];
        System.arraycopy(arr,0,dest,0,arr.length);
        //src: 源数组 srcPos: 从源数组的哪个位置开始 dest: 目标数组 destPos: 从目标数组的哪个位置 length: 复制多长
        for (int i : dest) {
//            System.out.println(i);
        }
//      Arrays.copyOf()内部是用System.arraycopy实现的
//      arraycopy 是 native方法，即用C++实现的，效率更高

        //获取系统当前的时间，返回毫秒
        System.out.println(System.currentTimeMillis());
        //获取运行时间
        long start = System.currentTimeMillis();
        {
            for (int i = 0; i < 999999; i++) {
                for (int j = 0; j < 99; j++) {
                    for (int k = 0; k < 9; k++) {

                    }
                }
            }
        }
        long end = System.currentTimeMillis();
        System.out.println((end - start));

        new Student("a");
        new Student("b");
        new Student("b");
        new Student("c");
        //建议启动垃圾回收器回收垃圾，具体实操要看系统系统
        System.gc();

        //退出jvm，即结束程序
        System.exit(0);

        System.out.println(1);//不会被执行

    }
}

class Student{
    String name;
    public Student(String name){
        this.name = name;
    }
    protected void finalize() throws Throwable {
        System.out.println("name: " + this.name);
    }
}

注：注意用系统获取时间方法可以计算过程耗时即可

补充：Array类

赏

谢谢你请我吃糖果