初学java时的常用类

包装类

测试包装类
Inter类的使用，其他的包装类用法类似。

public class TestWrappedClass {
    public static void main(String[] args) {
        //基本数据类型转换为包装类对象
        Integer a = new Integer(3);
        Integer b = Integer.valueOf(30);
        //把包装类对象转换为基本数据类型
        int c = b.intValue();
        double d = b.doubleValue();
        //把字符串转换成包装对象
        Integer e = new Integer("99999");
        Integer f = Integer.parseInt("999");
        //把包装类对象转换为字符串
        String string = f.toString(); //""+f
        //常见的常量
        System.out.println("int类型最大的数："+Integer.MAX_VALUE);
    }
}

测试自动装箱，自动拆箱。

public class TestAutoBox {
    public static void main(String[] args) {
        Integer a = 234; //自动装箱。Integer a = Integer.valueOf(234);
        int b = a;     //自动拆箱。编译器会修改成：int b = a.intValue();
        Integer c = null;
        if (c != null) {
            int d = c;     //自动拆箱。调用了：c.ineValie();
        }
        //缓存[-128,127]之间的数字，实际就是系统初始的时候，创建了[-128,127]之间的一个缓存数组。
        //当我们调用valueOf()的时候，首先检查是否在[-128,127]之间，如果在这个范围则直接从缓存数组中拿出已经创建好的对象。
        //如果不在这个范围内，则创建新的Integer对象。
        Integer in1 = Integer.valueOf(-128);
        Integer in2 = -128;
        System.out.println(in1 == in2);//true因为-128在缓存范围内；
        System.out.println(in1.equals(in2));
        System.out.println("##########################");
        Integer in3 = 1234;
        Integer in4 = 1234;
        System.out.println(in3 == in4);//false因为1234不在缓存范围内
        System.out.println(in3.equals(in4));//ture
    }
}

String类（不可变字符序列）

测试String（不可变字符序列）

public class TestString {
    //做字符串比较的时候，使用equals不要使用==
    public static void main(String[] args) {
        String string = "aaabbbb";
        String string1 = string.substring(2,5);
        System.out.println(string);
        System.out.println(string1);
    }
}

标题StringBulider、StringBuffer（可变字符序列）

测试StringBulider、StringBuffer

public class TestStringBulider {
    public static void main(String[] args) {
        //StringBuilder线程不安全，效率高（一般用）；StringBuffer线程安全效率低
        StringBuilder stringBuilder = new StringBuilder("abcdefg");
        System.out.println(Integer.toHexString(stringBuilder.hashCode()));
        System.out.println(stringBuilder);
        stringBuilder.setCharAt(2,'M');
        System.out.println(Integer.toHexString(stringBuilder.hashCode()));
        System.out.println(stringBuilder);
    }
}

测试StringBulider、StringBuffer的常用方法。

 public class TestStringBulider {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder();
        for(int i =0;i<26;i++){
            stringBuilder.append((char)('a'+i));
        }
        System.out.println(stringBuilder);
        stringBuilder.reverse();            //倒序
        System.out.println(stringBuilder);
        stringBuilder.setCharAt(3,'金');
        System.out.println(stringBuilder);
        stringBuilder.insert(3,'涛').insert(3,'金');//链式调用，核心：该方法调用了return this。
        System.out.println(stringBuilder);

        stringBuilder.delete(20,23);
        System.out.println(stringBuilder);
    }
}

测试可变字符串序列和不可变字符串序列使用的陷阱

public class TestStringBulider3 {
    public static void main(String[] args) {
        /*使用String进行字符串的拼接*/
        String string = "";
        //本质上使用StringBuilder拼接，但是每一次都会生成一个StringBuilder对象
        long num1 = Runtime.getRuntime().freeMemory();//获取系统的内存剩余空间。
        long time1 = System.currentTimeMillis();//获取系统的当前时间。
        for (int i = 0; i < 5000; i++) {
            string = string + i;//相当于产生了10000个对象。
        }
        long num2 = Runtime.getRuntime().freeMemory();
        long time2 = System.currentTimeMillis();
        System.out.println("String占用内存：" + (num1 - num2));
        System.out.println("String占用时间：" + (time2 - time1));

        /*使用String进行字符串的拼接*/
        StringBuilder stringBuilder = new StringBuilder();
        long num3 = Runtime.getRuntime().freeMemory();//获取系统的内存剩余空间。
        long time3 = System.currentTimeMillis();//获取系统的当前时间。
        for (int i = 0; i < 5000; i++) {
            stringBuilder.append(i);
        }
        long num4 = Runtime.getRuntime().freeMemory();
        long time4 = System.currentTimeMillis();
        System.out.println("StringBuilder占用内存：" + (num3 - num4));
        System.out.println("StringBuilder占用时间：" + (time4 - time3));
    }
}

