栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java常用类

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java常用类

Object类

Object类是所有类(包括超类,基类)的直接或间接父类,位于继承树的最顶层。任何类,如果没有显式地继承某个类,都默认直接继承Object类,否则为间接继承。Object类所定义的方法,是所有对象都具备的方法。Object类中可以存储任何对象,它作为参数时,可以接受任何对象;作为返回值时,可返回任何对象。
1、hashCode()方法
hashCode()方法返回该对象的hash值。hash值是根据对象的地址使用hash函数计算出来的int类型的数值。一般情况下,相同的对象会返回相同的hash值。

User user = new User("小明",20);
User user1 = new User("Lee",21);
User user2 = user;
//hashCode()方法
System.out.println(user.hashCode()); //356573597
System.out.println(user1.hashCode());//1735600054
System.out.println(user2.hashCode());//356573597

2、toString()方法
返回该对象的字符串表示,可以根据需求重写该方法,例如显示对象的各个属性的值。
不重写Object类的toString()方法,Object类自身的toString()方法返回一个字符串,包名+类名+@+该对象哈希码的无符号十六进制表示 如:usual.User@1540e19d
重写Object类的toString()方法,显示对象的各个属性的值,
User{name=‘null’, age=0}。

//重写toString()方法
@Override
    public String toString() {
        return "User{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
//toString()方法
//不重写Object的toString方法时
//System.out.println(user.toString()); //usual.User@1540e19d
//重写toString方法后
user.setAge(20);
System.out.println(user.toString()); //User{name='null', age=20}

3、clone()方法
clone()创建并返回此对象的副本,实现对象中各个属性的复制,以后可以改变各自的状态,而互不影响。但它的可见范围是protected的,实体类使用克隆的前提是:
1、实现Cloneable接口,这是一个标记接口,本身没有方法。
2、覆盖clone()方法,可见性提升为public。

浅拷贝:被复制对象的所有值属性都与原来对象的相同,所有的对象引用属性仍然指向原来的对象。
深拷贝:在浅拷贝的基础上,所有引用其他对象的变量也进行了clone,并指向被复制过的新对象。
如果被复制的属性都是基本类型,只需要实现当前类的cloneable机制就可以了,此为浅拷贝。
如果被复制对象的属性包含其他实体类对象引用,那么这些实体类对象都需要实现Cloneable接口并重写clone()方法。

public class User implements Cloneable {
    private String name;
    private int age;
}
	//clone()方法
        try {
            User cloneUser = (User) user.clone();
            System.out.println(user == cloneUser); //false
            cloneUser.setAge(18);
            System.out.println(cloneUser); //User{name='小明', age=18}
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

4、getClass()方法
getClass()方法返回对象运行时的实例类。通常用来判断两个引用中实际对象的类型是否一致。

//getCLass()方法
User stuUser = new Student();
Class userClass = user.getClass();
Class user1Class = user1.getClass();
Class stuUserClass = stuUser.getClass();
System.out.println(userClass);  //class usual.User
System.out.println(user1Class); //class usual.User
System.out.println(stuUserClass);   //class usual.Student
System.out.println(userClass == stuUserClass);  //false

5、notify()方法
唤醒正在等待对象监视器的单个线程。 如果任何线程正在等待这个对象,其中一个被选择被唤醒。选择是任意的,并且由实施的判断发生。 线程通过调用wait方法之一。
唤醒的线程将无法继续,直到当前线程放弃此对象上的锁定为止。 唤醒的线程将以通常的方式与任何其他线程竞争,这些线程可能正在积极地竞争在该对象上进行同步; 例如,唤醒的线程在下一个锁定该对象的线程中没有可靠的权限或缺点。
该方法只能由作为该对象的监视器的所有者的线程调用。 线程以三种方式之一成为对象监视器的所有者:
通过执行该对象的同步实例方法。
通过执行在对象上synchronized synchronized语句的正文。
对于类型为Class,的对象,通过执行该类的同步静态方法。
一次只能有一个线程可以拥有一个对象的显示器。

6、wait()方法
导致当前线程等待,直到另一个线程调用该对象的notify()方法或notifyAll()方法。 换句话说,这个方法的行为就好像简单地执行呼叫wait(0) 。
当前的线程必须拥有该对象的显示器。 该线程释放此监视器的所有权,并等待另一个线程通知等待该对象监视器的线程通过调用notify方法或notifyAll方法notifyAll 。 然后线程等待,直到它可以重新获得监视器的所有权并恢复执行。
像在一个参数版本中,中断和虚假唤醒是可能的,并且该方法应该始终在循环中使用:
synchronized (obj) {
while ()
obj.wait();
… // Perform action appropriate to condition
}
该方法只能由作为该对象的监视器的所有者的线程调用。 有关线程可以成为监视器所有者的方式的说明,请参阅notify方法。

7、equals()方法
该方法默认实现为(this==obj),判断两个对象地址是否相同。也可重写,比较两个对象的内容是否相同。返回值类型是boolean类型,若比较的两个对象地址相同则返回true,反之为false。
注意,无论何时重写该方法,通常需要重写hashCode方法,以便维护hashCode方法的通用合同,该方法规定相等的对象必须具有相等的哈希值。
重写equals()方法:
1、比较两个引用是否指向同一个对象
2、判断obj是否为null
3、判断两个引用指向的实际对象类型是否一致
4、强制类型转换,一次性比较各个属性值是否相同

	//重写equals方法
    @Override
    public boolean equals(Object obj) {
        // return super.equals(obj);
        // 比较两个引用是否指向同一个对象
        if (this == obj) {
            return true;
        }
        // 判断obj是否为null
        if (obj == null) {
            return false;
        }
        // 判断两个引用指向的实际对象类型是否一致
        if (obj instanceof User) {
            User user = (User) obj;
            if (this.name.equals(user.getName()) && this.age == user.getAge()) {
                return true;
            }
        }
        return false;
    }
		//equals()方法
		User user = new User("小明",20);
        User user1 = new User("Lee",21);
        User user2 = user;
        System.out.println(user.equals(user1)); //false
        System.out.println(user.equals(user2)); //true

8、finalize()方法
当对象被判定为垃圾对象,由JVM自动调用此方法,标记垃圾对象,进入回收队列。
垃圾对象:没有有效引用指向此对象时,此对象为垃圾对象。
垃圾回收:由gc销毁垃圾对象,释放数据存储空间。
自动回收机制:JVM内存耗尽,一次性回收所有垃圾对象。
手动回收机制:使用System.gc(),通知JVM执行垃圾回收。

	//重写finalize方法
    @Override
    protected void finalize() throws Throwable {
        // super.finalize();
        System.out.println(this+"被回收了...");
    }
		//finalize()方法
        User user3 = new User("A",19);
        User user4 = new User("B",20);
        //C没有有效引用,被回收v
        new User("C",21);   //User{name='C', age=21}被回收了...
        System.gc();
Math类

java.lang.Math包提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double类型。
abs() 绝对值
acos(),asin(),atan(),cos(),sin(),tan() 三角函数、反三角函数
sqrt() 平方根
pow(double a,doble b) a的b次幂 log
自然对数 exp() 以e为底的指数
max(double a,double b)
min(double a,double b)
random():返回取值范围是[0.0,1.0)的左闭右开区间,返回值是一个伪随机数,在该范围内(近似)均匀分布。
long round(double a) :double类型数据转换为long类型(四舍五入)
toDegrees(double angrad) 弧度—>角度
toRadians(double angdeg) 角度—>弧度

   //Math类
    System.out.println(Math.pow(2, 3));
    System.out.println(Math.abs(-1));
    System.out.println(Math.round(1231.213124));  //long 四舍五入
    System.out.println(Math.random() + 1);
    System.out.println(Math.exp(1 / 2));
    System.out.println(Math.sin(Math.PI / 2));
    System.out.println(Math.sqrt(2));
    System.out.println(Math.toDegrees(Math.PI / 2));
    System.out.println(Math.toRadians(30) * 6); //Pi
Random类

Random常用来创建一些随机数
1、实现的随机算法是伪随机,也就是有规则的随机,所谓有规则的就是在给定种子(seed)的区间内随机生成数字;
2、相同种子数的Random对象,相同次数生成的随机数字完全相同;
3、Random类中各方法生成的随机数字都是均匀分布的,也就是说区间内部的数字生成的几率均等;
Random():使用一个和当前系统时间对应的相对时间有关的数字作为种子数。Random(long seed):直接传入一个种子数。

		// Random类
        Random random = new Random();
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(10); //获取数的范围:[0,10)
        }
        for (int elem : arr) {
            System.out.print(elem + "t");
        }
        System.out.println();
UUID

什么是UUID?
UUID全称:Universally Unique ldentifier,通用唯一识别码。
UUID是由一组32位数的16进制数字所构成,UUID理论上的每纳秒产生1兆个UUID,要花100亿年才会将所有UUID用完。
UUID的标准型式包含32个16进制数字,以连字号分为五段,形式为8-4-4-4-12的32个字符,如:b0f483a7-c6b3-4d3f-8d32-3b07f6c1bb98

UUID的作用
UUID的是让分布式系统中的所有元素都能有唯一的辨识信息,而不需要通过中央控制端来做辨识信息的指定。如此一来,每个人都可以创建不与其它人冲突的UUID。
在这样的情况下,就不需考虑数据库创建时的名称重复问题。目前最广泛应用的UUID,是微软公司的全局唯—标识行(t系统、LUKS加密分区、GNOME、KDE、Mac OS X等等。

UUID的组成
UUID是指在一台机器上生成的数字,它保证对在同一时空中的所有机器都是唯一的。通常平台会提供生成的API。按照开放软件基金会(OSF)制定的标准计算,用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字。

UUID由以下几部分的组合:
当前日期和时间,UUID的第一个部分与时间有关,如果你在生成一个UUID之后,过几秒又生成一个UUID,则第一个部分不同,其余相同。时钟序列。全局唯一的IEEE机器识别号,如果有网卡,从网卡MAC地址获得,没有网卡以其他方式获得。

UUID的唯一缺陷在于生成的结果串会比较长。关于UUID这个标准使用最普遍的是微软的GUID(Globals Unique ldentifiers)。

		//UUID 生成随机的UUID
        String uuid = UUID.randomUUID().toString();
        String uuid2 = UUID.randomUUID().toString();
        System.out.println(uuid);
        System.out.println(uuid2);

        //去除‘-’符号
        String str = UUID.randomUUID().toString().replaceAll("-", "");
        System.out.println(str);
File类

java.io.File类是java中很常见的一个类。该类有以下特点:
1、封装文件或目录。
2、无法创建文件,在程序中创建一个File对象,并不会在计算机创建一个文件,这个File对象是计算机上某个文件的对象的引用。
3、不能向文件中写入内容,不能从文件中读取内容。
常见方法:
exists():File对象表示的文件名或目录是否存在,存在返回true。
canRead():File对象表示的文件名或目录存在且可读,存在返回true。
canWrite():File对象表示的文件名或目录存在且可写,存在返回true。
isFile():File对象是一个文件,返回true。
isDirectory():File对象表示的是一个目录,返回true。
isAbsolute():File对象表示的文件是用绝对路径名创建的,返回true。
isHidden():File对象表示的文件属性是隐藏的,返回true。
getAbsolutePath():返回File对象表示的文件或目录的绝对路径。
getCanonicalPath():返回File对象表示的文件或目录的绝对路径,用于unix系统
getName():返回File对象表示的文件或目录的名称。
getPath():返回File对象表示的文件或目录的完整路径。
getParent():返回File对象表示的文件或目录的父目录的完整路径。
lastModified():返回File对象表示的文件或目录的最后一次修改时间。
length():返回File对象表示的文件或目录的长度。
listFiles():如果返回File对象表示的是一个目录,则返回该目录下所有的文件和目录。
delete():删除File对象表示的文件或目录。
renameTo(File file):重命名文件或目录。

 public static void main(String[] args) {
        File file = new File("1.txt");
        File file1 = new File("E:\IDEAWorkSpace\JavaSE");
        File[] files = file1.listFiles();
        for (File fileElem : files) {
            System.out.print(fileElem.getName()+"t");
        }
        System.out.println();
        System.out.println("file==file1:"+file.equals(file1));  //false
        System.out.println("isFile:"+file.isFile());
        System.out.println("fileName:"+file.getName());
        System.out.println("fileLength:"+file.length());
        System.out.println("lastModified:"+file.lastModified());
        System.out.println("absolutePath:"+file.getAbsolutePath());
        System.out.println("getParentPath:"+file1.getParent());
        System.out.println("isDirectory:" + file.isDirectory());
        System.out.println("canRead:"+file.canRead());
        System.out.println("canWrite:"+file.canWrite());

    }
包装类

Java提供了8种基本数据类型对应的包装类
byte–>Byte
short–>Short
int–>Integer
long–>Long
float–>Float
double–>Double
boolean–>Boolean
char–>Character

自动装箱和自动拆箱
创建包装类对象有两种方式:new关键字和valueOf()方法。
JDK1.5之后,提供自动装箱和拆箱的功能

	public static void main(String[] args) {
        int i = 10;
        //int取值范围
        System.out.println(Integer.MIN_VALUE + "~" + Integer.MAX_VALUE);

        //创建包装类对象有两种方式:new关键字和valueOf()方法。
        //自动装箱
        Integer integer = new Integer(i);  //基本数据类型转换为包装类
        //自动拆箱 引用类型转换为基本类型
        int j = integer;
        System.out.println(j);
        Integer value = Integer.valueOf("12345");
        //将String类型解析为int类型
        int parseInt = Integer.parseInt("1000");
        System.out.println(integer);
        System.out.println(value);
        System.out.println(parseInt);

    }
Date类和Calendar类

1、java.util.Date 从1970-1-1开始计算的时间
两个构造器:
new Date(): 获取当前时间
new Date(long date): 获取毫秒数对应的时间
两个方法:
toString() : 输出时间的内容
getTime() : 获取时间对应的毫秒数

2、java.sql.Date
一个构造器:
new Date(long date); 获取毫秒数对应的日期
两个方法:
toString() : 输出日期的内容
getTime() : 获取日期对应的毫秒数

3、java.text.SimpleDateFormat : 用来格式化日期和时间
两个方法:
format(Date date) : 将Date转成字符串
parse(String time) : 将字符串转成Date的格式
注意:字符串中时间的格式和当前对象设置的时间格式必须一致

Calendar类
构造方法:protected Calendar():protected修饰,无法直接创建对象。

public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.getTime());
        System.out.println(date.toString());

        //获取毫秒数对应的日期
        java.sql.Date sqlDate = new java.sql.Date(date.getTime());
        System.out.println(sqlDate.toString());

        //SimpleDateFormat类
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = sdf.format(date);
        System.out.println("time:" + time);
        try {
            //将字符串转换为date
            Date date1 = sdf.parse("2000-01-01 00:00:01");
            System.out.println(date1);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        //Calendar类
        //获得calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getClass().getName()); //java.util.GregorianCalendar
        System.out.println(calendar.getCalendarType());
        //查询本周是今年的第几周
        int week = calendar.get(Calendar.WEEK_OF_YEAR);
        System.out.println("week:" + week);
        //查询今天是本月的第几天
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println("day:" + day);
        //获得日历所对应的日期和时间
        Date calendarDate = calendar.getTime();
        System.out.println(calendarDate);
    }
String、StringBuffer和StringBuilder

String类被final修饰,不能被继承。
String实现了Serializable接口,该类的对象可以被序列化。
序列化:可以将对象写到硬盘上,也可将不同进程间的对象进行传递
String实现了Comparable接口 :可以用来比较内容(往往通过Comparable接口实现排序的功能)
String(StringBuffer,StringBuilder)实现了CharSequence接口:
实现该接口可以获取字符串的长度,获取指定索引位置上的字符等。
String底层是一个char[],而且被final修饰。String是一个不可变长的字符序列
面试题 String str = new String(“abc”)语句在内存中开辟了几块空间?
常量池中一块空间,堆中一块空间。

内存结构分析:
①String s = “abc”; //在常量池中创建一个"abc"
②String s = new String(“abc”);//在堆中创建一个对象,在常量池中创建一个"abc"。
注:常量池中没有重复的内容。

常用方法:
增(添加,连接),删(delete),改(replace),查(indexOf),插入(insert),长度(length)
int length():返回字符串的长度: return value.length
char charAt(int index): 返回某索引处的字符 return value[index]
boolean isEmpty():判断是否空串:return value.length == 0
String toLowerCase():将 String 中的所有字符转换为小写
String toUpperCase():将 String 中的所有字符转换为大写
String trim():返回字符串的副本,忽略前导空白和尾部空白
boolean equals(Object obj):比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString):与equals方法类似,忽略大小写
String concat(String str):将指定字符串连接到此字符串的结尾。等价于“+”
String substring(int beginIndex):返回一个新的字符串,它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex) :返回一个新字符串,它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
boolean contains(CharSequence s):当且仅当此字符串包含指定的 char 值序列时,返回 true
int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始
int lastIndexOf(String str):返回指定子字符串在此字符串中最后一次出现处的索引
int lastIndexOf(String str, int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索
注:indexOf和lastIndexOf方法,如果未找到都是返回-1
boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始
String replace(char oldChar, char newChar):返回一个新的字符串,通过用 newChar替换此字符串中出现的所有oldChar 得到的。
String replace(CharSequence target, CharSequence replacement):使用指定的字面值替换序列替换此字符串所匹配字面值目标序列的子字符串。
String replaceAll(String regex, String replacement):使用给定的 replacement 替换此字符串所匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement):使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
String[] split(String regex):根据给定的匹配拆分此字符串。

