java初学者日志_常用类

最新推荐文章于 2022-05-17 16:47:40 发布

星空辰梦

最新推荐文章于 2022-05-17 16:47:40 发布

阅读量153

点赞数

分类专栏： java日记文章标签： java 字符串

本文链接：https://blog.csdn.net/dream_start_/article/details/114228257

版权

java日记专栏收录该内容

15 篇文章 0 订阅

订阅专栏

包装类要做的事：
基本数据类型，包装类对象,字符串，三者相互转化

public class test_baozhuang {
    public static void main(String[] args) {
        //基本数据类型转为对象
        Integer i0=new Integer(30);//已被废弃，建议不要使用该方法
        Integer i1=Integer.valueOf(20);
        Integer i2=Integer.valueOf(40);
        Character c1=Character.valueOf('a');
        //包装类对象转为基本数据类型
        double d1=i1.doubleValue();
        long l1=i2.longValue();
        
        //基本数据类型转为对象
        Integer i3=Integer.valueOf(l1);
        
        //字符串转为integer类型
        Integer str1=Integer.parseInt("2354");
        Integer str2=Integer.valueOf("456123");
        
        //将包装类对象转为字符串
        String str3=i0.toString();
    }
}

编写一个简单的包装类

public class myinteger {
    private int value;
    private static myinteger[] cache = new myinteger[256];
    public static final int LOW=-128;
    public static final int HIGH=127;
    //静态初始化
    static {
        for (int i=myinteger.LOW;i<HIGH;i++){
            //cache[0]=-128,cache[1]=-127...
            cache[i+128]=new myinteger(i);
        }
    }
    public static myinteger valueOf(int i){
        if(i>=LOW && i<=HIGH){
            return cache[i+128];
        }
        return new myinteger(i);
    }
    //私有构造器
    private myinteger(int i){
        this.value=i;
    }

    @Override
    public String toString() {
        return this.value+"";
    }

    public static void main(String[] args) {
        myinteger m1=myinteger.valueOf(30);
        myinteger m2=myinteger.valueOf(30);
        System.out.println(m1);
    }
}

String类是对象不可变的字符序列，
StringBuilder和StringBuffer代表可变字符序列
StringBuilder线程不安全，不做线程同步检查，因此效率较高，建议使用
StringBuffer线程安全，做线程同步检查，效率较低

public class Stringss {
    public static void main(String[] args) {
        String str1="hello"+" java";//相当于str1="hello java";
        String str2="hello java";
        System.out.println(str1==str2);//true
        String str3="hello";
        String str4=" java";
        String str5=str3 + str4;
        System.out.println(str5==str2);
        String str6="asd";//不可变字符序列
        //可变字符序列
        StringBuffer sbf=null;
        StringBuilder sbd=null;
        sbd=new StringBuilder("lv");
        //sbd.append相当于this.append，在源码中，返回值为本身
        //.append()在字符串后边追加字符串，
        sbd.append(123);
        sbd.append(456);
        System.out.println(sbd);
        sbd.append("aa").append("bb").append("cc");
        System.out.println(sbd);
        sbf=new StringBuffer("ya");
        System.out.println(sbf=new StringBuffer("ge"));
        for(int i=0;i<10;i++){
            sbf.append(i);
        }
        System.out.println(sbf);
        StringBuilder sb1=new StringBuilder("我叫星空辰梦");
        //插入操作
        sb1.insert(0,"1").insert(1,"2");
        System.out.println(sb1);
        //删除操作
        sb1.delete(2,4);
        System.out.println(sb1);
        //获取单个字符
        System.out.println(sb1.charAt(4));
        //字符串逆序
        System.out.println(sb1.reverse());
    }
}

Strign与StringBuilder占用内存以及占用时间的对比

public class test {
    public static void main(String[] args) {
        String s="";
        long num1 =Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
        long time1=System.currentTimeMillis();//获取系统的当前时间
        for(int i=0;i<5000;i++){
            s=s+i;//相当于产生了5000个对象因为String类不可变(只会产生一个新的String类)
        }
        long num2 =Runtime.getRuntime().freeMemory();
        long time2=System.currentTimeMillis();
        System.out.println("String占用内存："+(num1-num2));
        System.out.println("String占用时间："+(time2-time1));
        System.out.println("#################");
        StringBuilder sbd=new StringBuilder("");
        long num3 =Runtime.getRuntime().freeMemory();
        long time3=System.currentTimeMillis();
        for(int i=0;i<5000;i++){
            sbd.append(i);
        }
        long num4=Runtime.getRuntime().freeMemory();
        long time4=System.currentTimeMillis();
        System.out.println("StringBuilder占用内存："+(num3-num4));
        System.out.println("StringBuilder占用时间："+(time4-time3));
    }
}

在这里插入图片描述
以后当遇到需要拼接字符串的时候使用StringBuilder，因为使用String会创建大量无用对象