Date时间类

测试Date类的常见用法

public class TestDate {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        System.out.println(date.getTime());
        Date date1 = new Date();
        System.out.println(date1.getTime());
        System.out.println(date1.after(date));
        // 以后遇到日期处理，使用Canlendar日期类。
        Date date2 =new Date(2020-1900,3,10); //2020年4月10日
        System.out.println(date2);
    }
}

测试时间对象和字符串之间的互相转换DateFormat抽象类和SimpleDateFormat实现类的使用

public class TestDateFormat {
    public static void main(String[] args) {
        //把时间对象按照“格式字符串指定的格式”转换为相应的字符串a
        DateFormat dateFormat  = new SimpleDateFormat("yyyy年-MM月-dd日 hh:mm:ss");
        String string = dateFormat.format(new Date());
        System.out.println(string);
        //把字符串按照“格式字符串指定的格式”转换成相应的时间对象。
        DateFormat dateFormat1 = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
        try {
            Date date = dateFormat1.parse("1983年10月1日 10时45分55秒");
            System.out.println(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        //测试其他的格式字符,比如：利用D，获得本时间对象是所处年份的第几天
        DateFormat dateFormat2 = new SimpleDateFormat("D");
        String string1 = dateFormat2.format(new Date());
        System.out.println(string1);
    }
}

Calendar日期类（日历类）

测试日期类的使用

public class TestCalendar {
    public static void main(String[] args) {
        //获得日期的相关元素
        Calendar calendar = new GregorianCalendar(2019, 10, 01, 22, 05, 55);
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH);
        int weekday = calendar.get(Calendar.DAY_OF_WEEK);//星期几,1-7,1是星期1以此类推
        int day = calendar.get(Calendar.DAY_OF_MONTH);//也可以使用DATE。
        System.out.println(calendar);
        System.out.println(year);
        System.out.println(month);//0-11表示对应的月份，0是1月以此类推。
        System.out.println(weekday);
        System.out.println(day);
        //设置日期的相关元素
        Calendar calendar1 = new GregorianCalendar();
        calendar1.set(Calendar.YEAR, 2023);
        System.out.println(calendar1);
        //日期的计算
        Calendar calendar2 = new GregorianCalendar();
        calendar2.add(Calendar.DATE, 100);
        System.out.println(calendar2);
        //日期对象和时间对象的相互转换。
        Date date = calendar.getTime();
        Calendar calendar3 = new GregorianCalendar();
        calendar3.setTime(new Date());
        System.out.println(date);
        System.out.println(calendar3);
        printCalendar(calendar3);
    }

public static void printCalendar(Calendar calendar) {
    //打印：xxxx年xx月xx日xx xx：xx：xx 周x
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH) + 1;
    int day = calendar.get(Calendar.DAY_OF_MONTH);
    int dayweek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
    String dayweek1 = dayweek == 0 ? "日" : dayweek + "";
    int hour = calendar.get(Calendar.HOUR);
    int minute = calendar.get(Calendar.MINUTE);
    int second = calendar.get(Calendar.SECOND);
    System.out.println(year +"年"+month+"月"+day+"日"+"星期"+dayweek+hour+"时"+minute+"分"+second+"秒");
}

}

可视化日历小项目

版本一

public class TestCalendar1 {
    public static void main(String[] args) throws ParseException {
        String string = "2020-02-10";
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = dateFormat.parse(string);
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        System.out.println("日\t一\t二\t三\t四\t五\t六");
        calendar.set(Calendar.DAY_OF_MONTH,1);
        for (int i=0;i<calendar.get(Calendar.DAY_OF_WEEK)-1;i++){
            System.out.print("\t");
        }
        int days = calendar.getActualMaximum(Calendar.DATE);
        for (int i=1;i <=days;i++){
            System.out.print(calendar.get(Calendar.DAY_OF_MONTH)+"\t");
            if (calendar.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY){
                System.out.println(); //换行操作
            }
            calendar.add(Calendar.DAY_OF_MONTH,1);
        }
    }
}

版本二

