Java零基础(常用的类)_随着jdk版本的不断升级和发展-CSDN博客

本文链接：https://blog.csdn.net/weixin_48152652/article/details/124366326

文章目录

String类和StringBuffer类（掌握）

Java中定义了String和StringBuffer两个类来封装字符串，并提供了一系列操作字符串的方法，由于它们都位于java.lang 包中，所以不需要导包就可以直接使用。

String类常见的操作

public class Demo01 {
    public static void main(String[] args) {
        //string类的初始化
        String s="abcd";//通过字符串常量直接初始化化一个String对象，因为该类是final修饰的类，所以可以直接通过类直接进行初始化对象
        String str2= new String();//通过构造方法创建一个空字符串
        String str3= new String("abd");//通过构造方法创建一个字符串abd
        char[]charArray={'A','B'};// char[]charArray=new char[]{'A','B'},数组还可以这样定义
        String str4= new String(charArray);//通过构造方法创建一个字符数组的字符串

       //字符串的基本操作
        System.out.println("字符串的长度"+s.length());
        System.out.println("字符串中的第一个字符"+s.charAt(0));
        System.out.println("字符c第一次出现的位置"+s.indexOf('c'));
        System.out.println("子字符第一次出现的位置"+s.indexOf("ab"));
        System.out.println("子字符串最后一次出现的位置"+s.lastIndexOf("ab"));

        //字符串的转换操作
        String str="java";
        char[] array=str.toCharArray();//字符串转换为字符数组
        System.out.println("将int值转换为String类型之后的结果"+String.valueOf(12));//通过此方法可以把八大基本数据类型转换为string类型
        System.out.println("将字符串转换为大写之后的结果"+str.toUpperCase());

        //字符串的替换和去空格操作
        String st="   http://127.0.0.1:8080   ";
        System.out.println("去除字符串两端空格后结果"+st.trim());//只能去除首尾的空格
        System.out.println("去除字符串的所有空格结果"+st.replace("",""));//参数为空表示去除全部空格，有参数时表示替换

     //字符串判断操作
        String b="sthy";
        String c="dddd";
        System.out.println("判断是否以字符串st开头"+b.startsWith("st"));
        System.out.println("判断是否以字符串th结尾"+b.endsWith("th"));
        System.out.println("判断是否包含字符串gg"+b.contains("gg"));
        System.out.println("判断字符串是否为空"+b.isEmpty());
        System.out.println("判断字符串是相等"+b.equals(c));
        
   //字符串的截取和分割
        String v="2000-06-12";
        System.out.println("从第6个字符截取到末尾结果"+v.substring(5));
        System.out.println("从第6个字符截取到第7个字符结果"+v.substring(5,7));
        String[]varray=v.split("-");//通过横线连接符"-"将字符转换为字符数组

    }
}

StringBuffer类

在java中由于String类是final类型的，所以使用String定义的字符串是一个常量，一旦创建，长度不可变，而StringBuffer类（也称为字符串缓冲区）创建的字符串内容和长度都是可以改变的。它就类似一个字符容器，当在其中添加删除字符时，所操作都是这个容器，因此并不会产生新的StringBuffer对象。

StringBuffer类常用的方法

public class Demo02 {
    public static void main(String[] args) {
        //添加
        StringBuffer sb=new StringBuffer();//定义一个字符缓冲区
        sb.append("abc");//添加字符串,此方法始终把字符添加到缓冲区的末尾
        sb.insert(3,"de");//在指定字符串插入字符串，根据方法参数的不同，可以插入不同数据类型


       //修改
        StringBuffer sp=new StringBuffer();
        sp.setCharAt(2,'c');//修改指定位置的字符
        sp.replace(3,5,"fd");//替换指定位置字符串或字符
        sp.reverse();//字符串反转操作

         //删除
        sb.delete(3,7);//指定范围内删除
        sb.deleteCharAt(2);//删除指定位置
        sb.delete(0,sb.length());//清空缓冲区

        System.out.println(sb); System.out.println(sp);
    }

     /*  注意：
     1.String类重写了Object类的equals方法，
     而StringBuffer类没有重写，
     所以不能使用equals判断StringBuffer类，
     否则相等也会输出false
     2.String类对象可以用操作符+进行连接，而StringBuffer类不能，否则编译出错
      */
}

StringBuffer类和StringBuilder类

JDK1.5以后提供了一个StringBuilder类同样可以操作字符串，两者功能相似，且两个类提供的方法也基本相同。二者不同的是StringBuffer类是线程安全的，StringBuilder类没有实现线程安全功能，所以性能略高。通常情况下，如果创建一个内容可变的字符串对象，应该优先考虑StringBuilder类，性能高一点。