在计算机世界，将1970-1-1，00:00:00定为基准时间，度量单位为1/1000秒(1毫秒)

import java.util.Date;

public class test_time {
    public static void main(String[] args) {
        //Integer.MAX_VALUE;
        long l=Long.MAX_VALUE/(1000L*3600*24*365);//时间的最大值
        System.out.println(l);
        long nowtime=System.currentTimeMillis();//当前时刻的毫秒数
        System.out.println(nowtime);

        Date d1=new Date();//如果没有传参，就代理表当前时刻
        System.out.println(d1);
        System.out.println(d1.getTime());
        Date d2=new Date(1000L*3600*24*365*100);//1970年之后的100年(有闰年)
        System.out.println(d2);
    }
}

在这里插入图片描述

DateFormat：时间格式化类（抽象类）
SimplementDateFormat：简单时间格式化类
作用：把时间对象转化成指定格式的字符串

在这里插入图片描述
Calendar：日历类(公历)(抽象类)
一月是0，二月是1，以此类推
package com.MyInteger;
import java.util.*;
import java.util.Calendar;
import java.util.GregorianCalendar;

/*
*日历类
*/

public class test_calendar {
    public static void main(String[] args) {
        //得到相关日期元素
        GregorianCalendar c1=new GregorianCalendar(2902,10,24,10,30,15);
        //GregorianCalendar c2=new GregorianCalendar();
        //get方法
        int year=c1.get(Calendar.YEAR);
        int month=c1.get(Calendar.MONTH);
        int day=c1.get(Calendar.DAY_OF_MONTH);
        int day2=c1.get(Calendar.DATE);
        int week=c1.get(Calendar.DAY_OF_WEEK);//周日是1，周六是7，周日是一周的开始
        System.out.println(year+"年");
        System.out.println(month+"月");
        System.out.println(day+"日");
        System.out.println(day2+"日");
        System.out.println(week);
        //设置日期
        GregorianCalendar c2=new GregorianCalendar();
        System.out.println(c2);
        c2.set(Calendar.YEAR ,2019);
        c2.set(Calendar.MONTH ,Calendar.FEBRUARY);
        c2.set(Calendar.DATE,3);
        c2.set(Calendar.HOUR_OF_DAY,10);
        c2.set(Calendar.MINUTE,55);
        c2.set(Calendar.SECOND,59);

        System.out.println(c2.get(Calendar.YEAR));
        //日期计算
        GregorianCalendar c3=new GregorianCalendar(2019,10,9,22,10,50);

        c3.add(Calendar.MONTH,-7);//月份减7
        c3.add(Calendar.DATE,+4);
        printCalendar(c3);
        //日历对象和时间对象转化
        Date d=c3.getTime();
        GregorianCalendar c4=new GregorianCalendar();
        c4.setTime(new Date());//将时间对象的毫秒数转化为日历
        printCalendar(c4);

    }
    static void printCalendar(Calendar calendar){
        int year=calendar.get(Calendar.YEAR);
        int month=calendar.get(Calendar.MONTH)+1;
        int day=calendar.get(Calendar.DAY_OF_MONTH);
        //int day2=calendar.get(Calendar.DATE);
        int date=calendar.get(Calendar.DAY_OF_WEEK)-1;
        String week=""+((date==0)?"日":date);
        int hour=calendar.get(Calendar.HOUR);
        int minue=calendar.get(Calendar.MINUTE);
        int second=calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+month+"月"+day+"日,星期"+week+"  " +hour+"点:"+minue+"分:"+second+"秒");
    }
}

在这里插入图片描述

测试时间对象与字符串的相互转化
使用DateFormat

package com.MyInteger;
/*
测试时间对象与字符串的相互转化
使用DateFormat
 */
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class test_time2 {
    public static void main(String[] args) throws ParseException {
        //new的时候需要格式化字符串
        //将字符串转化为Date对象
        SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        SimpleDateFormat df2=new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
        Date d1=df.parse("1972-10-5 10:50:50");
        System.out.println(d1.getTime());
        //将Date转为字符串
        Date d2=new Date(1000L*3600*23);
        Date d3=new Date();

        String str=df.format(d2);
        String str1=df2.format(d3);
        System.out.println(str);
        System.out.println(str1);

        DateFormat df3=new SimpleDateFormat("今年第w周,第D天");
        String str2=df3.format(d3);
        System.out.println(str2);
        DateFormat df4=new SimpleDateFormat("今年第D天");
        String str3=df4.format(d3);
        System.out.println(str3);
    }
}

在这里插入图片描述

Math类

package com.math;

public class test_01 {
    public static void main(String[] args) {
        int a=-1;
        int b=2;
        double d=3.54;
        //绝对值
        System.out.println(Math.abs(a));
        //b的3次幂
        System.out.println(Math.pow(b,3));
        //取最大值，最小值
        System.out.println(Math.max(a,b)+Math.min(a,b));
        //大于d的最小整数
        System.out.println(Math.ceil(d));
        //小于d的最大整数
        System.out.println(Math.floor(d));
        //返回0.0到1.0的随机数
        System.out.println(Math.random());
        //四舍五入
        System.out.println(Math.round(d));
    }
}