与其它数据类型的转换:
1、与基本数据类型、包装类之间的转换:
String -> 基本数据类型 : Integer.parseInt(“111”);
String -> 包装类 : new Integer(“111”);

2、与字节数组byte[]之间的转换:
String -> byte[] : byte[] b = “abc”.getBytes();
byte[] -> String : new String(b);

3、与字符数组char[]之间的转换:
String -> char[] : char[] c = “abc”.toCharArray();
char[] -> String : new String;

StringBuffer和StringBuilder
String: 不可变的字符序列,底层是char[],被final所修饰
StringBuffer: 可变的字符序列,JDK1.0提供,线程安全,效率低,底层是char[]
StringBuffer类中的方法都添加了synchronized关键字,给这个方法添加了一个锁,用来保证线程安全。
StringBuilder: 可变的字符序列 JDK1.5提供,线程不安全,效率高,底层是char[]

StringBuffer构造器
StringBuffer():创建初始容量为16的字符串缓冲区
StringBuffer(int size):构造指定容量的字符串缓冲区
StringBuffer(String str):将内容初始化为指定字符串内容

StringBuffer常用方法
StringBuffer append(xxx):用于进行字符串拼接
StringBuffer delete(int start,int end):删除指定位置的内容
StringBuffer replace(int start, int end, String str):把[start,end)位置替换为str
StringBuffer insert(int offset, xx):在字符串指定位置插入数据
StringBuffer reverse() :将字符串逆转
public int indexOf(String str)
public String substring(int start,int end)
public int length()
public char charAt(int n)
public void setCharAt(int n ,char ch):将指定位置的字符改为指定字符