所以以上代码示例把StringBuffer换成StringBuilder同样能运行。

System类和Runtime类（了解）

System类

System类定义了一些关于系统相关属性和方法，它提供的属性和方法都是静态的，因此想要引用这些属性和方法，直接通过System类调用即可。

public class Demo03 {
    public static void main(String[] args) {
        Properties properties=System.getProperties();//获取当前系统的全部属性

        long startTime=System.currentTimeMillis();//开始的时间戳
        /*
        主程序
         */
        long endTime=System.currentTimeMillis();//结束的时间戳
        System.out.println("主程序执行的时间"+(startTime-endTime)+"毫秒");//由于处理器性能不同，程序运行时间会有所不同

        System.gc();//启动Java垃圾回收器，并且对内存中的垃圾对象进行回收
        System.exit(0);//终止当前正在运行的Java虚拟机，参数为0表示正常退出，否则表示异常终止
    }
}
//时间戳:该值表示当前时间与1970年1月1日0点0时0秒之间的时间差，单位为毫秒

Runtime类

在JDK的java.util包中Runtime类用于表示Java虚拟机运行时状态，它用于封装Java虚拟机的进程。

public class Demo04 {
    public static void main(String[] args) throws IOException, InterruptedException {
        Runtime rt=Runtime.getRuntime();//获取java程序关联的运行时对象
        System.out.println("处理器个数"+rt.availableProcessors()+"个");
        System.out.println("空闲内存大小"+rt.freeMemory()/1024/1024+"M");
        System.out.println("最大可使用内存"+rt.maxMemory()/1024/1024+"M");//以字节为单位计算，此处换成了以兆为单位

      rt.exec("notepad.exe");//此方法能执行一个DOS命令,返回一个process对象


        Process process=rt.exec("notepad.exe");//记事本3秒自动关闭的功能
        Thread.sleep(3000);//程序休眠3秒
        process.destroy();//关闭进程
    }
}

Math类和Random类

Math类

Math类是一个数学工具类，主要用于完成复杂数学运算，由于其构造方法被定义成private,因此无法创建Math类对象，但是里面都是静态的方法，可以直接通过类名来调用它们。除静态方法，Math类中还有两个静态常量PI和E，分别代表数学中π和e。

由于Math类比较简单，因此通过查看API文档来学习Math类的具体语法。
```
public class Demo05 {
    public static void main(String[] args) {
        System.out.println("计算正弦"+Math.sin(1.57));
        System.out.println("计算立方根"+Math.sqrt(9));
        System.out.println("计算乘方"+Math.pow(2,2));
        ystem.out.println("生成随机数"+Math.random());
    }
}
```

Random类

Random类可以指定取值范围内随机产生数字，相对于Math类的random（）方法而言,Random类提供了更多方法生成各种数据类型的伪随机数字。

public class Demo06 {
    public static void main(String[] args) {
        Random r=new Random();
        System.out.println("生成boolean类型的随机数"+r.nextBoolean());
        System.out.println("生成double类型的随机数"+r.nextDouble());
        System.out.println("生成int类型的随机数"+r.nextInt());
        System.out.println("生成0-10之间int类型的随机数"+r.nextInt(10));
        //生成其他数据类型随机数方法相似
    }
}

包装类(掌握)

虽然Java是面向对象的语言，但它包含的8种基本数据类型却不支持面向对象的编程机制（没有属性和方法）。Java之所以提供8种基本数据类型，是为了方便常规数据处理。在Java中，很多类的方法都需要接收引用类型的对象，此时就无法将数据类型的值传入。为了解决这个问题，jdk提供了一系列的包装类，通过这些包装类可以将基本数据类型的值包装为引用数据类型的对象。

包装类和基本类型在进行转换时引入了自动装箱和自动拆箱概念（不过一般不使用这种方法进行转换）

public class Demo07 {
    public static void main(String[] args) {
        int a=20;
        //自动装箱
        Integer b=20;
        //自动拆箱
        int c=b;
    }
}

除了基本数据类型和字符串之间的转换，java还提供了其他方法来支持基本数据类型，基本数据包装类以及字符串之间的相互转换

