Java学习笔记-06【API】

于 2022-07-09 01:52:39 发布
阅读量183 收藏
点赞数
分类专栏： Java学习笔记 文章标签： java 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaochen_2715/article/details/125688582
版权

Java学习笔记-06【API】

API（Application Programming Interface）指的是应用程序编程接口。

String类

String初始化有两种，一个是使用字符串常量初始化一个String对象：String s = "abc"；还有一种是使用String构造方法初始化字符串：

public class Test{
    public static void main(String[] args) {
        //创建一个空字符串
        String str1 = new String();
        //创建一个内容为abcd的字符串
        String str2 = new String("abcd");
        char[] ch = new char[]{'A','B','C','D'};
        //创建一个内容为字符数组的字符串
        String str3 = new String(ch);
        System.out.println(str1+"|"+str2+"|"+str3);
    }
}

运行结果：

|abcd|ABCD

String中的equals()

“==”和“equals()”区别

都可以通过这两种方式对字符串进行比较。equals()方法用于比较两个字符串中的字符是否相等；==方法用于比较字符串对象的地址是否相同。

public class Test{
    public static void main(String[] args) {
       String a = "abc";
       String b = "abc";
        System.out.println(a.equals(b));
        System.out.println(a==b);
    }
}

运行结果：

true
true

当创建两个字符串对象时，

public class Test{
    public static void main(String[] args) {
       String a = new String("abc");
       String b = new String("abc");
        System.out.println(a.equals(b));
        System.out.println(a==b);
    }
}

运行结果：

true
false

String中常用API

方法声明功能描述示例
int indexOf(int ch)返回指定字符在此字符串中第一次出现处的索引System.out.println(“abcdedcba”.indexOf(‘c’));
2
int lastIndexOf(int ch)返回指定字符在此字符串中最后一次出现处的索引System.out.println(“abcdedcba”.lastIndexOf(‘c’));
6
char charAt(int index)返回指定字符串中index位置上的字符，其中index的取值范围是：0~（字符串长度-1）System.out.println(“abcdedcba”.charAt(0));
a
boolean endsWith(String suffix)判断此字符串是否以指定的字符串结尾System.out.println(“abcd”.endsWith(“cd”));
true
boolean startsWith(String prefix)判断此字符串是否以指定的字符串开始System.out.println(“abcd”.startsWith(“ab”));
true
boolean isEmpty()判断此字符串中是否包含指定的字符序列System.out.println(“abcd”.contains(“bc”));
System.out.println(“abcd”.contains(“ac”));
true
false
boolean contains(CharSequence cs)将此字符串与指定的字符串比较System.out.println(“abcd”.equals(“dcba”));
false
boolean equals(Object anObject)将此字符串与指定的字符串比较System.out.println(“abcd”.equals(“dcba”));
false
int compareTo(String)比较两个字符串，并返回字符串中第一个字母ASCII的差值。//H–72 h–104
System.out.println(“Hello World”.compareTo(“hello world”));
-32
int compareToIgnoreCase(String)比较两个字符串，并返回字符串中第一个字母ASCII的差值。忽略大小写System.out.println(“Hello World”.compareToIgnoreCase(“hello world”));
0
boolean regionMatches(int toffset, String other, int ooffset,int len)
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)		测试两个字符串区域是否相等。
ignoreCase-如果为true ，则在比较字符时忽略大小写。
toffset-此字符串中子区域的起始偏移量
other-字符串参数
ooffset-字符串参数中子区域的起始偏移量
len-要比较的字符数		String str1 = “Welcome to Microsoft”;
String str2 = “I work with microsoft”;
boolean match1 = str1.regionMatches(11, str2, 12, 9);
boolean match2 = str1.regionMatches(true, 11, str2, 12, 9);
System.out.println(“区分大小写返回值：” + match1);
System.out.println(“不区分大小写返回值：” + match2);
false
true
int length()返回字符串的长度System.out.println(“abcdedcba”.length());
9
String toLowerCase()使用默认语言的规则将String中的所有字符串转换为小写System.out.print(“ABcd”.toLowerCase());
abcd
String toUpperCase()使用默认语言的规则将String中的所有字符串转换为大写System.out.print(“ABcd”.toUpperCase());
ABCD
String valueOf(int i)返回int参数的字符串表示形式System.out.print(String.valueOf(12));
12
Char[] toCharArray()将此字符串转换为一个字符数组char[] c=“abcd”.toCharArray();
for(int i=0;i<c.length;i++){System.out.print(c[i]+”,”);}
a,b,c,d,
String replace(CharSequence oldstr,CharSequence newstr)返回一个新的字符串，它是通过用newstr替换此字符串中出现的所有oldstr得到的System.out.println(“itcast”.replace(“it”,“cn.it”));
cn.itcast
String[] split(String regex)根据参数regex将原来的字符串分割为若干个 子字符串String[] str=“abc-de-fgh”.split(“-”);
for(int i=0;i<str.length;i++)System.out.println(str[i]);
abc
de
fgh
String substring(int beginIndex)返回一个新字符串，它包含字符串中索引beginIndex后的所有字符System.out.println(“abc-de-fgh”.substring(4));
de-fgh
String substring(int beginIndex,int endIndex)返回一个新字符串，它包含字符串中索引beginIndex到索引endIndex之间的所有字符System.out.println(“abc-de-fgh”.substring(4,6));
de
String trim()返回一个新的字符串，它去除了原字符串首尾的空格System.out.println(" i t c a s t ".trim());
i t c a s t

