java-API_常用类介绍及运用

130 阅读 0 评论 86 点赞

我是靠谱客的博主寂寞战斗机，最近开发中收集的这篇文章主要介绍java-API_常用类介绍及运用，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

java - API_常用类

- - 1.概述
  - 2.基本数据类型包装类
  - 3.Object类
  - - - 3.1.toString方法
      - 3.2equal方法
  - 4.Arrays类
  - - - 4.1equals 方法
      - 4.2sort-排序
      - sort()函数的基本格式（默认排序为升序排序）
      - 如果一个数组初始化时已经赋值。则sort函数可以另外一种格式
      - 4.3二分搜索算法
      - 4.4toString()方法
  - 5.String类
  - - - 5.1String s = "";
      - 5.2构造方法
      - 5.3判断功能
      - 5.4获取功能
      - 5.5转换功能
      - 5.6替换功能
      - 5.7正则表达式
  - 6.StringBuffer/StringBuild类
  - - - 6.1概述
      - 6.2构造方法
      - 6.3添加功能
      - 6.4删除功能
      - 6.5替换功能
      - 6.6翻转功能
      - 6.7截取功能
      - 6.8例如
  - 7.Math类
  - - - 7.1概念
      - 7.2代码
  - 8.Random类
  - - - 8.1概念
      - 8.2java.lang.Math.Random(第一类)
      - 8.3java.util.Random(第二类)
      - 8.4备注
  - 9.System
  - - - 9.1概述
      - 9.2成员方法
  - 10.Date类
  - - - 1.概念
      - 2.创建对象
      - 3.成员方法
  - 11.Calendar类
  - - - 11.1概念
      - 11.2创建对象
      - 11.3成员方法
  - 12.SimpleDateFormat类
  - 13.BigInterger类
  - - - 13.1概念
      - 13.2构造方法
      - 13.3BigInteger类常用方法
      - 13.4利用BigInteger构造方法转换进制
  - 14.BigDecimal类
  - - - 14.1概念
      - 14.2常用的构造方法
      - 14.3常用方法
      - 14.4大小比较

1.概述

API应用程序编程接口

API文档:是对java预先定义的类或接口功能和方法功能的说明文档,目的是提供给开发人员进行使用帮助说明

2.基本数据类型包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类.

包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作。

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

对于包装类说，这些类的用途主要包含两种：

1.作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。

2.包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法

包装类常见方法

以下方法以java.lang.Integer为例

public static final int MAX_VALUE 最大的int型数（231-1）

public static final int MIN_VALUE 最小的int型数（-231）

public int intValue() 返回封装数据的int型值

public static int parseInt(String s)将字符串解析成int型数据，返回该数据

public static Integer valueOf(String s)返回Integer对象，其中封装的整型数据为字符串s所表示。

public String toString()返回一个表示该 Integer 值的 String 对象。

public static String toString(int i)返回一个表示指定整数的 String 对象

装箱和拆箱Auto-boxing/unboxing

1.装箱

自动将基本数据类型转换为包装器类型

装箱的时候自动调用的是Integer的valueOf(int)方法

2.拆箱

自动将包装器类型转换为基本数据类型

拆箱的时候自动调用的是Integer的intValue方法

3.Object类

Object类是所有java类的祖先(根基类).每个类都使用Object作为超类(父类).所有对象(包括数组)都实现这个类的方法.

如果在类的声明中未使用extends关键字指明其基类,则默认基类为Object类

public class Person{…}

等价于:

public class Person extends Object{…}

3.1.toString方法

Object类中定义有public String toString()方法,其返回值是String类型,描述当前对象的有关信息.

在进行String与其他类型数据的连接操作时(如:System.out.println(“info”+person)),将自动调用该对象类的toString()方法

可以根据需要在用户自定义类型中重写toString()方法.

3.2equal方法

Object类中定义有:

public boolean equals(Object obj)方法

提供定义对象是否"相等"的逻辑.

Object的equals方法定义为:x.equals(y),当x和y是同一个对象的引用时返回true否则返回false

JDK提供的一些类,如String,Date等,重写了Object的equals方法,调用这些类的equals方法,x.equals(y),当x和y所引用的对象是同一类对象且属性内容相等时(并不一定是相同对象),返回true否则返回false.

import java.util.Arrays;
public class ObjectDemo extends Object{
public static void main(String[] args) { 
ObjectDemo obj = new ObjectDemo();

 int[] a = new int[5];//数组也是继承了Object
       a.hashCode();
Person p = new Person("jim",18);

System.out.println(p);
System.out.println("info==="+p);

 String s1 = new String("abc");
 String s2 = new String("abc");

 // == 基本类型比较的就是具体的值
 // == 再对引用类型进行比较时,比较的是引用的对象地址是否相同
 System.out.println(s1==s2);

 //一般类都重写Object类中equals(), 他们有自己的实现方式,比较的是对象中包含的内容(具体值)是否相等
System.out.println(s1.equals(s2));
}
}