底层扩容机制:
当我们通过空参的StringBuffer创建对象时,底层创建一个长度为16的数组,向该数组添加第17个元素时底层会自动扩容,扩容为原来的2倍+2.同时将原数组中的内容复制到新的数组中。

StringBuilder构造器和方法与StringBuffer基本相同

public static void main(String[] args) {
        String str = "abcda";
        System.out.println("str.length:" + str.length());
        System.out.println("charAt 0:" + str.charAt(0));
        System.out.println("UpperCase:" + str.toUpperCase());
        System.out.println("trim:" + str.trim());
        System.out.println("subString 1:" + str.substring(1));
        System.out.println("subString [0,2):" + str.substring(0, 2));
        System.out.println("contains a:" + str.contains("a"));
        System.out.println("index b:" + str.indexOf("b"));
        System.out.println("index a:" + str.indexOf("a", 1));
        System.out.println("lastIndex ab:" + str.lastIndexOf("ab"));
        System.out.println("lastIndex da:" + str.lastIndexOf("da", 4));
        System.out.println("endWith da:" + str.endsWith("da"));
        System.out.println("startWith abac:" + str.startsWith("abac"));
        System.out.println("a-->e" + str.replace('a', 'e'));
        // 根据给定的匹配拆分此字符串
        String[] split = str.split("c");
        for (String s : split) {
            System.out.print(s + "t");
        }
        System.out.println();
        String concat = str.concat("123");
        String str1 = "abcda" + "123";
        String str2 = "abcda123";
        System.out.println("concat:" + concat);
        System.out.println(str1 == concat);   //false
        System.out.println(str1.equals(concat)); //true
        System.out.println(str1 == str2);   //true

        //基本数据类型和String转换
        //String -->int
        int i = Integer.parseInt("123");
        System.out.println(i);
        //String -->Integer
        Integer integer = new Integer("456");
        System.out.println(integer);
        //String -->byte[]
        byte[] bytes = "qwe".getBytes();
        //byte[] -->String
        String s = new String(bytes);
        System.out.println("s:" + s);

        //String -->char[]
        char[] chars = s.toCharArray();
        //char[] -->String
        String s1 = new String(chars);
        System.out.println("s1:" + s1);

        String string = "a" + 1 + 2;   //12a
        String string1 = 1 + 2 + "a";  //3a
        System.out.println("sting:" + string + "t string1:" + string1);

        //StringBuffer
        // StringBuffer buffer = new StringBuffer(20);
        StringBuffer buffer = new StringBuffer();
        buffer.append("Lee").append(" 20");
        StringBuffer reverse = buffer.reverse();
        System.out.println("reverse:" + reverse);
        buffer.insert(0,"5");
        System.out.println(buffer);
        buffer.setCharAt(1,'e');
        System.out.println(buffer);
        System.out.println("buffer length:" + buffer.length());

        //StringBuilder
        StringBuilder builder = new StringBuilder();
        builder.append("Java").append("EE").append("666");
        System.out.println("builder:"+builder);
        builder.delete(0,builder.length());
        System.out.println("builder:"+builder);
    }