StringBuffer类

StringBuffer类和String类最大的区别在于它的内容和长度是可以改变的。StringBuffer在其中添加和删除字符时，并不会产生新的StringBuffer对象。

public class Test{
    public static void main(String[] args) {
        System.out.println("1.添加----------");
        add();
        System.out.println("2.删除----------");
        remove();
        System.out.println("3.修改----------");
        alter();
    }
    public static void add(){
        StringBuffer sb = new StringBuffer();   //定义一个字符串缓冲区
        sb.append("abcdefg");   //在末尾添加字符串
        System.out.println("append添加结果："+sb);
        sb.insert(2,"123"); //在指定位置插入字符串
        System.out.println("insert添加结果："+sb);
    }
    public static  void remove(){
        StringBuffer sb = new StringBuffer("abcdefg");  //创建一个非空的字符串对象
        sb.delete(1,5); //指定范围删除
        System.out.println("delete删除结果："+sb);
        sb.deleteCharAt(2); //指定位置删除
        System.out.println("deleatCharAt删除结果："+sb);
        sb.delete(0,sb.length());   //清空缓冲区
        System.out.println("delete清空缓冲区结果："+sb);
    }
    public static void alter(){
        StringBuffer sb = new StringBuffer("abcdef");
        sb.setCharAt(1,'p');    //修改指定位置字符
        System.out.println("setCharAt修改指定位置字符结果："+sb);
        sb.replace(1,2,"qq");   //替换指定位置字符或字符串
        System.out.println("replace替换指定位置字符或字符串结果："+sb);
        sb.reverse();   //翻转字符串
        System.out.println("reverse翻转字符串结果："+sb);
    }
}

运行结果：

1.添加----------
append添加结果：abcdefg
insert添加结果：ab123cdefg
2.删除----------
delete删除结果：afg
deleatCharAt删除结果：af
delete清空缓冲区结果：
3.修改----------
setCharAt修改指定位置字符结果：apcdef
replace替换指定位置字符或字符串结果：aqqcdef
reverse翻转字符串结果：fedcqqa

注：String类重写了Object类的equals()方法，而StringButter类没有。

所以要比较StringBuffer的字符串是否相等，需要用toString()转换成String类再进行比较。

String a = new String("abc");
String b = new String("abc");
System.out.println(a.equals(b));   //结果为true
StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb1.equals(sb2));   //结果为false

System类

System类定义了一些与系统相关的属性和方法，它所提供的属性和方法都是静态的。

static Properties getProperties()

getProperties()方法用于获取当前系统的全部属性，该方法会返回一个Properties对象。

