JAVA常用类

Object类

Object类是类层次结构的根，每个类都可以将Object作为超类,所有类都直接或者间接的继承该类
Object只有无参构造方法

Math类

包含执行基本数学运算的方法

Random类(伪随机数)

java.utal.Random类

public class Test1 {
    public static void main(String[] args) {
        //创建Random类
        Random random = new Random();
        //调用方法nexInt(范围)，0~19
        int i = random.nextInt(20);
        System.out.println(i);
    }
}

File类

File类概述

• File：它是文件和目录路径名的抽象表示
• 文件和目录是可以通过File封装成对象的
• 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在也可以是不存在；
  

public class Test1 {
    public static void main(String[] args) throws ParseException {
        File file = new File("E:\\java_test\\java.txt");
        File file1 = new File("E:\\java_test","java.txt");
        File file2 = new File("E:\\java_test");
        File file3 = new File(file2,"java.txt");//此时并不会生成java.txt文件
        System.out.println(file);
    }
}

File类创建功能

public class Test1 {
    public static void main(String[] args) throws ParseException, IOException {
        File file = new File("E:\\java_test\\java.txt");
        //创建文件，创建成功返回true,失败返回false,已创建java.txt，再执行将不会重复创建
        System.out.println(file.createNewFile());
        File file1 = new File("E:\\java_test\\javatest");
        //创建目录，创建成功返回true,失败返回false,已创建javatest目录，再执行将不会重复创建
        System.out.println(file1.mkdir());
        File file2 = new File("E:\\java_test\\javaweb\\js");
        //创建多级目录，当javaweb目录不存在时，创建成功返回true,失败返回false,已创建java.txt，再执行将不会重复创建
        System.out.println(file2.mkdirs());
    }
}

File类判断和获取功能

File类删除功能

注意如果该目录下还有文件，就不能直接删除该目录；

遍历目录

/**
 * todo 遍历目录
 */
public class Test1 {
    public static void main(String[] args) {
        //给定目录或着文件创建file对象
        File srcFile = new File("E:\\html");
        getAllFilePath(srcFile);
    }

    //todo 定义方法，返回一个目录下所有内容
    public static void getAllFilePath(File srcFile){
        if(srcFile.isFile()){
            System.out.println(srcFile.getAbsolutePath());
        }else{
            //获取给定的目录下的所有文件或着目录
            File[] fileArray = srcFile.listFiles();
            //遍历该file数组，得到每一个file对象
            if(fileArray!=null){
                for (File file : fileArray) {
                    //判断该对象是否是目录
                    if(file.isDirectory()){
                        getAllFilePath(file);
                    }else{
                        System.out.println(file.getAbsolutePath());
                    }
                }
            }
        }
    }
}

包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法
操作该数据常用的操作之一：基本数据类型与字符串之间的转换

例：Integer

public class Test1 {
    public static void main(String[] args) {
        Integer integer = Integer.valueOf("100");
        System.out.println(integer);
        Integer integer1 = Integer.valueOf(100);
        System.out.println(integer1);
    }
}

自动装箱和拆箱

• 装箱：把基本数据类型转换为对应的包装类类型’
• 拆箱：把包装类类型转换为对应的基本数据类型

日期类

Date类

SimpleDateFormat类

用于以区域设置敏感的方法格式化和解析日期

构造方法

格式化和解析日期

public class Test1 {
    public static void main(String[] args) throws ParseException {
        //格式化：Date到String
        Date d=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s=sdf.format(d);
        System.out.println(s);
        System.out.println("----------------");
        //从String 到 Date
        String ss="2022-08-02 09:09:09";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);
        System.out.println(dd);
    }
}

Calendar类(日历类)

Calendarw为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
Calendar 提供了一个类方法getInstance用于获取Calendat对象，其日历字段已使用当前日期和时间初始化：
Calendar rightNow =Calendar.getInstance();

public class Test1 {
    public static void main(String[] args) throws ParseException {
        //获取对象
        Calendar instance = Calendar.getInstance();
        System.out.println(instance);
        int year = instance.get(Calendar.YEAR);//年
        int month = instance.get(Calendar.MONTH) + 1;//月，月是从0开始的
        int date = instance.get(Calendar.DATE);//日
        System.out.println(year+"-"+month+"-"+date);
    }
}

String类

• String类再java.lang包下，使用时不需要导包
• String类代表字符串，Java程序中的所有字符串文字，都是此类的实例，即java程序中所有的双引号字符串，都是String类的对象。

String字符串的特点