random类

import java.util.Random;

public class test_random {
    public static void main(String[] args) {
        Random rand=new Random();
        //随机生成(0-1)之间的double类型的数据
        System.out.println(rand.nextDouble());
        //随机生成int类型的数据
        System.out.println(rand.nextInt());
        //随机生成(0-1)之间的float类型的数据
        System.out.println(rand.nextFloat());
        //随机生成false或true
        System.out.println(rand.nextBoolean());
        //随机生成(0-10)之间的int类型的数据
        System.out.println(rand.nextInt(10));
        //随机生成(20-30)之间的double类型的数据
        System.out.println(20+rand.nextInt(10));
    }
}

在这里插入图片描述
File类
用来代表文件和目录

import java.util.Date;
import java.io.File;
import java.io.IOException;

public class test_0 {
    public static void main(String[] args) throws IOException {
        File f1=new File("D:\\下载\\泰山版zxc.pdf");
        File f2=new File("D:/下载/泰山版.pdf");
        System.out.println(f1);
        System.out.println(System.getProperty("user.dir"));//获得项目的路径
        //File f3=new File(System.getProperty("user.dir"));
        File f4=new File("D:/下载/123泰山版.pdf");
        File f6=new File("D:/下载");
        //创建文件
        f4.createNewFile();
        System.out.println("File是否存在"+f2.exists());
        System.out.println("File是否是目录"+f2.isDirectory());
        System.out.println("File是否是文件"+f2.isFile());
        System.out.println("File最后修改时间"+new Date(f2.lastModified()));
        System.out.println("File的大小"+ f2.length());
        System.out.println("File的文件名"+f2.getName());
        Sysrem.out.println("打印出该目录下的子文件"+"f6.listFiles");
        System.out.println("File的目录路径"+f2.getPath());


        File f5=new File("D:/下载/哇/123/45/65/1531/654/6/465/46/54/654/6");
        f5.mkdir();//创建目录，若中间有目录缺失，则创建失败
        f5.mkdirs();//创建目录，若中间有目录缺失，则自动补全缺失的目录
        //删除文件
        f5.delete();//删除的是最终的文件，而不是他的父目录
    }
}

枚举:
枚举还是类，枚举就是放置一些常量

import java.util.Random;

public class test_meiju {
    public static final int SPRING=0;
    public static final int SUMMNER=1;
    public static final int AUTUMN=2;
    public static final int WINTER=3;

    public static void main(String[] args) {
        System.out.println(test_meiju.SUMMNER);
        System.out.println(Week.星期2);
        System.out.println(" ");
        //枚举遍历
        //values返回的是Week[],里边包含了所有的枚举元素
        for(Week k:Week.values()){
            System.out.print(k+"\t");
        }
        System.out.println("");
        Week[] ws=Week.values();
        System.out.println(ws[0]);

        //switch语句中使用枚举
        int a=new Random().nextInt(6);
        switch (Week.values()[a]){
            case 星期1:
                System.out.println("周一");
                break;
            case 星期2:
                System.out.println("周二");
                break;
            case 星期3:
                System.out.println("周三");
                break;
            case 星期4:
                System.out.println("周四");
                break;
            case 星期5:
                System.out.println("周五");
                break;
            case 星期6:
                System.out.println("周六");

                break;
            case 星期7:
                System.out.println("周日");
                break;
        }
        System.out.println(Week.values()[6]);
    }
}
enum Week{
    星期1,星期2,星期3,星期4,星期5,星期6,星期7
}

在这里插入图片描述
递归：自己调用自己就是递归
递归结构包括两部分：
定义递归头：解答什么时候不调用自身方法，如果没有头，就会陷入死循环
递归体：什么时候调用自身方法

打印目录树
mport java.io.File;

//打印目录树

public class test_tree {
    public static void main(String[] args) {
        File f=new File("D:/下载/ha1");
        printFile(f,0);
    }

    static void printFile(File file, int level){
        //输出层数
        for(int i=0;i<level;i++){
            System.out.print("- ");
        }
        //输出文件名
        System.out.println(file.getName());
        //如果输出的是目录，则获取子文件列表
        if(file.isDirectory()){
            //获取目录中的子文件
            File[] files=file.listFiles();
            for(File temp:files){
                printFile(temp,level+1);
            }
        }
    }
}

星空辰梦

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
java初学者日志_常用类

Math类package com.math;public class test_01 { public static void main(String[] args) { int a=-1; int b=2; double d=3.54; //绝对值 System.out.println(Math.abs(a)); //b的3次幂 System.out.println(Math.po
复制链接

扫一扫