import java.util.Enumeration;
import java.util.Properties;
public class Test{
    public static void main(String[] args) {
        //获取当前系统属性
        Properties properties = System.getProperties();
        //获取所有系统属性的key，返回Enumeration对象
        Enumeration propertyNames = properties.propertyNames();
        while(propertyNames.hasMoreElements()){
            //获取系统属性的键key
            String key = (String)propertyNames.nextElement();
            //获取当前键对应的值value
            String value = System.getProperty(key);
            System.out.println(key+"--->"+value);
        }
    }
}

static long currentTimeMillis()

返回long值，该值表示当前时间与1970年1月1日8点0分0秒之间的时间差，单位毫秒，习惯性的被称作时间戳。

public class Test{
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();    //循环开始的当前时间
        int sum = 0;
        for(int i=0;i<100000;i++){
            for (int j=0;j<=i;j++)
                sum++;
        }
        long endTime = System.currentTimeMillis();  //循环结束的当前时间
        System.out.println("程序运行的时间为："+(endTime-startTime)+"毫秒");
    }
}

static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

该方法用于将一个数组中的元素快速拷贝到另一个数组。其中src（源数组），dest（目标数组），srcPos（源数组中拷贝元素的起始位置），destPos（拷贝到目标数组的起始位置），length（拷贝元素的个数）。

public class Test{
    public static void main(String[] args) {
        int[] fromArray = {101,102,103,104,105,106};    //源数组
        int[] toArray = {201,202,203,204,205,206,207};  //目标数组
        System.arraycopy(fromArray,2,toArray,3,4);  //拷贝数组元素
        //打印目标数组中的元素
        for(int i=0;i<toArray.length;i++){
            System.out.println(i+": "+toArray[i]);
        }
    }
}

运行结果：

0: 201
1: 202
2: 203
3: 103
4: 104
5: 105
6: 106

其他常用

除此之外，常用的还有 System.gc(); 垃圾回收，System.exit(int status); 终止当前正在运行的Java虚拟机，status表示状态码，非0表示异常终止。

Runtime类

Runtime类用于表示虚拟机运行时的状态，用于封装JVM虚拟机进程。该类采用的是单例模式设计，对象不可以被实例化，只能通过“Runtime run = Runtime.getRuntime()”方式创建一个Runtime的实例对象。

public class Test{
    public static void main(String[] args) {
        Runtime rt = Runtime.getRuntime();  //获取
        System.out.println("处理器个数： "+rt.availableProcessors()+"个");
        System.out.println("空闲内存数量： "+rt.freeMemory()/1024/1024+"M");
        System.out.println("最大可用内存数量： "+rt.maxMemory()/1024/1024+"M");
    }
}

运行结果：

处理器个数： 16个
空闲内存数量： 232M
最大可用内存数量： 3506M

Runtime类提供了exec()方法，用于执行一个dos命令。

public class Test{
    public static void main(String[] args) {
        Runtime rt = Runtime.getRuntime();  //创建Runtime实例对象
        //捕获异常里调用exec()方法打开记事本
        try{rt.exec("notepad.exe");}catch(Exception e){e.printStackTrace();}
    }
}

exec()方法返回一个Process对象，该对象表示操作系统的一个进程，关闭此进程只需调用destroy()方法即可。

以下是打开记事本3秒后自动关闭：