• 字符串不可变，他们的值在创建后不能被更改
• String的值是不可变的，但是他们可以被共享
• 字符串效果上相当于字符数组(char[]),但是底层原理是字节数组(byte[]).
  注：JDK8及以前是字符数组，JDK9及以后是字节数组

String构造方法

注意：以""方式给出的字符串，只要字符序列相同()顺序和大小写，无论在程序中出现多少次，JVM都只会建立一个String对象，并在字符串池中维护。

String的字符串拼接

String str1 = "c";
String str2 = "x";		  
String str3 = "c" + "x";//常量池中的对象
String str4 = str1 + str2; //TODO:在堆上创建的新的对象	  
String str5 = "cx";//常量池中的对象
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false

‘==’与equal区别

• ==：比较的是两个字符串内存地址（堆内存）的数值是否相等，属于数值比较；
• equals()：比较的是两个字符串的内容，属于内容比较。

遍历字符串

public class Test1 {
    public static void main(String[] args) {
        String s="cx";
        for (int i = 0; i < s.length(); i++) {
            System.out.println(s.charAt(i));//指定索引处的字符值
        }
        }
}

面试问题

String a=new String(“abc”);在执行的时候创建了几个对象，答案是：1个
因为abc是存放在常量池中的，这个过程是在编译的时候就产生的，而问题是，在执行的过程中！！！

StringBuffer(线程安全synchronized)

是线程安全的可变字符序列，它是一个类似于String的字符串缓冲区，其实体容量会随着存放的字符串增加而自动增加。

StringBulider(非线程安全)

为什么使用StringBulider

使用String进行字符串拼接时,会浪费空间;

StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理

StringBulider概述

StringBulider是一个可变的字符串类，可变指的是内容可变

• String：内容不可变
• StringBuilder：内容可变

StringBuilder构造方法

StringBuilder添加和反转方法

public class Test1 {
    public static void main(String[] args) {
        StringBuilder s1=new StringBuilder("c");
        StringBuilder s2 = s1.append("x");
        System.out.println(s1);//cx
        System.out.println(s2);//cx
        //这就是返回对象本身
    }
}

String与StringBuilder相互转化

System类

public class Test1 {
    public static void main(String[] args) {
        long start=System.currentTimeMillis();
        StringBuilder s1=new StringBuilder("c");
        StringBuilder s2 = s1.append("x");
        System.out.println(s1);//cx
        System.out.println(s2);//cx
        //这就是返回对象本身
        long end=System.currentTimeMillis();
        System.out.println("共耗时："+(end-start)+"毫秒");//1毫秒
    }
}

枚举类Enum

• JDK1.5之前需要自定义枚举类
• JDK1.5新增的enum关键字用于定义枚举类
• 枚举类的属性

1. 枚举类对象的属性不应该允许被改动，所以应该使用private final修饰
2. 若枚举类使用private final修饰的属性应该在构造器中为其赋值
3. 若枚举类显式的定义了带参数的构造器，则在列出枚举值时也必须对应的传入参数

/**
 * 使用enum关键字定义枚举类
 * 定义的枚举类默认继承与java.lang.Enum
 */
public enum Gender {
    MAN("男"),
    WOMAN("女");

    //申明Gender对象的属性，用private final
    private final String sex;

    Gender(String sex) {
        this.sex=sex;
    }

    public String getSex() {
        return sex;
    }
}

public class Test15 {
    public static void main(String[] args) {
        Gender man = Gender.MAN;
        //toString():返回当前枚举类对象常量的名称
        System.out.println(man.toString());
        System.out.println("-------");
        //values()：返回枚举类型的对象数组
        Gender[] values = Gender.values();
        for (Gender value : values) {
            System.out.println(value);
        }
        System.out.println("-------");
        //valueOf(String objName):返回枚举类中对象名是objName的对象,没找到则抛出异常
        Gender man1 = Gender.valueOf("MAN");
        System.out.println(man1.getSex());
    }
}

枚举类实现接口

public class Test16 {
    public static void main(String[] args) {
        Gender1 woman = Gender1.WOMAN;
        woman.show();
    }
}

//接口
interface Info{
    void show();
}

enum Gender1 implements Info {
    MAN("男"){
        @Override
        public void show() {
            System.out.println("this is man");
        }
    },
    WOMAN("女") {
        @Override
        public void show() {
            System.out.println("this is woman");
        }
    };

    //申明Gender对象的属性，用private final
    private final String sex;

    Gender1(String sex) {
        this.sex=sex;
    }

    public String getSex() {
        return sex;
    }
}

=》javaAPI官方文档