public class TestCalendar2 {
    public static void main(String[] args) throws ParseException {
        System.out.println("请输入日期（格式：2020-02-10）");
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = dateFormat.parse(string);
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        int day =calendar.get(Calendar.DAY_OF_MONTH);
        int days = calendar.getActualMaximum(Calendar.DATE);
        System.out.println("日\t一\t二\t三\t四\t五\t六");
        calendar.set(Calendar.DAY_OF_MONTH,1);
        for (int i=0;i<calendar.get(Calendar.DAY_OF_WEEK)-1;i++){
            System.out.print("\t");
        }
        for (int i=1;i <=days;i++){
            if (day == calendar.get(Calendar.DAY_OF_MONTH)){
                System.out.print(calendar.get(Calendar.DAY_OF_MONTH)+"*\t");
            }else {
                System.out.print(calendar.get(Calendar.DAY_OF_MONTH)+"\t");
            }
            if (calendar.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY){
                System.out.println(); //换行操作
            }
            calendar.add(Calendar.DAY_OF_MONTH,1);
        }
    }
}

Math类

使用如下

 public class TestMath {
    public static void main(String[] args) {
        //取整相关操作
        System.out.println(Math.ceil(3.2)); //大的
        System.out.println(Math.floor(3.2));//小的
        System.out.println(Math.round(3.2));//四舍五入
        System.out.println(Math.round(3.8));//四舍五入
        //绝对值、开方、a的b次幂等操作
        System.out.println(Math.abs(-64));//绝对值
        System.out.println(Math.sqrt(64));//开方
        System.out.println(Math.pow(5,2));//5的2次幂
        System.out.println(Math.pow(2,5));//2的5次方
        //Math类中常用的常量
        System.out.println(Math.PI);//圆周率
        System.out.println(Math.E);//自然对数的底数
        System.out.println(Math.random());//0-1之间的随机数
    }
}

Random类

使用如下

public class TestRandom {
    public static void main(String[] args) {
        Random random =new Random();
        //随机生成（0，1）之间的double类型的数据
        System.out.println(random.nextDouble());
        //随机生成int类型允许范围之内的整型数据
        System.out.println(random.nextInt());
        //随机生成（0，1）之间的float类型的数据
        System.out.println(random.nextFloat());
        //随机生成false或者true
        System.out.println(random.nextBoolean());
        //随机生成（0，10）之间的int类型数据
        System.out.println(random.nextInt(10));
        //随机生成（20，30）之间的int类型的数据
        System.out.println(20+random.nextInt(10));
        //随机生成（20，30）之间的int类型的数据(此种计算方法较为复杂)
        System.out.println(20+(int)(random.nextDouble()*10));
    }
}

File类

测试File类的基本方法

public class TestFile {
    public static void main(String[] args) throws IOException {
        //File file = new File("d:/a/a.txt");
        File file = new File("d:\\a\\a.txt");
        System.out.println(file);
        file.renameTo(new File("d:/a/b"));
        System.out.println(System.getProperty("user.dir"));
        File file1 = new File("g.txt");
        //              file1.createNewFile();
        System.out.println("File是否存在："+file1.exists());
        System.out.println("File是否是目录："+file1.isDirectory());
        System.out.println("File是否是文件："+file1.isFile());
        System.out.println("File最后修改时间："+new Date(file1.lastModified()));
        System.out.println("File的大小："+file1.length());
        System.out.println("File的文件名："+file1.getName());
        System.out.println("File的目录路径："+file1.getPath());
        System.out.println("File的绝对路径："+file1.getAbsolutePath());
        //file1.delete();
        File file2 = new File("D:/电影/华语/大陆");
        boolean flag = file2.mkdirs();
        //boolean flag = file2.mkdir();//目录结构中有一个不存在。则不会创建整个目录树。
        //System.out.println(flag);//创建失败
        System.out.println(flag);
    }
}

使用递归算法打印目录树

public class TestPrintFileTree {
    public static void main(String[] args) {
        File file = new File("D:/电影");
        printFileTree(file,0);
    }
    static void printFileTree(File file,int level){
        //输出层数
        for (int i= 0; i<level;i++){
            System.out.println("-");
        }
        System.out.println(file.getName());
        if (file.isDirectory()){
           File[] files = file.listFiles();
           for (File temp:files){
               printFileTree(temp,level+1);
           }
        }
    }
}

枚举类

测试枚举类

public class TestEnum {
    public static void main(String[] args) {
        System.out.println(Session.SPRING);
        Session session =Session.AUTUMN;
        switch (session){
            case SPRING:
                System.out.println("春天来了，发芽的季节到了");
                break;
            case SUMMER:
                System.out.println("夏天来了，游泳的季节到了");
                break;
            case AUTUMN:
                System.out.println("秋天来了，收获的季节到了");
                break;
            case WINTER:
                System.out.println("冬天来了，冬眠的季节到了");
                break;
        }
    }
}
enum Session{
    SPRING,SUMMER,AUTUMN,WINTER
}
enum Week{
    星期一,星期二,星期三,星期四,星期五,星期六,星期日
}