public class Test{
    public static void main(String[] args) {
        Runtime rt = Runtime.getRuntime();  //创建Runtime实例对象
        //捕获异常里调用exec()方法打开记事本
        try{
            Process process = rt.exec("notepad.exe");   //得到表示进程的Process对象
            Thread.sleep(3000);     //程序休眠3秒
            process.destroy();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

Math类

public class Test{
    public static void main(String[] args) {
        System.out.println("计算绝对值: "+Math.abs(-1));
        System.out.println("求大于参数的最小整数: "+Math.ceil(5.4));
        System.out.println("求小于参数的最大整数: "+Math.floor(-5.2));
        System.out.println("对小数四舍五入: "+Math.round(-4.6));
        System.out.println("生成一个最接近参数的整数值: "+Math.rint(10.5));//除了0.5这个值其他的和四舍五入相同
        System.out.println("求两个数的较大值: "+Math.max(1,2.0));
        System.out.println("求两个数的较小值: "+Math.min(1,2.0));
        System.out.println("生成一个大于等于0.0小于1.0随机值: "+Math.random());
        System.out.println("e的值: "+Math.E);
        System.out.println("e的参数次方： "+Math.exp(1.0));
        System.out.println("参数的自然底数的对数值: "+Math.log(Math.E));
        System.out.println("返回第一个参数的第二个参数次方: "+Math.pow(2,3));
        System.out.println("返回参数的算数平方根: "+Math.sqrt(16));
    }
}

运行结果：

计算绝对值: 1
求大于参数的最小整数: 6.0
求小于参数的最大整数: -6.0
对小数四舍五入: -5
生成一个最接近参数的整数值: 10.0
求两个数的较大值: 2.0
求两个数的较小值: 1.0
生成一个大于等于0.0小于1.0随机值: 0.1599159306911967
e的值: 2.718281828459045
e的参数次方： 2.718281828459045
参数的自然底数的对数值: 1.0
返回第一个参数的第二个参数次方: 8.0
返回参数的算数平方根: 4.0

Random类

在JDK的java.util包中有一个Random类，它可以在指定的取值范围内随机产生数字。Random类提供了两个构造方法：

  • Random()用于创造一个伪随机数生成器；
  • Random(long seed)使用一个long型的seed种子创建伪随机数生成器。

无参的构造方法每次使用的种子是随机的，所以产生的随机数不同，而有参的构造方法运行多次产生的随机数是相同的。

import java.util.Random;
public class Test{
    public static void main(String[] args) {
        Random r = new Random();
        //随机产生5个[0,100)的随机数
        for(int i=0;i<5;i++){
            System.out.println(r.nextInt(100));
        }
    }
}

第一次运行结果：

43
60
88
84
82

第二次运行结果：

80
58
59
69
27

import java.util.Random;
public class Test{
    public static void main(String[] args) {
        Random r = new Random(1);   //创建对象时传入种子
        //随机产生5个[0,100)的随机数
        for(int i=0;i<5;i++){
            System.out.println(r.nextInt(100));
        }
    }
}

第一次运行结果：

85
88
47
13
54

第二次运行结果：

85
88
47
13
54

Random类的常用方法

方法声明功能描述
boolean nextBoolean()随机生成boolean类型的随机数
double nextDouble()随机生成double类型的随机数
float nextFloat()随机生成float类型的随机数
int nextInt()随机生成int类型的随机数
int nextInt(int n)随机生成0~n之间int类型的随机数
long nextLong()随机生成long类型的随机数

包装类

通过包装类可以将基本类型的值包装成引用数据类型的对象。

除了char对应Character，int对应Integer外，其他都是将首字母大写即可。

包装类和基本数据类型转换时，引入了装箱（将基本数据类型的值转为引用数据类型）和拆箱（将引用数据类型的值转为基本数据类型）的概念。

装箱：

public class Test{
    public static void main(String[] args) {
        int a = 20;
        Integer i = new Integer(a);
        System.out.println(i.toString());
    }
}

运行结果：

20

拆箱：

public class Test{
    public static void main(String[] args) {
        Integer i = new Integer(20);
        int a = 10;
        int num = i.intValue()+a;
        System.out.println(num);
    }
}

运行结果：

30

Integer类常用方法

方法声明功能描述
toBinaryString(int i)以二进制无符号整数形式返回一个整数参数的字符串
toHexString(int i)以十六进制无符号整数形式返回一个整数参数的字符串
toOctalString(int i)以八进制无符号整数形式返回一个整数参数的字符串
valueOf(int i)返回一个表示指定的int值的Integer实例
valueOf(String s)返回保存指定的String值的Integer对象
parseInt(String s)将字符串参数作为有符号的十进制整数进行解析
intValue()将Integer类型的值以int类型返回
public class Test{
    public static void main(String[] args) {
        System.out.println("10的二进制表示："+Integer.toBinaryString(10));
        System.out.println("10的八进制表示："+Integer.toOctalString(10));
        System.out.println("10的十六进制表示："+Integer.toHexString(10));
        System.out.println("二进制1010的十进制表示："+Integer.valueOf("1010",2));
        System.out.println("八进制-12的十进制表示："+Integer.valueOf("-12",8));
        System.out.println("十六进制a的十进制表示："+Integer.valueOf("a",16));
        System.out.println("二进制-1010的十进制表示"+Integer.parseInt("-1010",2));
        System.out.println("八进制12的十进制表示："+Integer.parseInt("12",8));
        System.out.println("十六进制-a的十进制表示："+Integer.parseInt("-a",16));
        System.out.println(Integer.valueOf("-15"));
        System.out.println(Integer.parseInt("-15"));
        int a = new Integer(10).intValue(); //Integer实例对象.intValue()
        int b = Integer.valueOf(10).intValue(); //Integer.valueOf(int i)就是表示一个指定int值的Integer实例
        int c = Integer.valueOf("-10").intValue();  //Integer.valueOf(String s)就是表示一个指定String值的Integer实例
        System.out.println("a:"+a+" b:"+b+" c:"+c);
    }
}

运行结果：

10的二进制表示：1010
10的八进制表示：12
10的十六进制表示：a
二进制1010的十进制表示：10
八进制-12的十进制表示：-10
十六进制a的十进制表示：10
二进制-1010的十进制表示-10
八进制12的十进制表示：10
十六进制-a的十进制表示：-10
-15
-15
a:10 b:10 c:-10

注：

  1. 包装类都重写了toString()方法，以字符串形式返回；

  2. 除了Character外，包装类都有valueOf(String s)方法，字符串s不能为null而且必须能解析成相应的基本数据类型，可以根据String类型的参数创建包装类对象：

    Integer i = Integer.valueOf("123");

  3. 除了Character外，包装类都有parseXXX(String s)的静态方法，字符串s不能为null而且必须能解析成相应的基本数据类型，将字符串转换为对应基本类型数据：

    int i = Integer.parseInt(“123”);

三种日期类

Date类

Date类中无参的构造方法Date()用来创建当前时间的Date对象，接收long型参数的构造方法Date(long date)，date参数表示1970.01.01 08:00:00(称为历元)以来的毫秒数。

import java.util.Date;
public class Test{
    public static void main(String[] args) {
        Date date1 = new Date();
        Date date2 = new Date(100000L);
        Date date3 = new Date(System.currentTimeMillis());
        System.out.println(date1);
        System.out.println(date2);
        System.out.println(date3);
    }
}

运行结果：

Sat Oct 05 14:26:24 CST 2019
Thu Jan 01 08:01:40 CST 1970
Sat Oct 05 14:26:24 CST 2019

Calendar类

Calendar类可以设置和读取日期特定部分，是抽象类，不能被实例化，需要调用其静态方法getInstance()来得到一个Calendar对象。

Calendar的常用方法

方法声明功能描述
int get(int field)返回指定日历字段的值
void add(int field,int amount)根据日历规则，为指定的日历字段增加或减去指定的时间量
void set(int field,int value)为指定日历字段设置指定值
void set(int year,int month,int date)设置Calendar对象的年月日三个字段的值
void set(int year,int,mouth,int date,int hourOfDate,int minute,int second)设置Calendar对象的年月日时分秒六个字段的值

上面field参数需要接收Calendar类中定义的常量值，要注意的是Calendar.MONTH字段月份是从0开始的不是1。

import java.util.Calendar;
public class Test{
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();//获取表示当前时间的Calendar对象
        int year = calendar.get(Calendar.YEAR); //获取当前年
        int month = calendar.get(Calendar.MONTH)+1; //获取当前月
        int date = calendar.get(Calendar.DATE); //获取当前日
        int hour = calendar.get(Calendar.HOUR); //获取当前时
        int minute = calendar.get(Calendar.MINUTE); //获取当前分
        int second = calendar.get(Calendar.SECOND); //获取当前秒
        System.out.println("当前时间： "+calendar.getTime());    //getTime()获取时间
        System.out.println("当前时间： "+year+"年"+month+"月"+date+"日"+hour+"时"+minute+"分"+second+"秒");
    }
}

运行结果：

当前时间： Sat Oct 05 15:29:37 CST 2019
当前时间： 2019年10月5日3时29分37秒

import java.util.Calendar;
public class Test{
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(2019,10,1);//  修改z时间为2019.10.01
        calendar.add(Calendar.DATE,100);    //日  加100天
        System.out.println("2019.10.01的100天后是"+calendar.get(Calendar.YEAR)+"."+calendar.get(Calendar.MONTH+1)+"."+calendar.get(Calendar.DATE));
    }
}

运行结果：

2019.10.01的100天后是2020.7.9

Calendar有两种解释：日历字段的模式–lenient模式（默认模式）和non-lenient模式。Calendar.MONTH取值是0~11，当超过数值时比如13，会设置为“一年两个月”，当改为non-lenient模式时，会抛出异常。

import java.util.Calendar;
public class Test{
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();//当前时间为2019.10.5
        //将MONTH字段设置为13
        calendar.set(Calendar.MONTH,13);
        System.out.println(calendar.getTime());
        //开启non-lenient模式
        calendar.setLenient(false);
        calendar.set(Calendar.MONTH,13);
        System.out.println(calendar.getTime());
    }
}

