JAVA中常用类的常用方法
java中类的用法
java中类的用法Java是一种面向对象的编程语言，类是面向对象编程的基本概念之一。
在Java中，类是一种模板，它用来描述一类对象的方法和属性。
可以通过创建类的对象来使用它的方法和属性。
本文将介绍Java中类的用法。
一、定义类Java中定义类的语法如下：```java public class ClassName { // 类的成员变量 // 类的构造函数 // 类的方法 } ```其中，类名要遵循标识符的命名规范。
类的成员变量是类的属性，它们用于存储对象的状态。
类的构造函数用于创建对象并初始化它的成员变量。
类的方法用于定义对象的行为。
二、成员变量Java中的成员变量也称为类的属性，用于存储对象的状态。
成员变量可以是基本类型、引用类型或数组类型。
在类的定义中，成员变量要放在构造函数和方法的前面。
成员变量可以通过类的对象来访问和修改。
```java public class Person { private String name; private int age;public Person(String name, int age){ = name; this.age = age; }public String getName() { return name; }public void setName(String name){ = name; }public int getAge() { return age; }public void setAge(int age){ this.age = age; } } ```在上面的例子中，Person类有两个成员变量name和age，它们都使用private关键字修饰，表示只能在类内部访问。
同时，这个Person类提供了一个有参构造函数和getter、setter方法，用来访问和修改成员变量。
三、构造函数Java中的构造函数用于创建对象并初始化它的成员变量。
【java】String类和StringBuffer类常用操作
【java】String类和StringBuffer类常⽤操作String类是字符串常量，是不可更改的常量。
⽽StringBuffer是字符串变量，它的对象是可以扩充和修改的。
StringBuffer在进⾏字符串处理时，不⽣成新的对象，在内存使⽤上要优于String类。
所以在实际使⽤时，如果经常需要对⼀个字符串进⾏修改，例如插⼊、删除等操作，使⽤StringBuffer要更加适合⼀些。
String类主要⽅法的使⽤⼀、创建并初始化字符串：String s = "hello!"; //使⽤字符串常量直接初始化String(); //使⽤构造⽅法创建并初始化,初始化⼀个对象，表⽰空字符序列String(value); //利⽤已存在的字符串常量创建⼀个新的对象String (char[] value); //利⽤⼀个字符数组创建⼀个字符串String(char[] value,int offset,int count);//截取字符数组offset到count的字符创建⼀个⾮空串String(StringBuffer buffer); //利⽤StringBuffer对象初始化String对象⼆、String类主要⽅法的使⽤：1、获取长度*.length(); //这与数组中的获取长度不同，*.length;2、⽐较字符串(1)equals() //判断内容是否相同(2)compareTo() //判断字符串的⼤⼩关系(3)compareToIgnoreCase(String int) //在⽐较时忽略字母⼤⼩写(4)== //判断内容与地址是否相同(5)equalsIgnoreCase() //忽略⼤⼩写的情况下判断内容是否相同//如果想对字符串中的部分内容是否相同进⾏⽐较，可以⽤(6)reagionMatches() //有两种 public boolean regionMatches(int toffset, String other,int ooffset,int len);表⽰如果String对象的⼀个⼦字符串与参数other的⼀个⼦字符串是相同的字符序列，则为true.要⽐较的String 对象的字符串从索引toffset开始,oth public boolean reagionMatches(boolean ignoreCase,int toffset,String other,int ooffset,int len);//⽤布尔类型的参数指明两个字符串的⽐较是否对⼤⼩写敏感。
Java-Method类常用方法详解
Java-Method类常⽤⽅法详解⼀、Method类的定义Method类位于 ng.reflect 包中，主要⽤于在程序运⾏状态中，动态地获取⽅法信息⼆、Method类的常⽤⽅法1、getAnnotatedReturnType()返回⼀个AnnotatedType对象，该对象表⽰使⽤⼀个类型来指定由该可执⾏⽂件表⽰的⽅法/构造函数的返回类型public class MethodTest {public String test() {return null;}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");AnnotatedType methodAnnotatedReturnType = method.getAnnotatedReturnType();// class ng.StringSystem.out.println(methodAnnotatedReturnType.getType());}}123456789101112132、getAnnotatedExceptionTypes()返回⼀个AnnotatedType对象数组，这些对象表⽰使⽤类型来指定由该可执⾏⽂件表⽰的⽅法/构造函数声明的异常public class MethodTest {public void test() throws NullPointerException, ClassNotFoundException {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");AnnotatedType[] annotatedExceptionTypes = method.getAnnotatedExceptionTypes();for (AnnotatedType annotatedExceptionType : annotatedExceptionTypes) {// class ng.NullPointerException// class ng.ClassNotFoundExceptionSystem.out.println(annotatedExceptionType.getType());}}}12345678910111213public class MethodTest {public void test() {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");AnnotatedType annotatedReceiverType = method.getAnnotatedReceiverType();// class lang.reflect.MethodTestSystem.out.println(annotatedReceiverType.getType());}}12345678910114、getAnnotation(Class<T> annotationClass)如果该⽅法对象存在指定类型的注解，则返回该注解，否则返回null只有类级别的注解会被继承得到，对于其他对象⽽⾔，getAnnotation() ⽅法与 getDeclaredAnnotation() ⽅法作⽤相同@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface MethodAnnotation {String key();String value();}public class MethodTest {@MethodAnnotation(key = "key", value = "value")public void test() {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");MethodAnnotation annotation = method.getAnnotation(MethodAnnotation.class);// @lang.reflect.MethodAnnotation(value=value, key=key)System.out.println(annotation);}}123456789101112131415161718如果该⽅法对象存在指定类型的注解，则返回该注解，否则返回null只有类级别的注解会被继承得到，对于其他对象⽽⾔，getAnnotation() ⽅法与 getDeclaredAnnotation() ⽅法作⽤相同6、getAnnotationsByType(Class<T> annotationClass)如果该⽅法对象存在指定类型的注解，则返回该注解数组，否则返回null只有类级别的注解会被继承得到，对于其他对象⽽⾔，getAnnotationsByType() ⽅法与 getDeclaredAnnotationsByType() ⽅法作⽤相同getAnnotationsByType() ⽅法与 getAnnotation() ⽅法的区别在于 getAnnotationsByType() ⽅法会检查修饰该⽅法对象的注解是否为可重复类型注解，如果是则会返回该参数类型的⼀个或多个注解@Repeatable ⽤于声明注解为可重复类型注解，当声明为可重复类型注解后，如果⽅法注解仍为⼀个，则 getAnnotation() ⽅法会正常返回，如果⽅法注解为多个，则 getAnnotation()⽅法会返回null@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Repeatable(RepeatableAnnotation.class)public @interface MethodAnnotation {String key();String value();}@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@interface RepeatableAnnotation {MethodAnnotation[] value();}public class MethodTest {@MethodAnnotation(key = "key1", value = "value1")@MethodAnnotation(key = "key2", value = "value2")public void test() {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");MethodAnnotation[] annotationsByType = method.getAnnotationsByType(MethodAnnotation.class);// [@lang.reflect.MethodAnnotation(value=value1, key=key1), @lang.reflect.MethodAnnotation(value=value2, key=key2)]System.out.println(Arrays.toString(annotationsByType));}}1234567891011121314151617181920212223242526如果该⽅法对象存在指定类型的注解，则返回该注解数组，否则返回null只有类级别的注解会被继承得到，对于其他对象⽽⾔，getAnnotationsByType() ⽅法与 getDeclaredAnnotationsByType() ⽅法作⽤相同 8、getAnnotations()返回该⽅法对象上的所有注解，如果没有注解，则返回空数组只有类级别的注解会被继承得到，对于其他对象⽽⾔，getAnnotations() ⽅法与 getDeclaredAnnotations() ⽅法作⽤相同@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface MethodAnnotation {String key();String value();}@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface TestAnnotation {String key();String value();}public class MethodTest {@MethodAnnotation(key = "key1", value = "value1")@TestAnnotation(key = "key2", value = "value2")public void test() {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");Annotation[] annotations = method.getAnnotations();for (Annotation annotation : annotations) {// @lang.reflect.MethodAnnotation(value=value1, key=key1)// @lang.reflect.Parameter.TestAnnotation(key=key2, value=value2)System.out.println(annotation);}}}12345678910111213141516171819202122232425269、getDeclaredAnnotations()返回该⽅法对象上的所有注解，如果没有注解，则返回空数组只有类级别的注解会被继承得到，对于其他对象⽽⾔，getAnnotations() ⽅法与 getDeclaredAnnotations() ⽅法作⽤相同 10、getModifiers()返回修饰该⽅法对象修饰符的整数形式，使⽤ Modifier 类对其进⾏解码public class MethodTest {public void test() {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");// publicSystem.out.println(Modifier.toString(method.getModifiers()));}}1234567891011、getName()返回⽅法对象名称public class MethodTest {public void test() {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");// testSystem.out.println(method.getName());}}1234567891012、isAnnotationPresent(Class<? extends Annotation> annotationClass)如果该⽅法对象上有指定类型的注解，则返回true，否则为falsepublic class MethodTest {@MethodAnnotation(key = "key", value = "value")public void test() {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");// trueSystem.out.println(method.isAnnotationPresent(MethodAnnotation.class));789101113、isVarArgs()如果该⽅法对象的参数中存在可变参，则返回true，否则为falsepublic class MethodTest {public void test(String ... args) {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test", String[].class);// trueSystem.out.println(method.isVarArgs());}}1234567891014、getDeclaringClass ()返回该⽅法对象表⽰的⽅法所在类的Class对象public class MethodTest {public void test() {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");Class<?> declaringClass = method.getDeclaringClass();// class lang.reflect.MethodTestSystem.out.println(declaringClass);}}123456789101115、getAnnotatedParameterTypes()返回⼀个AnnotatedType对象数组，这些对象表⽰使⽤类型来指定由该可执⾏⽂件表⽰的⽅法/构造函数的形式参数类型public class MethodTest {public void test(String name, Integer age) {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test", String.class, Integer.class);System.out.println(annotatedParameterType.getType());}}}123456789101112131416、getParameterAnnotations()返回⼀组注解数组，这些注解以声明顺序修饰该⽅法对象的参数public class MethodTest {public void test(@ParameterAnnotation(key = "key1", value = "value1") String name,@ParameterAnnotation(key = "key2", value = "value2") Integer age) {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test", String.class, Integer.class);Annotation[][] parameterAnnotations = method.getParameterAnnotations();// [[@lang.reflect.ParameterAnnotation(key=key1, value=value1)], [@lang.reflect.ParameterAnnotation(key=key2, value=value2)]] System.out.println(Arrays.deepToString(parameterAnnotations));}}12345678910111217、getParameterCount()返回该⽅法对象的参数个数 (⽆论是显式声明的还是隐式声明的或不声明的)public class MethodTest {public void test(String name, Integer age) {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test", String.class, Integer.class);// 2System.out.println(method.getParameterCount());}}1234567返回⼀个参数对象数组，该数组表⽰该⽅法对象的所有参数public class MethodTest {public void test(String name, Integer age) {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test", String.class, Integer.class); Parameter[] parameters = method.getParameters();for (Parameter parameter : parameters) {// ng.String name// ng.Integer ageSystem.out.println(parameter);}}}123456789101112131419、getDefaultValue()返会该注解⽅法对象表⽰的成员默认值如果成员属于基本数据类型，则返回对应的包装类实例如果没有默认值或者该⽅法实例不表⽰注解⽅法，则返回null@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface MethodAnnotation {String key() default "default key";String value() default "default value";}public class MethodTest {public static void main(String[] args) throws Exception {Method key = MethodAnnotation.class.getMethod("key");Method value = MethodAnnotation.class.getMethod("value");Object defaultValue1 = key.getDefaultValue();Object defaultValue2 = value.getDefaultValue();// default keySystem.out.println(defaultValue1);// default valueSystem.out.println(defaultValue2);}}123456789181920212220、getParameterTypes()返回⼀个Class对象数组，该数组以声明顺序表⽰该⽅法对象的参数对象，会擦除泛型public class MethodTest<T> {public void test(T t) {}public void test(LinkedList<Integer> list) {}public static void main(String[] args) throws Exception {Method objectMethod = MethodTest.class.getMethod("test", Object.class);Method listMethod = MethodTest.class.getMethod("test", LinkedList.class);Class<?>[] objectParameterTypes = objectMethod.getParameterTypes();// [class ng.Object]System.out.println(Arrays.toString(objectParameterTypes));Class<?>[] listParameterTypes = listMethod.getParameterTypes();// [class java.util.LinkedList]System.out.println(Arrays.toString(listParameterTypes));}}12345678910111213141516171821、getReturnType()返回⼀个Class对象，该Class对象表⽰该⽅法对象的返回对象，会擦除泛型public class MethodTest<T> {public T test(T t) {return t;}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getMethod("test", Object.class);Class<?> returnType = method.getReturnType();// class ng.ObjectSystem.out.println(returnType);}}1211121322、getGenericReturnType()返回⼀个Type对象，该Type对象表⽰该⽅法对象的返回类型，会保留泛型public class MethodTest<T> {public T test(T t) {return t;}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getMethod("test", Object.class);Type genericReturnType = method.getGenericReturnType();// TSystem.out.println(genericReturnType);}}1234567891011121323、getExceptionTypes()返回⼀个Class对象数组，该数组表⽰由该⽅法对象抛出的异常对象，会擦除泛型public class MethodTest<T> {public <T extends Exception> void test() throws T, NullPointerException {} public static void main(String[] args) throws Exception {Method method = MethodTest.class.getMethod("test");Class<?>[] exceptionTypes = method.getExceptionTypes();// [class ng.Exception, class ng.NullPointerException]System.out.println(Arrays.toString(exceptionTypes));}}123456789101124、getGenericExceptionTypes()返回⼀个Type对象数组，该数组表⽰由该⽅法对象抛出的异常类型，会保留泛型public class MethodTest<T> {Type[] genericExceptionTypes = method.getGenericExceptionTypes();// [T, class ng.NullPointerException]System.out.println(Arrays.toString(genericExceptionTypes));}}123456789101125、getTypeParameters()返回⼀个TypeVariable对象数组，该数组表⽰该⽅法对象声明列表上的类型变量数组public class MethodTest<T, V> {public <T, V> void test() {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getMethod("test");TypeVariable<Method>[] typeParameters = method.getTypeParameters();// [T, V]System.out.println(Arrays.toString(typeParameters));}}123456789101126、toString()返回该⽅法对象的字符串表⽰形式，会擦除泛型public class MethodTest<T, V> {public <T, V> void test() {}public static void main(String[] args) throws Exception {Method method = MethodTest.class.getMethod("test");// public void lang.reflect.MethodTest.test()System.out.println(method.toString());}}1234567891027、toGenericString()public static void main(String[] args) throws Exception {Method method = MethodTest.class.getMethod("test");// public <T,V> void lang.reflect.MethodTest.test()System.out.println(method.toGenericString());}}1234567891028、isAccessible()获取该⽅法对象的可访问标志public class MethodTest {private void test() {}}public class Test {public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");// falseSystem.out.println(method.isAccessible());}}1234567891011121329、setAccessible(boolean flag)设置该⽅法对象的可访问标志在其他类⾥调⽤该⽅法对象时，如果该⽅法为私有⽅法，需要设置访问标志为true，否则会报异常public class MethodTest {private void test() {}}public class Test {public static void main(String[] args) throws Exception {Method method = MethodTest.class.getDeclaredMethod("test");method.setAccessible(true);// testSystem.out.println(method.getName());}}12312131430、isDefault()判断该⽅法对象是否为默认⽅法，如果是则返回true，否则为falsepublic interface Interface {default void test() {System.out.println("这是⼀个默认⽅法");}}public class MethodTest implements Interface {public static void main(String[] args) throws Exception {Method method = MethodTest.class.getMethod("test");// trueSystem.out.println(method.isDefault());}}12345678910111213141531、isSynthetic()判断该⽅法对象是否为合成⽅法，如果是则返回true，否则为false在内部类InnerClass中，name是⼀个私有属性，⽽我们在外部类MethodTest中，直接引⽤了这个属性，因此编译器通过⽣成⼀个合成⽅法，⽤于绕开private私有属性的限制public class MethodTest {private class InnerClass {private String name = "⼩明";}public static void main(final String[] arguments) {InnerClass innerClass = new MethodTest().new InnerClass();System.out.println("name: " + );Method[] declaredMethods = innerClass.getClass().getDeclaredMethods();for (Method declaredMethod : declaredMethods) {// 【static ng.String lang.reflect.MethodTest$InnerClass.access$100(lang.reflect.MethodTest$InnerClass)】 isSynthetic(): true System.out.println("【" + declaredMethod + "】" + " isSynthetic(): " + declaredMethod.isSynthetic());}}}12341314151617有关synthetic的相关内容，⼩伙伴可以看下这⾥Java 中冷门的 synthetic 关键字原理解读32、isBridge()判断该⽅法对象是否桥接⽅法，如果是则返回true，否则为false桥接⽅法: 是 JDK1.5 引⼊泛型后，为了使Java的泛型⽅法⽣成的字节码和 1.5 版本前的字节码相兼容，由编译器⾃动⽣成的⽅法public interface Interface<T> {T test(T t);}public class MethodTest implements Interface<String> {@Overridepublic String test(String str) {return str;}public static void main(final String[] arguments) {Method[] declaredMethods = MethodTest.class.getDeclaredMethods();for (Method declaredMethod : declaredMethods) {//【public static void lang.reflect.MethodTest.main(ng.String[])】 isBridge(): false//【public ng.String lang.reflect.MethodTest.test(ng.String)】 isBridge(): false//【public ng.Object lang.reflect.MethodTest.test(ng.Object)】 isBridge(): trueSystem.out.println("【" + declaredMethod + "】" + " isBridge(): " + declaredMethod.isBridge());}}}12345678910111213141516171819202122。
常用类
常用类和包¾标准类(系统提供)¾包。
¾类中有数据和方法，用方法对数据操作¾Object类：是所有类的根（父类）Object类Object类是Java类库中所有类的父类所有类都从Object类派生。
Object类包含了所有Java类的公共成员(属性)。
常用方法protected Object clone()：复制当前对象，返回复制的对象。
public boolean equals(Object obj)：比较两个对象public final Class getClass()：获取对象所属类信息，返回Class对象。
protected void finalize()：定义回收当前对象时完成的清理工作。
public String toString()：以字符串形式返回当前对象的有关信息。
String类¾属于语言包java .lang¾不变字符串类，处理内容不变的字符串，即字符串常量。
¾public final class java .lang. String¾构造方法与建立String对象public String()例String s1=new String( ); //生成空串nulls1="ABC";public String(String value)例 String s2=new String("ABC");public String(StringBuffer value)例 StringBuffer s3=new StringBuffer("Hello");String s4=new String(s3);public String(char value[])例char a[ ]={ 'h', 'e', 'l', ' l', 'o' };String s5=new String(a); //转换String s6=new String(a ,1 ,3); //取子串“ell”String的方法求字符串长度：public int length()调用方法：String对象名.length( )public class StrLength{public static void main(String[] args){String s1=new String("ABC");System.out.println(s1.length());String s2=new String("你好");System.out.println(s2.length());System.out.println("Hello".length());}}输出结果：325英文字符和汉字都用Unicode编码表示。
攀枝花学院Java实验五 常用类
实验报告附页String s7 = new String("123.678");int n1=Integer.parseInt(s6);//将s6转化成int型数据。
double n2=Double.parseDouble(s7); //将s7转化成double型数据。
double m=n1+n2;System.out.println(m);String s8=String.valueOf(m); //String调用valuOf(int n)方法将m转化为字符串对象position=s8.indexOf(".");String temp=s8.substring(position+1);System.out.println("数字"+m+"有"+temp.length()+"位小数") ;@SuppressWarnings("unused")String s9=new String("ABCDEF");char a[]=s8.toCharArray(); //将s8存放到数组a中。
for(int i=a.length-1;i>=0;i--){System.out.print(" "+a[i]);}}}运行结果：将上面程序按如下要求修改，并运行：（1）程序中的s6改写成String s6=new String(“1a12b”);运行时提示怎样的错误？Exception in thread "main" ng.NumberFormatException: For input string: "1a12b"at ng.NumberFormatException.forInputString(Unknown Source)at ng.Integer.parseInt(Unknown Source)at ng.Integer.parseInt(Unknown Source)at xiti2.xiugai.main(xiugai.java:39)（2）请用数组a的前3个单元创建一个字符串并输出该串。
java基础常用的方法
java基础常用的方法Java基础常用的方法Java作为一门流行的编程语言，拥有着丰富的基础方法。
本文将介绍一些Java基础常用的方法，帮助读者更好地理解和使用这门语言。
一、字符串处理方法在Java中，字符串是一种常用的数据类型，因此字符串处理方法也是开发中常用到的。
下面是一些常见的字符串处理方法：1. length()：返回字符串的长度。
javaString str = "Hello World";int len = str.length(); len的值为112. charAt()：返回指定索引位置的字符。
javaString str = "Hello World";char ch = str.charAt(4); ch的值为'o'3. substring()：返回指定索引范围内的子串。
javaString str = "Hello World";String subStr = str.substring(6); subStr的值为"World"4. concat()：将指定字符串连接到原字符串末尾。
javaString str1 = "Hello";String str2 = "World";String result = str1.concat(str2); result的值为"HelloWorld"5. replace()：替换字符串中的指定字符或子串。
javaString str = "Hello World";String newStr = str.replace('o', 'a'); newStr的值为"Hella Warld"6. toUpperCase()和toLowerCase()：将字符串转换为大写或小写。
JavaBigDecimal类常用方法
JavaBigDecimal类常⽤⽅法最近⼯作中接触到了 Java BigDecimal类，准备整理⼀下⽤到的⼏个常⽤⽅法。
简介Java在java.math包中提供的API类BigDecimal，⽤来对超过16位有效位的数进⾏精确的运算。
双精度浮点型变量double可以处理16位有效数。
在实际应⽤中，需要对更⼤或者更⼩的数进⾏运算和处理。
float和double只能⽤来做科学计算或者是⼯程计算，在商业计算中要⽤java.math.BigDecimal。
BigDecimal所创建的是对象，我们不能使⽤传统的+、-、*、/等算术运算符直接对其对象进⾏数学运算，⽽必须调⽤其相对应的⽅法。
⽅法中的参数也必须是BigDecimal的对象。
构造器是类的特殊⽅法，专门⽤来创建对象，特别是带有参数的对象。
构造器BigDecimal(int) 创建⼀个具有参数所指定整数值的对象。
BigDecimal(double) 创建⼀个具有参数所指定双精度值的对象。
BigDecimal(long) 创建⼀个具有参数所指定长整数值的对象。
BigDecimal(String) 创建⼀个具有参数所指定以字符串表⽰的数值的对象。
这⼏个都是常⽤的构造器，他们返回的对象都是BigDecimal对象。
换⽽⾔之，将各个类型的值转换为BigDecimal对象，就是通过构造器。
反过来说，将BigDecimal对象转换为其他类型的对象，我们通过以下⼏种：toString() 将BigDecimal对象的数值转换成字符串。
doubleValue() 将BigDecimal对象中的值以双精度数返回。
floatValue() 将BigDecimal对象中的值以单精度数返回。
longValue() 将BigDecimal对象中的值以长整数返回。
intValue() 将BigDecimal对象中的值以整数返回。
常⽤⽅法BigDecimal b1 = new BigDecimal("20");BigDecimal b2 = new BigDecimal("30");b1.add(b2) ：加法，求两个BigDecimal类型数据的和。
JavaString类的常用方法(字符串替换)
JavaString类的常用方法（字符串替换）Java中的String类提供了多个方法用于替换字符串，常用方法包括：1. `replace(char oldChar, char newChar)`：将字符串中所有的指定字符oldChar替换为newChar。
```javaString str = "hello world";String replacedStr = str.replace('o', 'e');System.out.println(replacedStr); // 输出: helle werld```2. `replace(CharSequence target, CharSequence replacement)`：将字符串中所有的指定字符序列target替换为replacement。
```javaString str = "hello world";String replacedStr = str.replace("world", "Java");System.out.println(replacedStr); // 输出: hello Java```3. `replaceAll(String regex, String replacement)`：使用正则表达式regex匹配的所有字符串替换为replacement。
```javaString str = "hello 123 world";String replacedStr = str.replaceAll("\\d+", "Java");System.out.println(replacedStr); // 输出: hello Java world ```4. `replaceFirst(String regex, String replacement)`：使用正则表达式regex匹配的第一个字符串替换为replacement。
java常用方法
java常用方法
以下是Java中常用的一些方法：
1. toString()：将一个对象转换为字符串表示形式。
2. equals()：比较两个对象是否相等。
3. hashCode()：返回对象的哈希码。
4. clone()：创建并返回一个对象的副本。
5. getClass()：返回对象的类。
6. finalize()：在垃圾回收器清除对象之前调用。
7. wait()：使线程等待，直到另一个线程通知。
8. notify()：唤醒一个等待中的线程。
9. notifyAll()：唤醒所有等待中的线程。
10. compareTo()：比较两个对象的大小。
11. length()：返回字符串的长度。
12. substring()：返回字符串的子字符串。
13. indexOf()：返回指定字符或字符串在字符串中第一次出现的位置。
14. split()：将字符串分割成子字符串数组。
15. trim()：去除字符串两端的空格。
这些是Java中一些常用的方法，可以根据具体需求选择使用。
java基础-Integer类常用方法介绍
4 EMAIL:y1053419035@
5 */
6
7 package .yinzhengjie.demo;
8
9 public class Demo1 {
10 public static void main(String[] args) {
11
int src = 32;
12
//将int整数转换成指定的进制数
33 Double最小值是：4.9E-324
34 */
4>.十进制转成不同的进制，三个静态方法的返回值都是以字符串的形式返回
1 /* 2 @author :yinzhengjie 3 Blog:/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
1 /*
2 @author :yinzhengjie
3 Blog:/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
4 EMAIL:y1053419035@
5 */
6
7 package .yinzhengjie.demo;
25 Long最大值是：9223372036854775807
26 Long最小值是：-9223372036854775808
27 Double最大值是：1.7976931348623157E308
28 Double最小值是：4.9E-324
java.util包下的类及常用方法
java.util包下的类及常⽤⽅法1、⽇期类 Date类
常⽤⽅法
创建⽇期对象：Date date = new Date ( ) ;
获取当前时间以标准格式：date
获取当前时间的毫秒数：date.getTIme ( )
获取纪元时间：date。
toGMTString ( )
时间转成字符串：date.toString ( )
这个类的⼀些⽅法已经过时了、被⽇历类取代！
2、⽇历类 Calender类
常⽤⽅法
getlnstance（）：获取⽇历对象
get（）：获取指定的单位的⽇历数值（年，⽉，⽇等等）
set（）：设置指定单位的⽇历数值
add（）：添加指定单位的⽇历数值
getTimelnMills（）：获取⽇历的毫秒数
3、SCanner类
常⽤⽅法
扫描控制台：Scanner sc = new Scanner（System.in）
扫描字符串，遇到空格就返回给程序：sc.next()
扫描⼀个整数：sc.nextInt()
扫描⼀个⼩数：sc.nextDouble()
扫描⼀⾏：sc.nextLine()
4、定时器类 Timer类
常⽤⽅法
创建TImer对象：
Timer timer = new Timer();
Timer timer = new Timer(name);
timer.schedule(TimerTask,2000); 2秒后执⾏⼀次任务
t imer.schedule(TimerTask,2000,1000); 2秒后开始执⾏任务，每1s执⾏⼀次。
java的queue类常用方法
java的queue类常用方法Queue是Java中用来存储一组元素的集合类，它遵循先进先出（FIFO）的原则。
Queue接口继承自Collection接口，它包含了一些常用的方法来操作队列中的元素。
下面我们将介绍一些Java中Queue类常用的方法。
1. add(E e)方法：将指定的元素插入到队列中，如果插入成功则返回true，否则抛出一个异常。
2. offer(E e)方法：将指定的元素插入到队列中，如果插入成功则返回true，否则返回false。
3. remove()方法：移除并返回队列的头部元素，如果队列为空则抛出一个异常。
4. poll()方法：移除并返回队列的头部元素，如果队列为空则返回null。
5. element()方法：返回队列的头部元素，但不移除。
如果队列为空则抛出一个异常。
6. peek()方法：返回队列的头部元素，但不移除。
如果队列为空则返回null。
除了上述常用方法外，Queue类还提供了一些其他方法来操作队列：7. addAll(Collection<? extends E> c)方法：将指定集合中的元素添加到队列中。
8. clear()方法：清空队列中的所有元素。
9. contains(Object o)方法：判断队列中是否包含指定元素。
10. isEmpty()方法：判断队列是否为空。
11. size()方法：返回队列中的元素个数。
12. toArray()方法：将队列中的元素以数组的形式返回。
13. iterator()方法：返回一个迭代器，可以用来遍历队列中的元素。
Queue类的常用方法可以帮助我们方便地对队列进行操作，实现队列的基本功能。
在实际的开发中，根据具体的需求选择合适的方法来操作队列，可以提高代码的效率和可读性。
希望以上内容能帮助您更好地了解Java中Queue类的常用方法。
java中date类的常用方法
java中date类的常用方法Java中的Date类是用于表示日期和时间的类，它提供了一系列常用的方法来处理日期和时间的操作。
下面将介绍Date类的一些常用方法。
1. getDate()：获取当前日期的天数。
返回值为一个整数，范围从1到31。
2. getMonth()：获取当前日期的月份。
返回值为一个整数，范围从0到11，其中0表示一月，11表示十二月。
3. getYear()：获取当前日期的年份。
返回值为一个整数，表示当前年份减去1900。
4. getDay()：获取当前日期是星期几。
返回值为一个整数，范围从0到6，其中0表示星期日，1表示星期一，以此类推。
5. getHours()：获取当前时间的小时数。
返回值为一个整数，范围从0到23。
6. getMinutes()：获取当前时间的分钟数。
返回值为一个整数，范围从0到59。
7. getSeconds()：获取当前时间的秒数。
返回值为一个整数，范围从0到59。
8. getTime()：获取当前日期和时间的毫秒数。
返回值为一个长整型数字，表示从1970年1月1日00:00:00 GMT到当前日期和时间的毫秒数。
9. setTime()：设置日期和时间。
接受一个长整型参数，表示从1970年1月1日00:00:00 GMT到所设置日期和时间的毫秒数。
10. after(Date date)：判断当前日期是否在指定日期之后。
返回值为一个布尔值，如果当前日期在指定日期之后，则返回true，否则返回false。
11. before(Date date)：判断当前日期是否在指定日期之前。
返回值为一个布尔值，如果当前日期在指定日期之前，则返回true，否则返回false。
12. compareTo(Date date)：比较当前日期和指定日期的顺序。
返回值为一个整数，如果当前日期在指定日期之前，则返回负数；如果当前日期等于指定日期，则返回0；如果当前日期在指定日期之后，则返回正数。
java中date类的常用方法
java中date类的常用方法Java中Date类的常用方法1. 获取当前日期和时间•Date()：创建一个表示当前日期和时间的Date对象。
2. 获取日期/时间的特定部分•getYear()：返回日期的年份（从1900开始计算）。
•getMonth()：返回日期的月份（0-11表示1-12月）。
•getDate()：返回日期的天数（1-31）。
•getDay()：返回日期的星期几（0-6表示周日到周六）。
•getHours()：返回时间的小时数（0-23）。
•getMinutes()：返回时间的分钟数（0-59）。
•getSeconds()：返回时间的秒数（0-59）。
3. 设置日期/时间的特定部分•setYear(int year)：设置日期的年份。
•setMonth(int month)：设置日期的月份。
•setDate(int day)：设置日期的天数。
•setHours(int hours)：设置时间的小时数。
•setMinutes(int minutes)：设置时间的分钟数。
•setSeconds(int seconds)：设置时间的秒数。
4. 格式化日期和时间•toString()：将Date对象转换为字符串表示形式。
•SimpleDateFormat类：可以使用该类进行更灵活的日期和时间格式化，例如：SimpleDateFormat sdf = new SimpleDateForma t("yyyy-MM-dd");String formattedDate = (date);5. 比较日期和时间•before(Date date)：判断当前日期是否在指定日期之前。
•after(Date date)：判断当前日期是否在指定日期之后。
•compareTo(Date date)：比较两个日期的先后顺序，返回值为负数、零或正数。
6. 计算日期和时间•getTime()：返回距离1970年1月1日的毫秒数。
java实用类
实用类1、枚举：a、关键字enum;b、可以定义枚举常量；c、还可以定义普通类的成员，包括构造方法（构造方法必须是私有访问级别）d、枚举语法：注：枚举必须首先定义枚举常量，如果枚举中除了枚举常量还要定义其他成员，那么枚举常量的列表必须以；结尾；使用String类操作字符串一、1、String类位于ng包中，默认情况下，该包被自动导入所有的程序。
2、创建一个String 对象：String s = “Hello World”;或是：String s = new String(“Hello Wold”);二、1、获取字符串长度：字符串.length();* 返回字符串长度；例：Public class Register{Public static void main(String []args){Scanner input = new Scanner(System.in);String uname,pwd;System.out.println(“请输入用户名：”);Uname = intpu.next();System.out.println(“请输入密码：”);Pwd = input.next();If(pwd.length()> = 6){System.out.println(“注册成功”);System.out.println(“用户名：”+uname+”\n密码：”+pwd);}else{System.out.println(“密码长度不能小于6位！”);}}}2.字符串比较：字符串1.equals(字符串2);*比较俩个值是否相等，返回boolean类型的值true或false;例：Public class Login{Public static void main(String [] args){Scanner input = new Scanner(System.in);String uname,pwd;System.out.println(“请输入用户名：”);uname=input.next();System.out.println(“请输入密码：”);pwd = input.next();if(uname.equals(“TOM” )&& pwd.equals(“123456”)){System.out.println(“登录成功！！！”);}else{System.out.println(“用户名或密码不匹配，登录失败！！”);}} }“==”与“equals()”的区别：双等号（==）判断的是俩个字符串对象在内存中的首地址，就是判断是否是同一个字符串对象；equals() 判断的是俩个字符串对象的值；注：a、在使用equals()方法比较俩个字符串时，对于字符的大小写，也在检查范围之内；b、equalsIgnoreCase()方法比较字符串时忽略字符的大小写；3、改变字符串中字符的大小写：toLowerCase() : 转换字符串中的英文字母为小写；toUpperCase() : 转换字符串中的英文字母为大写；语法：字符串.toLowerCase();字符串.toUpperCase();4、字符串的连接：在java中String提供了concat() 方法将一个字符串连接到另一个字符串后面。
java.util包下常用类及常用方法介绍
java.util包下常⽤类及常⽤⽅法介绍
java.util包下常⽤类及常⽤⽅法
包含 collection 框架、遗留的 collection 类、事件模型、⽇期和时间设施、国际化和各种实⽤⼯具类（字符串标记⽣成器、随机数⽣成器和位数组）。
1. 常⽤接⼝
（1）Collection
Collection 层次结构中的根接⼝。
（2）Iterator
对 collection 进⾏迭代的迭代器。
（3）List
有序的 collection（也称为序列）。
（4）Map<K,V>
将键映射到值的对象。
（5）Map.Entry<K,V>
映射项（键-值对）。
（6）Set
⼀个不包含重复元素的 collection。
2. 常⽤类
（1）ArrayList
List 接⼝的⼤⼩可变数组的实现。
（2）Arrays
此类包含⽤来操作数组（⽐如排序和搜索）的各种⽅法。
（3）Collections
此类完全由在 collection 上进⾏操作或返回 collection 的静态⽅法组成。
（4）Date
类 Date 表⽰特定的瞬间，精确到毫秒。
（5）HashMap<K,V>
基于哈希表的 Map 接⼝的实现。
（6）HashSet
此类实现 Set 接⼝，由哈希表（实际上是⼀个 HashMap 实例）⽀持。
（7）Random
此类的实例⽤于⽣成伪随机数流。
（8）Timer
⼀种⼯具，线程⽤其安排以后在后台线程中执⾏的任务。
java localdate常用方法
java localdate常用方法Java LocalDate是Java 8中的一个日期类，用于表示不带时区的日期。
它提供了一系列常用的方法来操作和处理日期。
本文将介绍LocalDate类的常用方法，帮助读者更好地理解和使用该类。
1. 获取当前日期在Java中，我们可以使用LocalDate.now()方法获取当前日期。
下面是示例代码：LocalDate currentDate = LocalDate.now();System.out.println(currentDate);以上代码将输出当前的日期，格式类似于"2022-07-15"。
2. 构造指定日期除了获取当前日期，我们还可以使用LocalDate.of()方法构造一个指定日期的LocalDate对象。
示例代码如下：LocalDate date = LocalDate.of(2022, 7, 15);System.out.println(date);以上代码将输出指定的日期"2022-07-15"。
3. 获取年、月、日信息在LocalDate类中，我们可以使用getYear()、getMonthValue()和getDayOfMonth()等方法分别获取当前日期的年、月和日信息。
示例代码如下：LocalDate currentDate = LocalDate.now();int year = currentDate.getYear();int month = currentDate.getMonthValue();int day = currentDate.getDayOfMonth();System.out.println("Year: " + year);System.out.println("Month: " + month);System.out.println("Day: " + day);以上代码将输出当前日期的年、月和日信息。
java.io.包内常用类及方法
例：String inputLine = scan.nextLine();StringTokenizer wordFinder =new StringTokenizer(inputLine, " \n.,");while(wordFinder.hasMoreTokens()){System.out.println(wordFinder.nextToken());}（2）FileReader注意：可以接文件名。
二、二进制文件（Binary File）1、输出（output）类(to the file)（1）ObjectOutputStream注意：不可以接文件名，可通过套用FileReader来实现。
例如：ObjectOutputStream outputStream=new ObjectOutputStream(new FileOutputStream("numbers.dat"));常用方法：writeInt(int n)，writeDouble(double x)，writeBoolean(boolean b)，writeUTF(String s)，writeChar((int) 'A')写入数值，close()：保存并关闭文件。
（2）FileOutputStream注意：可以接文件名。
2、输入（input）类(from the file)（1）ObjectInputStream注意：不可以接文件名，可通过套用FileReader来实现。
例如：ObjectInputStream inStream =new ObjectInputStream (new FileInputStream("numbers.dat"));常用方法：readInt()，readDouble()，readBoolean()读取数值，close()：保存并关闭文件。
string类中常用的5个方法
string类中常用的5个方法String类是Java中最常用的类之一，在开发中我们经常使用String类来处理字符串相关的操作。
在String类中提供了许多用于操作字符串的方法，下面将介绍五个常用的方法。
1. length()方法：length()方法用于返回字符串的长度，即字符串中字符的个数。
这个方法非常常用，可以用来判断字符串是否为空或者获取字符串的长度。
示例代码：String str = "Hello World!";int length = str.length();System.out.println("字符串长度为：" + length);输出结果：字符串长度为：122. charAt(int index)方法：charAt()方法用于返回字符串中指定位置的字符。
其中index表示要获取的字符在字符串中的索引位置，索引从0开始。
示例代码：String str = "Hello World!";char ch = str.charAt(6);System.out.println("字符串索引位置为6的字符为：" + ch);输出结果：字符串索引位置为6的字符为：W3. substring(int beginIndex, int endIndex)方法：substring()方法用于获取字符串中指定范围内的子串。
其中beginIndex 表示子串的起始位置（包含），endIndex表示子串的结束位置（不包含）。
示例代码：String str = "Hello World!";String subStr = str.substring(6, 11);System.out.println("截取的子串为：" + subStr);输出结果：截取的子串为：World4. indexOf(String str)方法：indexOf()方法用于返回指定子字符串在原字符串中第一次出现的位置。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
JAVA中常用类的常用方法一、ng.Object类1、clone()方法创建并返回此对象的一个副本。
要进行“ 克隆” 的对象所属的类必须实现ng.Cloneable接口。
2、equals(Object obj)方法?功能：比较引用类型数据的等价性。
?等价标准：引用类型比较引用，基本类型比较值。
?存在特例：对、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。
3、finalize()方法当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
4、hashCode()方法返回该对象的哈希码值。
5、notify()方法唤醒在此对象监视器上等待的单个线程。
6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。
7、toString()方法返回该对象的字符串表示。
在进行String与其它类型数据的连接操作时，自动调用toString()方法。
可以根据需要重写toString()方法。
8、wait()方法在其他线程调用此对象的notify() 方法或notifyAll() 方法前，导致当前线程等待。
二、字符串相关类String类charAt(int index) 返回指定索引处的char 值。
compareTo(String anotherString) 按字典顺序比较两个字符串。
compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。
concat(String str) 将指定字符串连接到此字符串的结尾。
endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
equals(Object anObject) 将此字符串与指定的对象比较。
equalsIgnoreCase(String anotherString) 将此String 与另一个String 比较，不考虑大小写。
indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。
lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
length() 返回此字符串的长度。
replace(char oldChar, char newChar)返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar 得到的。
split(String regex) 根据给定正则表达式的匹配拆分此字符串。
startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
substring(int beginIndex)返回一个新的字符串，它是此字符串的一个子字符串。
该子字符串始于指定索引处的字符，一直到此字符串末尾。
substring(int beginIndex, int endIndex)返回一个新字符串，它是此字符串的一个子字符串。
该子字符串从指定的beginIndex 处开始，一直到索引endIndex - 1 处的字符。
toCharArray() 将此字符串转换为一个新的字符数组。
toLowerCase() 使用默认语言环境的规则将此String 中的所有字符都转换为小写。
toUpperCase() 使用默认语言环境的规则将此String 中的所有字符都转换为大写。
trim() 返回字符串的副本，忽略前导空白和尾部空白。
valueOf(int i) 返回int 参数的字符串表示形式。
StringBuffer类append () 为该StringBuffer对象添加字符序列，返回添加后的该StringBuffer对象引用。
insert() 为该StringBuffer对象在指定位置插入字符序列，返回修改后的该StringBuffer对象引用。
delete (int start，int end) 可以删除从start开始到end－1为止的一段字符序列，返回修改后的该StringBuffer对象引用。
deleteCharAt(int index)移除此序列指定位置的charreverse() 将字符序列逆序，返回修改后的该StringBuffer对象引用。
reverse() 将此字符序列用其反转形式取代。
setCharAt( (int index，char ch) 将给定索引处的字符设置为ch。
StringBuilder类?JDK5.0 以后引入该类能够提供与StringBuffer 相同的功能,?二者区别：a)StringBuffer类是线程安全的，而StringBuilder则不是，即不保证其对象的同步性，在多线程环境中是不安全的。
b)StringBuilder在性能上要比StirngBuffer 好一些。
StringTokenizer类?java.util.StringTokenizer类的功能是将当前字符串按照默认或指定的分隔符分解为多个片段。
?主要功能方法：a)public boolean hasMoreTokens () 测试此tokenizer 的字符串中是否还有更多的可用标记。
b)public String nextToken () 返回此string tokenizer 的下一个标记。
三、基本数据类型封装类Integer类intValue() 以int 类型返回该Integer 的值parseInt(String s) 将字符串参数作为有符号的十进制整数进行分析。
reverse(int i) 返回通过反转指定int 值的二进制补码表示形式中位的顺序而获得的值。
toHexString(int i) 以十六进制的无符号整数形式返回一个整数参数的字符串表示形式。
valueOf(int i) 返回一个表示指定的int 值的Integer 实例。
Byte类Short类Float类Double类Long类Boolean类Character类四、日期时间类型Date类?java.util.Date类用于表示特定的时间点，精确到毫秒，但不支持日期的国际化和分时区显示。
?主要功能方法：boolean after(Date when) 测试此日期是否在指定日期之后。
public int compareTo(Date anotherDate) 比较两个日期的顺序。
public boolean equals(Object obj) 比较两个日期的相等性。
public long getTime() 返回自1970 年 1 月 1 日00:00:00 GMT 以来此Date 对象表示的毫秒数。
void setTime(long time)设置此Date 对象，以表示1970 年 1 月 1 日00:00:00 GMT 以后time 毫秒的时间点。
public String toString()把此Date 对象转换为以下形式的String：dow mon dd hh:mm:ss zzz yyyy 其中：dow 是一周中的某一天(Sun, Mon, Tue, Wed, Thu, Fri, Sat)。
Calendar类?主要方法：public static Calendar getInstance() 使用默认时区和语言环境获得一个日历。
public int get(int field) 返回给定日历字段的值。
public void set(int field, int value) 将给定的日历字段设置为给定值。
public final void set(int year, int month, int date) 设置日历字段YEAR、MONTH 和DAY_OF_MONTH 的值。
public final void set(int year, int month, int date, int hourOfDay, int minute, int second)设置字段YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和SECOND 的值。
public abstract void add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量。
Locale类public static Locale getDefault() 获得此Java 虚拟机实例的当前默认语言环境值。
public String getCountry() 返回此语言环境的国家/地区代码，将为空字符串或大写的ISO 3166 两字母代码。
public String getLanguage() 返回此语言环境的语言代码，可以是空字符串或小写的ISO 639 代码。
public final String getDisplayName() 返回适合向用户显示的语言环境名。
public static Locale[] getAvailableLocales() 返回所有已安装语言环境的数组。
TimeZone类?java.util.TimeZone类描述时区信息。
?TimeZone被定义为抽象类，可以调用其静态方法getDefault()以获得该类的实例。
?public static TimeZone getDefault() 获取此主机的默认TimeZone。
?public static TimeZone getTimeZone(String ID) 获取给定ID 的TimeZone。
GregorianCalendar类?主要方法：public boolean isLeapYear(int year) 确定给定的年份是否为闰年。
DateFormat类?java.text.DateFormat类提供了将日期/时间信息进行格式化处理的功能?主要方法：?public static final DateFormat getDateInstance()获得日期formatter，该formatter 具有默认语言环境的默认格式化风格。
public static final DateFormat getDateTimeInstance()获得日期/时间formatter，该formatter 具有默认语言环境的默认格式化风格。
public static final DateFormat getDateTimeInstance()获得日期/时间formatter，该formatter 具有默认语言环境的默认格式化风格。
?public final String format(Date date) 将一个Date 格式化为日期/时间字符串。