System类

System类代表系统,系统级很多属性和控制方法都放置在该类的内部。
该类的构造器是private的,无法创建该类的对象,也就无法实例化该类。其内部的成员变量和成员方法都是static的,可以很方便的进行调用。

常用方法:
static native long currentTimeMillis();
返回当前的计算机时间,时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。

static native void arraycopy(Object src, int srcPos, Object dest,int length); 复制数组 src:原数组 srcPos:从指定位置开始复制
destPos:目标数组的位置,length:复制的长度

static void gc():通知JVM回收垃圾对象

static void exit(int status):退出JVM,参数为0表示正常退出,参数非0表示异常退出

public static void main(String[] args) {
        //复制数组
        int[] arr = new int[]{1, -1, 0, 2, -2, -3, 3};
        int[] dest = new int[10];
        System.arraycopy(arr, 0, dest, 1, 7);

        for (int elem : dest) {
            System.out.print(elem + "t");
        }

        StringBuffer buffer = new StringBuffer();
        StringBuilder builder = new StringBuilder();
        long bufferStart = System.currentTimeMillis();
        for (int i = 0; i < 9999; i++) {
            for (int j = 0; j < 9999; j++) {
                buffer.append(i + j);
            }
        }
        System.out.println();
        long bufferEnd = System.currentTimeMillis();
        System.out.println("buffer拼接循环用时:" + (bufferEnd - bufferStart) + "ms");

        long builderStart = System.currentTimeMillis();
        for (int i = 0; i < 9999; i++) {
            for (int j = 0; j < 9999; j++) {
                builder.append(i + j);
            }
        }
        long builderEnd = System.currentTimeMillis();
        System.out.println("builder拼接循环用时:" + (builderEnd - builderStart) + "ms");

        System.exit(0);
        System.out.println("JVM退出了...");  //未执行
    }
BigInteger和BigDecimal

BigInteger
可以对比Integer类范围更大的数进行计算。

BigDecimal
一般的Float类和Double类可以做科学计算或工程计算。
但在商业计算中,要求数字精度比较高,用到java.math.BigDecimal类。

public static void main(String[] args) {

        int i = Integer.MAX_VALUE;
        BigInteger a = new BigInteger(String.valueOf(i));
        BigInteger b = new BigInteger(String.valueOf(1000000000));
        System.out.println(a.add(b));

        BigDecimal c = new BigDecimal(String.valueOf(100));
        BigDecimal d = new BigDecimal(String.valueOf(0.412));
        System.out.println(c.subtract(d));
        System.out.println(c.multiply(d));

    }
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/966557.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号