public class Demo08 {
    public static void main(String[] args) {
        int num=123;
        String string=String.valueOf(num);//此方法可以把八大基本数据类型都转换为字符串
      
        //通过包装类的valueOf()静态方法将基本类型和字符串转换为包装类
        String str="996";
        Integer integer=Integer.valueOf(num);
        Integer integer2=Integer.valueOf(str);
        System.out.println("将int变量转换为包装类结果"+integer);
        System.out.println("将字符串变量转换为包装类结果"+integer2);
      
        //通过包装类的有参构造方法将基本类型和字符串转换为包装类
        Integer integer3=new Integer(num);
        Integer integer4=new Integer(str);
        System.out.println("通过构造器将int变量转换为包装类结果"+integer3);
        System.out.println("通过构造器将字符串变量转换为包装类结果"+integer4);
      
        //通过包装类的的ParseIntXxx()方法将字符串转换为基本类型
        int pareInt=Integer.parseInt(str);
        float d=Float.parseFloat(str);
        System.out.println("将字符串转换为基本类型的结果"+pareInt+d);
      
        //通过包装类的toString()方法将包装类转换为字符串
        String s=integer.toString();
        System.out.println("将包装类转换为字符串结果"+s);
    }
}

日期与时间类

Date类

随着JDK版本不断升级和发展，Date类已经很少使用，只需要连接如果通过创建对象和封装时间值即可

public class Demo09 {
    public static void main(String[] args) {
        Date date1=new Date();
        //获取当前时间后1秒的时间
        Date date2=new Date(System.currentTimeMillis()+1000);
        System.out.println("当前时间"+date1+"后一秒时间"+date2);
    }
}

Calendar类

该类可以操作年，月，日，分，秒等，Calendar类是一个抽象类，所以不能被实例化，需要调用其静态方法getInstance()来得到一个Calendar对象，然后才能调用其他相应的方法

public class Demo09 {
    public static void main(String[] args) {
        Calendar calendar=Calendar.getInstance();
//        int year=calendar.get(Calendar.YEAR);//获取年份
//        int month=calendar.get(Calendar.MONTH)+1;//获取月
//        int date=calendar.get(Calendar.DATE);//获取日
        //获取时分秒类似

        //设置指定日期
       calendar.set(2022,4,22);
        //为指定日期添加时间
        calendar.add(Calendar.DATE,100);
        int year=calendar.get(Calendar.YEAR);//获取年份
        int month=calendar.get(Calendar.MONTH)+1;//获取月，由于月份是从0开始计算，所以新需要加1
        int date=calendar.get(Calendar.DATE);//获取日
        System.out.println("计划完成Java学习时间为:"+year+"年"+month+"月"+date+"日");
    }
}

JDK8的日期与时间类

为满足更多的需求，JDK8比之前的版本添加了一个java.time包，该包下包含了更多的日期与时间操作类

public class Demo10 {
    public static void main(String[] args) {
        // Clock 使用
        Clock clock=Clock.systemUTC();
        System.out.println("世界标准时间(UTC)"+clock.instant());//世界标准时间和中国标准时间相差整整8个小时
        System.out.println("世界标准时间(UTC)"+clock.instant().toString().substring(0,10));

        //LocateDate使用
        LocalDate localDate=LocalDate.now();
        System.out.println("从默认时区的系统时钟获得当前日期"+localDate);

        //LocalTime使用
        LocalTime localTime=LocalTime.now();
        System.out.println("从默认时区的系统时钟获得当前时间"+localTime);

        //LocalDateTime使用
        LocalDateTime localDateTime=LocalDateTime.now();
        System.out.println("中国标准时间（CTS）"+" "+localDateTime);
        LocalDateTime time=localDateTime.plusDays(1).plusHours(3).minusMinutes(30);
        System.out.println("当前日期,1天3小时30分之后"+time);

        //Year，YearMonth,MonthDay使用
        Year year=Year.now();
        System.out.println("当前年份"+year);
        YearMonth yearMonth=YearMonth.now();
        System.out.println("当前月份"+yearMonth);
        MonthDay monthDay=MonthDay.now();
        System.out.println("当前月日"+monthDay);

        //获取系统默认时区
        ZoneId zoneId=ZoneId.systemDefault();
        System.out.println("当前系统默认时区"+zoneId);
    }
}

格式化类

使用Date类默认打印时间都是英文格式，如果想指定日期以指定格式输出需要用到DateFormat类和SimpleDateFormat类等

public class Demo11 {
    public static void main(String[] args) {
        //DateFormat类
        DateFormat fullFormat=DateFormat.getDateInstance(DateFormat.FULL);
        System.out.println("当前日期完整格式"+fullFormat.format(new Date()));
        DateFormat longFormat=DateFormat.getDateInstance(DateFormat.LONG);
        System.out.println("当前日期长格式"+longFormat.format(new Date()));

        //SimpleDateFormat类
        SimpleDateFormat date=new SimpleDateFormat("yyyy年MM月dd日");
        System.out.println(date.format(new Date()));
    }

}