运行结果：

Wed Feb 05 15:46:15 CST 2020
Exception in thread "main" java.lang.IllegalArgumentException: MONTH

Calendar的getTime()方法返回一个表示Calendar时间值的Date对象，Calendar的setTime(Date date)方法接收一个Date对象，通过这两个方法就可以完成Date和Calendar对象的转换。

Calendar.getInstance().setTime(new Date());

DateFormat

DateFormat类是抽象类，不能被直接实例化，可以用它的四个静态方法获取，它们可以分别对日期或者时间部分进行格式化。

FULL常量表示完整格式，LONG常量表示长格式，MEDIUM常量表示普通格式，SHORT常量表示短格式。

import java.text.DateFormat;
import java.util.Date;
public class Test{
    public static void main(String[] args) {
        Date date = new Date();
        //FULL格式的日期格式器对象
        DateFormat fullFormat = DateFormat.getDateInstance(DateFormat.FULL);
        System.out.println("FULL格式："+fullFormat.format(date));
        DateFormat fullFormat1 = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL);
        System.out.println("FULL格式："+fullFormat1.format(date));
        //LONG格式的日期格式器对象
        DateFormat longFormat = DateFormat.getDateInstance(DateFormat.LONG);
        System.out.println("LONG格式："+longFormat.format(date));
        DateFormat longFormat1 = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
        System.out.println("LONG格式："+longFormat1.format(date));
        //MEDIUM格式的日期格式器对象
        DateFormat mediumFormat = DateFormat.getDateInstance(DateFormat.MEDIUM);
        System.out.println("MEDIUM格式："+mediumFormat.format(date));
        DateFormat mediumFormat1 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM);
        System.out.println("MEDIUM格式："+mediumFormat1.format(date));
        //SHORT格式的日期格式器对象
        DateFormat shortFormat = DateFormat.getDateInstance(DateFormat.SHORT);
        System.out.println("SHORT格式："+shortFormat.format(date));
        DateFormat shortFormat1 = DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT);
        System.out.println("SHORT格式："+shortFormat1.format(date));
    }
}