package com.ff.javaapi.day1;

public class Person extends  Object{
String name;
int age;

public Person(String name, int age) {
    this.name = name;
    this.age = age;
}

@Override
public String toString() {//对toString方法的重写
    return "Person{" +
            "name='" + name + ''' +
            ", age=" + age +
            '}';
}
}

4.Arrays类

java.util.Arrays类
用于操作数组工具类，里面定义了常见操作数组的静态方法。

4.1equals 方法

比较两个非同一数组是否相等，而数组本身的equals判断另一个数组是否它本身。
声明：public static boolean equals(type[]a,type[]a2)
参数的类型可以是原生数据类型和引用类型的任意一种类型。
返回：如果两个相等，则返回true，否则返回false

4.2sort-排序

sort()函数的基本格式（默认排序为升序排序）

**Arrays.sort(int[] a, int fromIndex, int toIndex)；**Arrays.sort(数组名,起始下标,终止下标);

例如

import java.util.Arrays;
import java.util.Scanner;
import java.util.*;
 
public class Main {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc= new Scanner(System.in);
		int n=sc.nextInt();
		int[] a= new int[10001];
		for(int i=0;i<n;i++){
			a[i]=sc.nextInt();
		}
		Arrays.sort(a,0,n);
		for(int i=0;i<n;i++){
			if(i==n-1){
				System.out.println(a[i]);
			}
			else{
				System.out.print(a[i]+" ");
			}
		}
	}
 
}

如果一个数组初始化时已经赋值。则sort函数可以另外一种格式

Arrays.sort(数组名);

例如

  import java.util.*;  
    import java.util.Arrays;  
    public class Main {  
        public static void main(String[] args) {  
              
            Scanner sc=new Scanner(System.in);  
                int num[]= {5,4,3,2,1};                    
                Arrays.sort(num);                    
                for(int i=0;i<5;i++)  
                {  
                    System.out.println(num[i]);  
                      
                }  
          
      
        }  
    }

自定义排序

sort(List list, Comparator c)：根据指定比较器产生的顺序对指定列表进行排序，也就是自定义排序，第一个参数是传入的要排序的列表，第二个参数是指定的比较器。

int compare(Object o1, Object o2) 返回一个基本类型的整型
如果要按照升序排序，
则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）
如果要按照降序排序
则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）

例如----输入n个数，然后降序排序。

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
 
class shu{
	int x;
}
class cmp implements Comparator<shu>{
	public int compare(shu a,shu b){
		if(a.x<b.x){
			return 1;
		}
		else if(a.x>b.x){
			return -1;
		}
		else{
			return 0;
		}
		//可以简化成
		//return b.x-a.x
	}
}
public class Main {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		int n=sc.nextInt();
		shu num[] = new shu[100];
		for(int i=0;i<n;i++){
			num[i]=new shu();    ///这个地方容易漏  
			num[i].x=sc.nextInt();
		}
		
		Arrays.sort(num,0,n,new cmp());
		
		for(int i=0;i<n;i++){
			if(i==n-1){
				System.out.println(num[i].x);  
			}
			else{
				System.out.print(num[i].x+" ");  
			}			
		}
		sc.close();
}
	}

4.3二分搜索算法

二分查找（binary search）

二分搜索，也称折半搜索，是一种在 有序数组 中 查找某一特定元素 的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。
- 时间复杂度:折半搜索每次把搜索区域减少一半，时间复杂度为O(log n)。（n代表集合中元素的个数）
- 空间复杂度: O(1)。虽以递归形式定义，但是尾递归，可改写为循环。
声明和使用

binarySearch -使用二分搜索算法搜索指定数组

public static int binarySearch(type[] a, type key)
public static int binarySearch(long[] a,int fromIndex,int toIndex,long key)

a - 要搜索的数组。

key - 要搜索的值。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

type -byte、double、float、object、long、int、short、char

如果key在数组中，则返回搜索值的索引；否则返回-1或者”-“(插入点)

内部代码

int bsearchWithoutRecursion(int a[], int key) {    
    int low = 0;    
    int high = a.length - 1;
    while (low <= high) {   
        int mid = low + (high - low) / 2;
        if (a[mid] > key)     
            high = mid - 1;
        else if (a[mid] < key)    
            low = mid + 1;
        else    return mid;    
    }    
    return -1; 
}

4.4toString()方法

声明

public static String toString(type[] a)
描述

返回指定数组内容的字符串表示形式

基本数组，字符串表示形式由数组的元素列表组成，括在[]，相邻元素用“, ”(逗号加空格)分隔。

例如

int[] i = new int []{1,2,3};
System.out.println(i);
System.out.println(Arrays.toString(i));
/*结果:
*[I@14ae5a5
*[1,2,3]
*/

5.String类

java中所有的字符串都是String类的对象
值一旦给定不能改变,一旦修改会重新创建一个新的对象

两种创建方法:

5.1String s = “”;

特点:创建对象时,先在常量池检测有没有相同的值,
如果没有就在堆中创建一个字符串对象,值在常量池中
第二次创建时,常量池已经存在,直接让引用变量指向已有的字符串对象

5.2构造方法

public String()

public String(String str)

public String(byte[] bytes) //把byte数组转为字符串

public String(char[] value)//把char数组转为字符串

例如:

String s = new String();//创建String对象  值是""
        String s1 = new String("abc"); //使用指定的值填充value

        char[] c = {'a','b','c'};
        String s2 = new String(c);
        System.out.println(s2);

        char[] c1 = {'a','b','c'};
        String s3 = new String(c,0,2);
        System.out.println(s3);
        //getBytes("utf-8"); 把字符串转为byte数组,指定字符集(编码格式)
        String s4 = "abc";
        //byte[] b = s4.getBytes(); //把能够看懂的字符转为字节数组编码
        byte[] b = s4.getBytes("utf-8"); //把能够看懂的字符转为字节数组编码
        System.out.println(Arrays.toString(b));
        String s5= "中文";
        byte[] b1 = s5.getBytes("utf-8"); //把能够看懂的字符转为字节数组编码
        System.out.println(Arrays.toString(b1));
        System.out.println(new String(b));
        System.out.println(new String(b,"utf-8"));
        System.out.println(new String(b1,"utf-8"));// 把看不懂的byte数组转为字符  解码
        System.out.println(new String(b1,0,3,"utf-8"));
        //注意:编码和解码时 两端的编码表要一致 ,否则会乱码

5.3判断功能

boolean equals(Object obj)//判断是否相等

boolean equalsIgnoreCase(String str)//判断是否相等,忽略大小写

boolean contains(String str)//是否包含指定字符串

boolean isEmpty()//判断字符串内容是否为空,为空("") true ,否则false

boolean startsWith(String prefix)//判断是否以指定字符串开头

boolean endsWith(String suffix)//判断是否以指定字符串结尾

例如:

public static void main(String[] args) {
          String s1 = "abc";
          String s2 = new String("abc");
          String s3 = new String("abC");
          System.out.println(s1==s2);//false ,地址不相同
          System.out.println(s1.equals(s2));//重写Object类equals
          System.out.println(s1.equalsIgnoreCase(s3));//不区分大小写比较
          System.out.println("a".compareTo("b"));
        System.out.println(s1.contains("a"));//是否包含指定字符串
        System.out.println(s1.contains("ab"));
        System.out.println(s1.isEmpty());
        System.out.println("".isEmpty());//判断字符串内容是否为空, 为空("")true  
        System.out.println(s1.startsWith("a"));//判断是否已指定字符串开头
        System.out.println(s1.startsWith("ab"));
        System.out.println(s1.endsWith("ab"));判断是否已指定字符串结尾

    }

5.4获取功能

int length() //获取字符串长度

char charAt(int index)//返回指定位置上的字符

int indexOf(String str)//获得字符首次出现的位置,从前往后找

int indexOf(String str,int fromIndex)//从指定位置开始找,获取字符串首次出现的位置

int lastIndexof(String str)//获取字符首次出现的位置,从后往前找

int lastIndexof(String str , int fromIndex)//从指定位置开始找,获取字符串首次出现的位置

String substring(int start)//从指定位置开始截取到结束,返回一个新的字符串

String substring(int start,int end)//从指定位置开始截取到指定位置结束,返回一个新的字符串,不包含结束

例如:

public static void main(String[] args) {
        String s1 = "abcdefgcs";
                 //  012345678
        System.out.println(s1.length());
        System.out.println(s1.charAt(4));//返回指定位置上的字符
        System.out.println(s1.indexOf("c"));//获得字符首次出现的位置从前向后找
    System.out.println(s1.indexOf("c",s1.indexOf("c")+1));
        System.out.println(s1.lastIndexOf("c"));//获得字符首次出现的位置从后向前找
        String s2 = s1.substring(3);
        System.out.println(s2);//从指定位置开始截取到结束,返回一个新的字符串
        String s3 = s1.substring(3,7);//截取指定区间的字符串,返回一个新的字符串  包含开始,不包含结束
        System.out.println(s3);
    }

5.5转换功能

byte[] getBytes()//把字符串转为byte数组

char[] toCharArray()//把字符串转为字符数组

static String valueOf(char[] chs)//把字符数组转为字符串

String toLowerCase()//把字符串转为小写字母

String toUpperCase()//把字符串转为大写字母

String concat(String str)//把两个字符串连接起来,返回一个新的字符串

Stirng[] split(分割符);//用正则表达式,将字符串分割为数组

         char [] c = "abc".toCharArray();//把字符串转为字符数组
         String s = String.valueOf(c);//把字符数组转为字符串
         new String(c);
         String s1 = "abcdEFG";
         System.out.println(s1.toLowerCase());//转为小写字母
         System.out.println(s1.toUpperCase());//转为大写字母
         String s2 = s1.concat("xxxx");//把两个字符串连接起来 , 返回一个新的字符串
         System.out.println(s2);
         String s3 = "a:b:c:def";
         String [] array =   s3.split(":");//用正则表达式 ,将字符串分割为数组
         System.out.println(Arrays.toString(array));

5.6替换功能

String replace(char old,char new)//替换

String replace(String old,String new)

replaceAll(String regex, String replacement)//将所有的指定字符换成给定字符

replaceFirst(String regex, String replacement)//将字符串中的与给定字符相同的第一个字符替换

String trim()//去除空格,不能去除中间的空格

5.7正则表达式

模式匹配语法: 用特定的符号来表示某种规则去匹配某个字符串

如果字符串与规则想匹配返回true,否则返回false

d 匹配数字 == 0-9
数量控制
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

例如:

public static void main(String[] args) {

           String  s = "133456782";
           //boolean b = s.matches("\d*");
           //boolean b = s.matches("\d");
           //boolean b = s.matches("[4-9]");
           //boolean b = s.matches("[357]");
           //boolean b = s.matches("\d?");//一次或一次也没有
           //boolean b = s.matches("\d*");//零次 或 多次
           //boolean b = s.matches("\d+");//一次 或 多次
           //boolean b = s.matches("\d{4}");// 恰好 n 次
           //boolean b = s.matches("\d{4,}");// 至少 n 次
           //boolean b = s.matches("\d{4,7}");// 至少 n 次  最多m次
           //手机号
           //boolean b = s.matches("[1][35789]\d{9}");
           //qq号
           //boolean b = s.matches("[1-9]\d{5,9}");
           //System.out.println(b);

           /*
              D  匹配非数字  不能是数字
              s  空格
              w  [a-zA-Z_0-9]
            */
           String  s1 = "3423adasd@qq1.com";
           //boolean b   = s1.matches("\D*");
           //boolean b   = s1.matches("\s*");
           //boolean b   = s1.matches("[a-z]*");
           //boolean b   = s1.matches("[a-zA-Z]*");
           //boolean b   = s1.matches("[A-z]*");
           //boolean b   = s1.matches("[A-z0-9]*");
           //boolean b   = s1.matches("\w*");
           //boolean b   = s1.matches("\W*");
          //邮箱地址   213213213@qq.com  34324safdsf@sina.com.cn 163
                                // .表示任意字符     需要时对其进行转义  \.
           boolean b   = s1.matches("\w{6,15}@\w{2,6}\.(com|com\.cn)");
           System.out.println(b);
           String s3 = "ab2cd4e2g";
           String[] arr = s3.split("\d");
           System.out.println(Arrays.toString(arr));

           //System.out.println(s3.replace("2","c"));
           System.out.println(s3.replaceAll("\d","A"));
           System.out.println(s3.replaceFirst("\d","A"));
    }

6.StringBuffer/StringBuild类

6.1概述

StringBuilder类功能和StringBuffer功能完全一致

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题

线程安全的可变字符序列

6.2构造方法

public StringBuffer()
public StringBuffer(String str)

6.3添加功能

public StringBuffer append(String str)
public StringBuffer insert(int offset,String str)

6.4删除功能

public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)

6.5替换功能

public StringBuffer replace(int start,int end,String str)

6.6翻转功能

public StringBuffer reverse()

6.7截取功能

public String substring(int start)
public String substring(int start,int end)

截取功能和前面几个功能的不同
返回值类型是String类型，本身没有发生改变

6.8例如

    StringBuffer s1 = new StringBuffer();//默认16长度 char数组
    StringBuffer s2 = new StringBuffer("abc");// 内容长度+16
                 s2.append(1); //向末尾添加字符串  不会创建新的StringBuffer对象
                 s2.append("def");
                 s2.insert(1,"xxxx");//从指定的位置插入一个指定的字符串
    System.out.println(s2);

                  s2.deleteCharAt(0);//删除指定位置上的字符  在原字符串操作 不会返回新的
                  s2.delete(0,5);//删除指定区间的字符串, 包含开始,不包含结束

                  s2.replace(0,5,"ABCD");//替换指定区间的字符串

    System.out.println(s2.reverse());
    System.out.println(s2.substring(0,5));//截取  返回一个新的字符串
        System.out.println(s2);

StringBuilder类功能和StringBuffer功能完全一致, StringBuffer是线程安全的

String类,StringBuffer类和StringBuilder区别

String：是字符常量,适用于少量的字符串操作的情况
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

7.Math类

7.1概念

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。

7.2代码

/*
    * abs 绝对值
     sqrt 平方根
     pow(double a, double b) a的b次幂
    max(double a, double b)
     min(double a, double b)
     random() 返回 0.0 到 1.0 的随机数
     long round(double a) double型的数据a转换为long型（四舍五入）
     */
    public static void main(String[] args) {
        double a = Math.sqrt(9);//平方根
        System.out.println(a);
        int b = Math.abs(-1);//绝对值
        System.out.println(b);
        double c = Math.pow(2,3);//幂次运算 a的b次
        System.out.println(c);
        int d = Math.max(5,3);//最大值
        System.out.println(d);
        int d1 = Math.min(5,3);//最小值
        System.out.println(d1);
        double r = Math.random();//返回0.0到1.0的随机数
        long l = Math.round(c);//double型的数据a转换为long型(四舍五入)
        System.out.println(l);
    }

8.Random类

8.1概念

此类用于产生随机数

java中存在着两类Random函数

8.2java.lang.Math.Random(第一类)

调用这个Math.Random()函数能够返回带正号的double值，该值大于等于0.0且小于1.0，即取值范围是[0.0,1.0)的左闭右开区间，返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。

例子如下：

import java.util.Random;

public class TestRandom {
    
    public static void main(String[] args) {
        // 案例1
        System.out.println("Math.random()=" + Math.random());// 结果是个double类型的值，区间为[0.0,1.0）
        int num = (int) (Math.random() * 3); // 注意不要写成(int)Math.random()*3，这个结果为0，因为先执行了强制转换
        System.out.println("num=" + num);
        /**
         * 输出结果为：
         * 
         * Math.random()=0.02909671613289655
         * num=0
         * 
         */
　　}
}

8.3java.util.Random(第二类)

下面Random()的两种构造方法：
public Random():创建一个新的随机数生成器。

public Random(long seed ????:使用单个 long 种子创建一个新的随机数生成器。

可以在构造Random对象的时候指定种子

如：Random r1 = new Random(20);

或者默认当前系统时间的毫秒数作为种子数:Random r1 = new Random();

**注意:**在创建一个Random对象的时候可以给定任意一个合法的种子数，种子数只是随机算法的起源数字，和生成的随机数的区间没有任何关系。

具体用法如下例：

import java.util.ArrayList;
import java.util.Random;

public class TestRandom {
    
    public static void main(String[] args) {
        
        // 案例2
        // 对于种子相同的Random对象，生成的随机数序列是一样的。
        Random ran1 = new Random(10);
        System.out.println("使用种子为10的Random对象生成[0,10)内随机整数序列: ");
        for (int i = 0; i < 10; i++) {
            System.out.print(ran1.nextInt(10) + " ");
        }
        System.out.println();
        Random ran2 = new Random(10);
        System.out.println("使用另一个种子为10的Random对象生成[0,10)内随机整数序列: ");
        for (int i = 0; i < 10; i++) {
            System.out.print(ran2.nextInt(10) + " ");
        }
        /**
         * 输出结果为：
         * 
         * 使用种子为10的Random对象生成[0,10)内随机整数序列: 
         * 3 0 3 0 6 6 7 8 1 4 
         * 使用另一个种子为10的Random对象生成[0,10)内随机整数序列: 
         * 3 0 3 0 6 6 7 8 1 4 
         * 
         */
        
        // 案例3
        // 在没带参数构造函数生成的Random对象的种子缺省是当前系统时间的毫秒数。
        Random r3 = new Random();
        System.out.println();
        System.out.println("使用种子缺省是当前系统时间的毫秒数的Random对象生成[0,10)内随机整数序列");
        for (int i = 0; i < 10; i++) {
            System.out.print(r3.nextInt(10)+" ");
        }
        /**
         * 输出结果为：
         * 
         * 使用种子缺省是当前系统时间的毫秒数的Random对象生成[0,10)内随机整数序列
         * 1 1 0 4 4 2 3 8 8 4
         *  
         */
        
        // 另外，直接使用Random无法避免生成重复的数字，如果需要生成不重复的随机数序列，需要借助数组和集合类
}

8.4备注

下面是Java.util.Random()方法摘要：

protected int next(int bits)：生成下一个伪随机数。
boolean nextBoolean()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的boolean值。
void nextBytes(byte[] bytes)：生成随机字节并将其置于用户提供的 byte 数组中。
double nextDouble()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的 double值。
float nextFloat()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布float值。
double nextGaussian()：返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的double值，其平均值是0.0标准差是1.0。
int nextInt()：返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
int nextInt(int n)：返回一个伪随机数，它是取自此随机数生成器序列的、在（包括和指定值（不包括）之间均匀分布的int值。
long nextLong()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。
void setSeed(long seed)：使用单个 long 种子设置此随机数生成器的种子。

下面给几个例子：

生成[0,1.0)区间的小数：double d1 = r.nextDouble();
生成[0,5.0)区间的小数：double d2 = r.nextDouble() * 5;
生成[1,2.5)区间的小数：double d3 = r.nextDouble() * 1.5 + 1;
生成-231到231-1之间的整数：int n = r.nextInt();
生成[0,10)区间的整数：

int n2 = r.nextInt(10);//方法一

n2 = Math.abs(r.nextInt() % 10);//方法二

9.System

9.1概述

System类包含一些有用的类字段和方法.它不能被实例化.

9.2成员方法

public static void exit(int status)//终止当前运行的java虚拟机.

public static long currentTimeMillis()//返回当前时间(以毫秒为单位)

public static void arraycopy(Object asc,int scrPos Object dest , int destPos , int length )//将指定源数组中的数组从指定位置复制到目标数组的指定位置.

src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目的地数据中的起始位置。
length - 要复制的数组元素的数量。

public static void gc()//运行垃圾回收器.

public static String getenv(String name)//获取指定环境变量的值.

例如:

public static void main(String[] args) {    System.out.println(System.currentTimeMillis());//返回当前时间(以毫秒为单位)    
                                        int[] a = new int[]{1,2,3};    
                                        int[] b = new int[3];    
                                        System.arraycopy(a,0,b,0,3);//将指定源数组中的数组从指定位置复制到目标数组的指定位置    
                                        System.out.println(Arrays.toString(b));    
                                        String s = "a";    
                                        System.out.println(System.getenv());//获取指定环境变量的值    
                                        System.gc();//运行垃圾回收器    
                                        System.exit(0);//终止当前运行的java虚拟机}

10.Date类

1.概念

使用Date类代表当前系统时间;

抽象类;

2.创建对象

Date d = new Date();//日期对象中封装了当前时间信息,精确到毫秒.

Date d = new Date(long d);

例如:Date d = new Date(160942675972l);//将一个long型的时间,转换为Date对象.

3.成员方法

public long getTime(); //返回自1970年1月1日以来由此Date对象表示的00:00:00GMT的毫秒数.与System.currentTimeMillis();作用相同.

以下是过期方法,仍然可以用,但不建议.

public int getYear();//返回年份

public void setMonth(int month);//设置月份

public int getDate();//这个月的第几天

public int getDay();//这个星期的第几天

11.Calendar类

11.1概念

关于时间建议使用这个类;这也是一个抽象类.

Calender类是一个抽象类,在实际使用时实现特定的子类的对象,创建对象的过程对程序员来说是透明的,只需要使用getInstance方法创建即可.

11.2创建对象

Calendar c = new GregorianCalendar(1);//创建子类对象

Calendar c = Calendar.getInstance();//GregorianCalendar返回子类对象

11.3成员方法

public static void main(String[] args) {        //Calendar c = new GregorianCalendar();//直接new 子类对象GregorianCalendar        
    Calendar c = Calendar.getInstance();//GregorianCalendar返回子类对象        
    System.out.println(c.get(Calendar.YEAR));  //2020      
    System.out.println(c.get(Calendar.MONTH)+1);  // 11     
    System.out.println(c.get(Calendar.DATE)); //  10    
    System.out.println(c.get(Calendar.DAY_OF_YEAR)); //315       
    System.out.println(c.get(Calendar.DAY_OF_WEEK));//一周中的第几天  老外认为星期天是一周的第一天    3    
    System.out.println(c.get(Calendar.SECOND));//45
}

12.SimpleDateFormat类

SimpleDateFormat 是一个以国别敏感的方式格式化和分析数据的具体类。它允许格式化 (date -> text)、语法分析 (text -> date)和标准化。

SimpleDateFormat 允许以为日期-时间格式化选择任何用户指定的方式启动。但是，希望用 DateFormat 中的 getTimeInstance、 getDateInstance 或 getDateTimeInstance 创建一个日期-时间格式化程序。每个类方法返回一个以缺省格式化方式初始化的日期／时间格式化程序。可以根据需要用 applyPattern 方法修改格式化方式。

SimpleDateFormat函数的继承关系：
java.lang.Object
|
±—java.text.Format
|
±—java.text.DateFormat
|
±—java.text.SimpleDateFormat
下面是个小例子：
import java.text.*;
import java.util.Date;

/**
SimpleDateFormat函数语法：

G 年代标志符
y 年
M 月
d 日
h 时在上午或下午 (1~12)
H 时在一天中 (0~23)
m 分
s 秒
S 毫秒
E 星期
D 一年中的第几天
F 一月中第几个星期几
w 一年中第几个星期
W 一月中第几个星期
a 上午 / 下午标记符
k 时在一天中 (1~24)
K 时在上午或下午 (0~11)
z 时区
*/
public class FormatDateTime {

public static void main(String[] args) {
SimpleDateFormat myFmt=new SimpleDateFormat(“yyyy年MM月dd日 HH时mm分ss秒”);
SimpleDateFormat myFmt1=new SimpleDateFormat(“yy/MM/dd HH:mm”);
SimpleDateFormat myFmt2=new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);//等价于now.toLocaleString()
SimpleDateFormat myFmt3=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E ");
SimpleDateFormat myFmt4=new SimpleDateFormat(
“一年中的第 D 天一年中第w个星期一月中第W个星期在一天中k时 z时区”);
Date now=new Date();
System.out.println(myFmt.format(now));
System.out.println(myFmt1.format(now));
System.out.println(myFmt2.format(now));
System.out.println(myFmt3.format(now));
System.out.println(myFmt4.format(now));
System.out.println(now.toGMTString());
System.out.println(now.toLocaleString());
System.out.println(now.toString());
}

}

效果：
2020年12月16日 17时24分27秒
20/12/16 17:24
2020-12-16 17:24:27
2020年12月16日 17时24分27秒星期四
一年中的第 351 天一年中第51个星期一月中第3个星期在一天中17时 CST时区
16 Dec 2020 09:24:27 GMT
2020-12-16 17:24:27
Thu Dec 16 17:24:27 CST 2020

下面是个JavaBean:
public class FormatDateTime {

public static String toLongDateString(Date dt){
SimpleDateFormat myFmt=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E ");
return myFmt.format(dt);
}

public static String toShortDateString(Date dt){
SimpleDateFormat myFmt=new SimpleDateFormat(“yy年MM月dd日 HH时mm分”);
return myFmt.format(dt);
}

public static String toLongTimeString(Date dt){
SimpleDateFormat myFmt=new SimpleDateFormat(“HH mm ss SSSS”);
return myFmt.format(dt);
}
public static String toShortTimeString(Date dt){
SimpleDateFormat myFmt=new SimpleDateFormat(“yy/MM/dd HH:mm”);
return myFmt.format(dt);
}

public static void main(String[] args) {

Date now=new Date();

System.out.println(FormatDateTime.toLongDateString(now));
System.out.println(FormatDateTime.toShortDateString(now));
System.out.println(FormatDateTime.toLongTimeString(now));
System.out.println(FormatDateTime.toShortTimeString(now));
}

}
调用的main 测试结果：
2004年12月16日 17时38分26秒星期四
04年12月16日 17时38分
17 38 26 0965
04/12/16 17:38

13.BigInterger类

13.1概念

在 Java 中，有许多数字处理的类，比如 Integer类，但是Integer类有一定的局限性。
我们都知道 Integer 是 Int 的包装类，int 的最大值为 2^31-1。若希望描述更大的整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类。
BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息。

这些大数都会以字符串的形式传入。

BigInteger类位于java.math包中

13.2构造方法

BigInteger(String val) /BigInteger(byte[] val) …

13.3BigInteger类常用方法

BigInteger abs() 返回大整数的绝对值

BigInteger add(BigInteger val) 返回两个大整数的和

BigInteger and(BigInteger val) 返回两个大整数的按位与的结果

BigInteger andNot(BigInteger val) 返回两个大整数与非的结果

BigInteger divide(BigInteger val) 返回两个大整数的商

double doubleValue() 返回大整数的double类型的值

float floatValue() 返回大整数的float类型的值

BigInteger gcd(BigInteger val) 返回大整数的最大公约数

int intValue() 返回大整数的整型值

long longValue() 返回大整数的long型值

BigInteger max(BigInteger val) 返回两个大整数的最大者

BigInteger min(BigInteger val) 返回两个大整数的最小者

BigInteger mod(BigInteger val) 用当前大整数对val求模

BigInteger multiply(BigInteger val) 返回两个大整数的积

BigInteger negate() 返回当前大整数的相反数

BigInteger not() 返回当前大整数的非

BigInteger or(BigInteger val) 返回两个大整数的按位或

BigInteger pow(int exponent) 返回当前大整数的exponent次方

BigInteger remainder(BigInteger val) 返回当前大整数除以val的余数

BigInteger leftShift(int n) 将当前大整数左移n位后返回

BigInteger rightShift(int n) 将当前大整数右移n位后返回

BigInteger subtract(BigInteger val)返回两个大整数相减的结果

byte[] toByteArray(BigInteger val)将大整数转换成二进制反码保存在byte数组中

String toString() 将当前大整数转换成十进制的字符串形式

BigInteger xor(BigInteger val) 返回两个大整数的异或

13.4利用BigInteger构造方法转换进制

String string1 = new BigInteger("20", 10).toString(2);
        Log.d("TAG","十进制的20转换成二进制是："+string1);
 
        String string2 = new BigInteger("20", 10).toString(8);
        Log.d("TAG","十进制的20转换成八进制是："+string2);
 
        String string3 = new BigInteger("20",10).toString(16);
       Log.d("TAG","十进制的20转换成十六进制是："+string3);
 
        String string4 = new BigInteger("110", 2).toString(10);
        Log.d("TAG","二进制的110转换成十进制是："+string4);
 
        String string5 = new BigInteger("110", 8).toString(10);
        Log.d("TAG","八进制的110转换成十进制是："+string5);
 
        String string6 = new BigInteger("110", 16).toString(10);
        Log.d("TAG","十六进制的110转换成十进制是："+string6);

十进制的20转换成二进制是：10100
十进制的20转换成八进制是：24
十进制的20转换成十六进制是：14
二进制的110转换成十进制是：6
八进制的110转换成十进制是：72
十六进制的110转换成十进制是：272

14.BigDecimal类

14.1概念

Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。
根本原因是:十进制值通常没有完全相同的二进制表示形式;十进制数的二进制表示形式可能不精确。只能无限接近于那个值.
BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。
Java在java.math包中提供的API类BigDecimal

14.2常用的构造方法

BigDecimal(int)

创建一个具有参数所指定整数值的对象
BigDecimal(double)

创建一个具有参数所指定双精度值的对象
BigDecimal(long)

创建一个具有参数所指定长整数值的对象
BigDecimal(String)

创建一个具有参数所指定以字符串表示的数值的对象

使用示例：

        BigDecimal a =new BigDecimal(0.1);
        System.out.println("a values is:"+a);
        BigDecimal b =new BigDecimal("0.1");
        System.out.println("b values is:"+b);

结果示例：

a values is:0.1000000000000000055511151231257827021181583404541015625
b values is:0.1

原因分析：

1）参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在Java中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。

2）String 构造方法是完全可预知的：写入 newBigDecimal(“0.1”) 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言，通常建议优先使用String构造方法。

3）当double必须用作BigDecimal的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用Double.toString(double)方法，然后使用BigDecimal(String)构造方法，将double转换为String。要获取该结果，请使用static valueOf(double)方法。

14.3常用方法

add(BigDecimal)

BigDecimal对象中的值相加，返回BigDecimal对象
subtract(BigDecimal)

BigDecimal对象中的值相减，返回BigDecimal对象
multiply(BigDecimal)

BigDecimal对象中的值相乘，返回BigDecimal对象
divide(BigDecimal)

BigDecimal对象中的值相除，返回BigDecimal对象
toString()

将BigDecimal对象中的值转换成字符串
doubleValue()

将BigDecimal对象中的值转换成双精度数
floatValue()

将BigDecimal对象中的值转换成单精度数
longValue()

将BigDecimal对象中的值转换成长整数
intValue()

将BigDecimal对象中的值转换成整数

14.4大小比较

java中对BigDecimal比较大小一般用的是bigdemical的compareTo方法

int a = bigdemical.compareTo(bigdemical2)

返回结果分析：

a = -1,表示bigdemical小于bigdemical2；
a = 0,表示bigdemical等于bigdemical2；
a = 1,表示bigdemical大于bigdemical2；

举例：a大于等于b

new bigdemica(a).compareTo(new bigdemical(b)) >= 0

最后

以上就是寂寞战斗机为你收集整理的java-API_常用类介绍及运用的全部内容，希望文章能够帮你解决java-API_常用类介绍及运用所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：笔记
浏览次数：130 次浏览
发布日期：2023-06-16 18:23:05
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_26_fy_12__23__10_2.html