运行结果：

FULL格式：2019年10月5日星期六
FULL格式：2019年10月5日星期六 中国标准时间 下午4:37:51
LONG格式：2019年10月5日
LONG格式：2019年10月5日 CST 下午4:37:51
MEDIUM格式：2019年10月5日
MEDIUM格式：2019年10月5日 下午4:37:51
SHORT格式：2019/10/5
SHORT格式：2019/10/5 下午4:37

getDateInstance()方法获得的实例对象用于对日期部分进行格式化，getDateTimeInstance()方法获得的实例对象用于对日期和时间进行格式化。DateFormat类还提供了parse(String source)方法，将字符串解析成Date对象，该方法需要捕获异常。

import java.text.DateFormat;
public class Test{
    public static void main(String[] args) {
        //创建LONG格式的DateFormat对象
        DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
        String d = "2000年10月1日";
        try{
            System.out.println(df.parse(d));    //字符串解析
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：

Sun Oct 01 00:00:00 CST 2000
SimpleDateFormat类

SimpleDateFormat类是DateFormat的子类，可以使用new关键字创建实例对象，它的构造方法接收一个格式字符串参数，表示日期格式模板。

import java.text.SimpleDateFormat;
import java.util.Date;
public class Test{
    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("Gyyyy年MM月dd日E,第D天");
        System.out.println(sdf.format(new Date()));
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MMM/dd");
        String dt = "2009/五月/03";
        try{
            System.out.println(sdf1.parse(dt));    //字符串解析
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：

公元2019年10月05日周六,第278天
Sun May 03 00:00:00 CST 2009
小辰~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java API学习笔记
m0_48936146的博客
04-12 936
一、字符串类 1.1 String类的初始化，几个常见的构造方法 String() //创建一个内容为空的字符串 String(String value) //根据指定的字符串内容创建对象 String(char[] value) //根据指定的字符数组创建对象 String(byte[] bytes) //根据指定的字节数组创建对象 String测试案例 public class test8 { public static void main(String[] args)throw.
javaSE试题(二)
司天宏的博客
01-07 5492
一、填空题（共20个题目，总计20分） 1.Java虚拟机就是一个虚拟的用于执行 字节码文件 .class 的计算机。它是Java最核心的技术，是Java跨平台的基础。 2.使用Java开发应用程序包括编写源程序，编译源程序，解释并运行三个步骤，其中编译和解释分别需要使用javac.exe和 java.exe 实现。 3.一个十进制整数转换成八进制数后是12...
java基础面试（二）
weixin_42709333的博客
06-02 175
（四）下面程序是否有问题？如果存在请说出问题所在，如果不存在，说明输出结果。 public class Test{ public static void main(String args[]){ Test t = new Test(); int i = 0; t.increase(i); i = i++; ...
Java基础知识004
hahaEverybody的博客
04-08 733
1. 不可变类 不可变类是指当创建了这个类的实例后，就不允许修改它的值了。 所有基本类型的包装类都是不可变类，String也是不可变类。 public class Test { public static void main(String[] args) { String s="hello"; s+="world"; System.out.println(s); } } 表面上看...
java 基础题目--01
最后的武艺集大成者
01-15 739
  1.输出结果多少？ class Test { public static void main(String[] args) { System.out.println(new B().getValue()); } static class A { protected int value; public A (int v...
java学习笔记-java思维导图流程图表格整理
11-19
在Java的学习过程中，了解并掌握基本语法和核心概念至关重要。以下是一些关键知识点的详细说明： 1. **命令行运行Java程序**： 使用`javac`编译器将`.java`源代码文件编译为`.class`字节码文件，例如`javac -...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java JDK7学习笔记-光盘
08-20
《Java JDK7学习笔记》是作者多年来教学实践经验的总结，汇集了教学过程中学生在学习java时遇到的概念、操作、应用或认证考试等问题及解决方案。《Java JDK7学习笔记》针对java se 7新功能全面改版，无论是章节架构...
java学习笔记--PrintStream分享.pdf
12-07
Java学习笔记--PrintStream分享 PrintStream是一种输出流，能够将Java基本数据类型转换为系统预设编码下的字元，再输出至OutputStream中。在Java I/O流中，PrintStream是OutputStream的子类，主要用于将数据输出至...
2022年Java学习笔记-Java课程配套案例.rar
最新发布
12-19
这份"2022年Java学习笔记-Java课程配套案例.rar"压缩包文件显然是为了帮助学习者深入理解Java编程，通过实践案例来巩固理论知识。下面将详细探讨Java语言的一些核心知识点，并结合压缩包中的案例进行说明。 1. **...
java入门基础(四)
qq_45798550的博客
08-15 2145
（一）对象和类 类:类是对象的抽象(不存在) 对象:对象是类的实现(具体存在) 现实生活中先有对象再有类 Java中先有类再有对象 面向对象:是一种思想,在开发过程中关注于对象进行开发 类中相同的行为和特征在Java中如何表示 特征:变量 行为:方法 类的定义: 1.public class 类名{} 2.定义成员变量 格式:public 数据类型 变量名 3.定义成员方法 格式:public 返回值数据类型 方法名称(参数){} 类的使用(对象): 1.通过类创建对象 格式:类名 对象名=
关于public class 类名{ public static void main(String[] args)}的一些说明
热门推荐
Xue_fabulous的博客
12-28 1万+
1、在java中任何有效的代码必须写到“类体”当中，最外层必须是一个类的定义。 2、public表示公开的，class表示定义一个类，Test是一个类名。类名后面必须是 一对大括号，这一对大括号被称为“类体” 3、大括号必须是成对的。并且建议都要成对编写，这样才不会丢掉。 {} [] () 4、什么时候代码缩进？ 我包着你，你就比我低一级。你就需要缩进。 没有合理的缩进，代码可读性很差。 或者也可以这样所，大括号里的都需要缩进。 缩进就是可读性问题，不缩进也不影响程序的编译和执行。 ...
public static void main (String[] args) 详解
YelloJesse的博客
08-18 8237
1 public static void main (String[] args) public static void main (String[] args) 是Java程序的入口方法，JVM在运行程序时，会先查找 main() 方法。 public是权限修饰符，表明任何类或对象都可以访问这个方法。 static表明mian()方法是一个静态方法，即方法中的代码是存储在静态存储区的，...
Java字符串基础问题
Apple_Boy的博客
09-08 1011
题目一 public class Test{ public static void main(String[] args){ String s1 = "abc"; String s2 = s1; String s3 = new String("abc"); String s4 = new String("abc"); String s5 = "ab...
public static void main(String args[])什么意思？
weixin_33675507的博客
03-09 923
　　public static void main(String[] args) 　　这绝对不是凭空想出来的，也不是没有道理的死规定，而是java程序执行的需要。 　　jvm在试图运行一个类之前，先检查该类是否包含一个特殊方法。这个方法必须是公有的，以便在任何位置都能访问得到。这个方法必须是static的，因为这个方法不能依赖任何该类的实例即可运行，而非static的方法，在运行之前要先创建该...
Java面试笔试-003-public static void main(String[] args)
qq_33605778的博客
04-23 5240
描述1）publicpublic是权限修饰符，表明任何类或对象都可以访问这个方法。2）staticstatic表明main()方法是一个静态方法，即方法中的代码是存储在静态存储区的，只要类被加载后，就可以使用该方法而不需要通过实例化对象来访问，可以直接通过类名.main()直接访问，JVM在启动时就是按照上述方法的签名（必须有public与static修饰，返回值为void,且方法的参数为字符中数组
java编程题
Echoxxxxx的博客
01-19 743
1.取出一个字符串中字母出现的次数，如：“abcdekka27qoq”输出格式a(2)b(1)k(2)… public class Test { public static void main(String[] args) { String str = "abcdekka27qoq"; char[] cs = str.toCharArray(); TreeMap<Character, Integer> map = new TreeMap<>(); for(int
【java期末复习题】第8章 常用实用类
DynamoTUO的博客
06-25 2981
第8章 常用实用类 1．获取字符串长度应该使用下列哪个方法？（ ）。 A、length B、length() C、codePointAt() D、chatAt() 2．当编译和运行下列代码时会发生什么？（ ）。 public class Test { public static void main(String[] args) { System.out.println("" + 2 + 3); System.out.println
Java编程练习 String类
gegejiawei的博客
07-28 263
编程 1、倒序输出字符串 2、给定一个字符串 判断该字符串中是否包含某个字符串 如果包含 求出子串的所有出现位置 如："abcd23abc34bcd"中"bc"子串的出现位置 3、判断字符串是否是回文数 4、将驼峰字符串转化为下划线字符串 5、给定一个字符串数组 按照字典顺序进行大小写排序 package project0728; /** * (1)倒序输出字符串 */ public class Test1 { public static void main(String[] args) { S
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小辰~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值