JavaAPI-工具类

8 篇文章 0 订阅

java提供了一系列的工具类,我们应用的时候可以访问它们的属性和方法,但是工具类很多,记住常用的即可!使用的时候就去API帮助文档手册查找,有离线的和在线版本的,离线的百度搜索一下都能找到

在线官网:https://docs.oracle.com/javase/8/docs/api/

中文参考官网:https://www.matools.com/api/java8

Object

之前我们说过Object是所有类的根类,那么说具体的工具类之前,我们先说一下Object

说白了Object也是一个类,那么肯定也有对应的方法

Object所有方法的作用在API帮助文档手册都能找到,这里就介绍几个方法,测试之前先写一段代码

public class MobilePhone {
    private String brand;
    private int price;

    public MobilePhone() {
    }

    public MobilePhone(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}
public class TestMobilePhone {
    public static void main(String[] args) {
        MobilePhone phone=new MobilePhone();
        //子类没对Object重写,都调用的是Object类的方法
        
        //getClass():获取类的全限定名(包名+类名),执行结果:class com.ty.Packaging.MobilePhone
        System.out.println(phone.getClass());
        
        //hashCode():获取哈希码,执行结果:703360008,注意:每次执行hashCode都可能不同
        //哈希码:将对象在堆中的地址,进行哈希算法,会返回一个码称为哈希码
        System.out.println(phone.hashCode());
        
        //获取该对象字符串的表示信息:执行结果:com.ty.Packaging.MobilePhone@519dcf69
        //默认此字符串的含义:getClass().getName() + "@" + Integer.toHexString(hashCode());
        // Integer.toHexString()的意思是将一个数用十六进制展示
        System.out.println(phone.toString());
        
        MobilePhone phone1=new MobilePhone("P40",4488);
        MobilePhone phone2=new MobilePhone("P40",4488);
        //比较phone1对象和phone2对象内容是否相等,此处现在执行结果是false,因为默认调用的Object里的equals方法还是用==判断,比较的是两个对象的地址是否相等,return (this == obj);
        System.out.println(phone1.equals(phone2));
    }
}
//要想显示对象信息的时候好看一些,判断2个对象内容是否相等而不是比较地址的话,MobilePhone就可以重写toString和equals方法
//自己进行重写equals 
@Override
    public boolean equals(Object obj) {
        MobilePhone phone = (MobilePhone) obj;
        if (this.getBrand() == phone.getBrand() && this.getPrice() == phone.getPrice()) {
            return true;
        }
        return false;
    }
//IDE帮助我们重写equals
 @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MobilePhone phone = (MobilePhone) o;
        return price == phone.price &&
                Objects.equals(brand, phone.brand);
    }

//自己进行重写toString
 @Override
    public String toString() {
        return "手机品牌是:"+this.getBrand()+"手机价格是:"+this.getPrice();
    }
//IDE帮助我们重写toString
 @Override
    public String toString() {
        return "MobilePhone{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }

//这样 System.out.println(phone1.equals(phone2));输出的就是:true
//System.out.println(phone1.toString());输出的就是:MobilePhone{brand='P40', price=4488}

包装类

之前我们都是用基本都是基本类型存储数据的,基本类型的好处就是不需要new创建,也就不会在堆中开辟空间,直接在栈中存储会更加高效。但是我们了解java最主要的就是面向对象的特性,即能操作对象的属性和方法,基本类型就不能满足要求了,然后java就引进了包装类

基本数据类型包装类父类
byteByteNumber------->Object
booleanBooleanObject
shortShortNumber------->Object
charCharacterObject
intIntegerNumber------->Object
longLongNumber------->Object
floatFloatNumber------->Object
doubleDoubleNumber------->Object

Integer

拿Integer做案例来进行讲解,此类掌握了之后其它的包装类大同小异

从上面API帮助文档手册可以看出几个信息,所有的类都可以从 API帮助文档手册上查看!

  1. 所属包:Integer类所属java.lang下,使用的时候无需导包

  2. 继承信息:Integer类继承自Number类,再往上继承自Object类

  3. 实现信息:Integer类实现Serializable和Comparable<Integer>接口

  4. 类的附加信息:Integer类被final关键字修饰,不能有子类继承

  5. 类的描述信息:是对基本数据类型的封装,Integer是对int的封装。而且此类提供了处理int的时候的属性和方法

  6. 类的开始生效版本:JDK1.0

  7. 再接着往下看API你能看到具体的操作方法,也能看到具体操作的描述信息,这里就不截出来了

演示一下操作方法,详细的还是看API比较好

//操作属性
System.out.println(Integer.MAX_VALUE); //返回最大值
System.out.println(Integer.MIN_VALUE); //返回最小值
//构造方法
Integer integer1 = new Integer(10);
Integer integer2 = new Integer("123");
System.out.printf("integer1:%d , integer2:%d", integer1, integer2);

简单看一下源码的处理流程:

//传进的int数据传进底层要封装进的value里
private final int value;
public Integer(int value) {
        this.value = value;
}

//传进的String数据调用parseInt,将String转换成int类型数据,然后传进底层要封装进的value里,如果转换不成功就报NumberFormatException异常
public Integer(String s) throws NumberFormatException {
        this.value = parseInt(s, 10);
}

另外包装类型和基本数据类型是互相能进行转换的,基本数据类型转换为包装类型称为装箱,反之成为拆箱

在jdk5之后增加了一种机制,提供了自动装箱和自动拆箱这种特性,能很好更好的完成转换功能

Integer integer = 18; //自动装箱,基本类型-》包装类型
System.out.println(integer);
int num = integer1;
System.out.println(num); //自动拆箱,包装类型-》基本类型

看一下反编译之后的代码

可见底层实现自动装箱就是调用了valueOf()方法,自动拆箱就是调用了intValue()方法

看一下ValueOf()方法的实现

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            int h = 127;        
            high = h; //high = 127

            cache = new Integer[(high - low) + 1]; //cache = new Integer[(127 - (-128)) + 1]
            								 	  // 也就是cache[] = new Integer[256]
            int j = low; 					      // int j = -128
            for(int k = 0; k < cache.length; k++) 
                cache[k] = new Integer(j++); //cache[256]={-128,-127,-126,......,126,127}

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high) //if(i >= -128 && i <= 127)
            return IntegerCache.cache[i + (-IntegerCache.low)]; //return IntegerCache.cache[i + (-128)]
        return new Integer(i); //不符合范围就new一个
    }
            
 //总结:如果值是-128到127之间就从IntegerCache.cache数组中获取,如果不在这个范围,就new
//这段代码就是调用了上面那段valueOf的代码,判断实现
Integer integer3 = 12;
Integer integer4 = 12;
Integer integer5 = 128;
Integer integer6 = 128;
System.out.println(integer3 == integer4); // true,比较的是数值
System.out.println(integer5 == integer6); // false,比较的是地址

再演示一个方法:

Integer integer7=10;
Integer integer8=12;
System.out.println(integer.compareTo(integer8));// 执行结果:-1

/*
源码:
public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
}
public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }
*/

Character

可以从API帮助文档手册查看具体信息,查看方法参考上面的Integer,这里演示几个常用的方法!

public class TestCharacter {
    public static void main(String[] args) {
        Character ch=new Character('a');
        System.out.println(Character.isDigit(ch)); //判断是否为数字
        System.out.println(Character.isLetter(ch)); //判断是否为字母
        System.out.println(Character.isUpperCase(ch)); //判断是否为大写
        System.out.println(Character.isLetter(ch)); //判断是否为小写
        System.out.println(Character.isWhitespace(ch)); //判断是否为空格

        System.out.println(Character.toUpperCase(ch)); //转换为大写
        System.out.println(Character.toLowerCase('A')); //转换为小写
    }
}

字符串类

String

除了从API手册上查看此类的信息,还可以从源码上查看

package java.lang;

/**
 * The <code>String</code> class represents character strings. All
 * string literals in Java programs, such as <code>"abc"</code>, are
 * implemented as instances of this class.
 * 类的上面有许多注释,这些注释都不是白来的,API的描述信息也是从这些注释得来的
 * @since   JDK1.0
 */
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

通过看源码,可得以下基本信息:

  1. 所属包:String类所属java.lang下,使用的时候无需导包

  2. 继承信息:String类继承自Object类

  3. 实现信息:String类实现Serializable,Comparable<Integer>和CharSequence接口

  4. 类的附加信息:String类被final关键字修饰,不能有子类继承;"abc"是String类下的一个具体的对象

  5. 类的描述信息:String是对字符数组封装,String的内容存放在char value[]中,而且此数组被final修饰,即字符串不可被修改

  6. 类的开始生效版本:JDK1.0

  7. 再接着往下看源码你能看到具体的操作方法,而且也能看见对应操作的描述信息

下面演示一下具体操作,详细的你最好还是看API或者源码

//创建字符串
public class TestString {
    public static void main(String[] args) {
        /**这种方式先在常量池中查看是否具有"abc"的存储空间
         * 如果有的话直接指向,如果没有就先创建再指向
         * str1指向的是常量池的空间地址
         */
        String str1 = "abc";

        /**new这种方式,会先在堆中开辟一个空间,里面有个value属性,指向常量池的空间
         * 如果常量池中有"abc"的话 value直接指向,如果没有就先创建然后 value再指向
         * new指向的是堆中的空间地址
         */
        String str2 = new String("abc");
        String str3 = new String(new char[]{'a', 'b', 'c'});
        String str4 = "hello";
        String str5 = str4 + "java";
    }
}

此外还有一种方式

String str4 = "hello";
String str5 = str4 + "java";

/*这种方式其实是创建了StringBuilder字符串类,通过反汇编的方式,可能有利于理解,反汇编的命令:javap -c class文件
  	  39: ldc           #6              // String hello	
  	  				      String str4 = "hello";
      41: astore        4
      43: new           #7                  // class java/lang/StringBuilder
      					      new StringBuilder
      46: dup
      47: invokespecial #8                  // Method java/lang/StringBuilder."<init>":()V
      					      StringBuilder sb=new StringBuilder();
      50: aload         4
      52: invokevirtual #9                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;   
                                               sb.append(str4);
      55: ldc           #10                 // String java
      					       String str = "java";
      57: invokevirtual #9                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;   
                                               sb.append(str);
      60: invokevirtual #11                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
						将StringBuilder类型转换成String类型
//常用方法
System.out.println(str1.length()); //获取字符串的长度

System.out.println(str1.isEmpty()); //判断字符串是否为空

System.out.println(str1.charAt(1)); //获取字符串指定索引的单个字符,索引从0开始

System.out.println(str1.indexOf("b")); //获取字符在字符串中第一次出现的索引,如果找不到,返回-1

System.out.println(str1.lastIndexOf("b")); //获取字符在字符串中最后一次出现的索引,如果找不到,返回-1

System.out.println(str1.substring(1)); //截取指定范围的子串

System.out.println(str1.equals("abcd")); //判断两个字符串内容是否相等,Object类之下的系统子类基本都重写了equals方法

System.out.println(str1.equalsIgnoreCase("ABCD")); //忽略大小写,判断内容是否相等

System.out.println(str1.compareTo("abcd")); //按照Unicode的顺序比较两个字符串,如果前者大,则返回正数,后者大,则返回负数,如果相等,返回0

System.out.println(str1.toUpperCase()); //转换成大写

System.out.println("ABCD".toLowerCase()); //转换成小写

System.out.println(str1.concat("def")); //拼接字符串

System.out.println("智障,CNM".replace("CNM", "xxx")); //替换字符串中的字符

String poem = "E:\\附加项目\\附加-project";
String[] split = poem.split("\\\\"); //以指定字符分割字符串

for (int i = 0; i < split.length; i++) {
    System.out.println(split[i]);
}

str="              abc          ";
System.out.println(str);
System.out.println(str.trim()); //去除前后空格

String str = "hello";
char[] array = str.toCharArray(); //转换成字符数组
for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}

String name = "john";
int age = 10;
double score = 98.3 / 3;
char gender = '男';
//format():格式字符串,占位符:%s 字符串 %c 字符 %d 整型 %.f 浮点型,.f之前可以加数字表示保留几位小数
String info = String.format("我的名字%s,年龄:%d,考试成绩:%f,性别:%c", name, age, score, gender);
System.out.println(info);

了解一下equals和compareTo的源码

/*	String str1 = "abcd";
	String str2 = "abcd"
	System.out.println(str1.equals(str2)); 
*/
private final char value[];

public boolean equals(Object anObject) {
        if (this == anObject) {		//if (str1 == str2),比较两个对象的地址,相同就直接返回true
            return true;
        }
        if (anObject instanceof String) {	//判断传入的str2是不是String的实例,不是的话直接返回false
            String anotherString = (String)anObject;  // Object类型的str2向下转型为String类型
            int n = value.length;					  // n = str1.length
            if (n == anotherString.value.length) {	  // if (n == str.length),判断长度不等的话就返回false
                char v1[] = value;					  // v1[] = str1{'a','b','c','d'}
                char v2[] = anotherString.value;   	  // v2[] = str2{'a','b','c','d'}
                int i = 0;
                while (n-- != 0) {					//对数组进行遍历
                    if (v1[i] != v2[i])				//一位一位取出来进行遍历,对应位不等的话的话就返回false
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
/*	String str1 = "abcd";
	String str2 = "abcd"
	System.out.println(str1.equals(str2)); 
*/
private final char value[];

public int compareTo(String anotherString) {
        int len1 = value.length;			 // len1 = str1的长度:4
        int len2 = anotherString.value.length; // len2 = str2的长度:4
        int lim = Math.min(len1, len2);		   // 取小的那个值,即:lim = 4
        char v1[] = value;					   // v1[] = str1{'a','b','c','d'}
        char v2[] = anotherString.value;	   // v2[] = str2{'a','b','c','d'}

        int k = 0;  
        while (k < lim) {
            char c1 = v1[k]; //c1 = v1[0],c1 = v1[1],c1 = v1[2],c1 = v1[3]
            char c2 = v2[k];// c2 = v2[0],c2 = v2[1],c2 = v2[2],c2 = v2[3]
            if (c1 != c2) { // 分别对应判断是否相等,如果相等直接k++,如果不等先返回两个数的差值,然后进行k++
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2; //如果经过上面那个步骤判断每位数都相同,两个数长度不同的话就返回它俩的长度差
    }

String这种方式创建字符串,因为它是不可变的每次增加的时候实际上是重新开辟空间存储

//衡量一些代码走完所需的时间
long start = System.currentTimeMillis();

for (int i = 0; i < 10000; i++) {
    str += "hello";
}
long end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start));

针对这种效率问题,java提供了另外一种表示字符串的类StringBuilder 和 StringBuffer

StringBuffer

还是简单看一下源码

/**
 * A thread-safe, mutable sequence of characters.
 * A string buffer is like a {@link String}, but can be modified. At any
 * point in time it contains some particular sequence of characters, but
 * the length and content of the sequence can be changed through certain
 * method calls.
 * @since   JDK1.0
 *
 * 线程安全[多线程]的可变字符序列,字符串缓冲区类似于String,可以被修改,可以通过某些方法调用来更改序列的长度和内容。JDK1.0就有
 */
public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
//继承自AbstractStringBuilder类

/**
 * A mutable sequence of characters.
 * <p>
 * Implements a modifiable string. At any point in time it contains some
 * particular sequence of characters, but the length and content of the
 * sequence can be changed through certain method calls.
 *
 * 可变的字符序列,实现可修改的字符串。它在任何时间点都包含某些特殊的字符序列,但是可以通过某些方法调用来更改序列的长度和内容。
 * @author      Michael McCloskey
 * @author      Martin Buchholz
 * @author      Ulf Zibis
 * @since       1.5
 */
abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value; //存放的是可变的字符数组

    /**
     * The count is the number of characters used.
     */
    int count; //value数组中被使用的长度

//测试效率
public class TestStringBuffer {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        long start = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {
            sb.append("hello"); //表示追加内容
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:" + (end - start));
    }
}

//同样一段代码StringBuffer比String的效率高
//常用方法
StringBuffer sb = new StringBuffer("好好学习");
System.out.println(sb); //执行结果:好好学习;调用的是toString()方法,return new String(value, 0, count)

//增加
sb.append(",");
sb.append("天天向上");
System.out.println(sb); //执行结果:好好学习,天天向上

//删除
sb.delete(4,sb.length());
System.out.println(sb); //执行结果:好好学习

//修改
sb.replace(2,sb.length(),"工作"); //替换
System.out.println(sb); //执行结果:好好工作

sb.insert(0,"dream!"); //插入
System.out.println(sb); //执行结果:dream!好好工作

//查找
sb=new StringBuffer("abcdef");
System.out.println(sb.charAt(3));

StringBuilder

/**
 * A mutable sequence of characters.  This class provides an API compatible
 * with <code>StringBuffer</code>, but with no guarantee of synchronization.
 * This class is designed for use as a drop-in replacement for
 * <code>StringBuffer</code> in places where the string buffer was being
 * used by a single thread (as is generally the case).   Where possible,
 * it is recommended that this class be used in preference to
 * <code>StringBuffer</code> as it will be faster under most implementations.
 * @since       1.5
 *
 * 可变的字符序列,此类提供一个与 StringBuffer 兼容的 API,但不保证同步(多线程问题)。该类被设计用作 StringBuffer 的一个简易
 * 替换,用在字符串缓冲区被单个线程使用的时候。如果可能,建议优先采用该类,因为在大多数实现中,它比StringBuffer要快,JDK1.5有
 */
public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{

StringBuilder 和 StringBuffer方法是一样的,所以使用和StringBuffer一样,这里就不演示了

总结:String、StringBuffer 和StringBuilder的比较

  • String:不可变字符序列

  • StringBuilder 和 StringBuffer 非常类似,均代表可变的字符序列,而且方法也一样

    • StringBuffer:可变字符序列、效率较高(增删)、线程安全

    • StringBuilder(JDK1.5):可变字符序列、效率最高、线程不安全

应用场景:

  • 字符串很少修改,被多个对象引用,使用String, 比如配置信息等

  • 字符串存在大量的修改操作,一般使用 StringBuffer 或 StringBuilder

    • 单线程:使用 StringBuilder

    • 多线程:使用StringBuffer

数学类

Math

/**
 * The class {@code Math} contains methods for performing basic
 * numeric operations such as the elementary exponential, logarithm,
 * square root, and trigonometric functions.
 *
 * Math类包含用于执行基本数值运算的方法,例如基本指数,对数,*平方根和三角函数。
 */
public final class Math {
    /**
     * Don't let anyone instantiate this class.
     */
    private Math() {} //构造器私有化代表不能创建Math对象
    
    //往下看属性和方法能看出来都是被static关键字修饰,所以使用Math.来调用
//静态导包
import static java.lang.Math.*;

public class TestMath {
    public static void main(String[] args) { //常用属性:
        System.out.println(PI);
        //常用方法:
        System.out.println("随机数:" + random());//[0.0 ~ 1.0)
        System.out.println("绝对值:" + abs(-80));
        System.out.println("向上取值:" + ceil(9.1));
        System.out.println("向下取值:" + floor(9.9));
        System.out.println("四舍五入:" + round(3.5));
        System.out.println("取大的那个值:" + max(3, 6));
        System.out.println("取小的那个值:" + min(3, 6));
        System.out.println("求幂:" + pow(2, 3));
        System.out.println("求开方:" + sqrt(9));
    }
}

Arrays类

/**
 * This class contains various methods for manipulating arrays (such as
 * sorting and searching). This class also contains a static factory
 * that allows arrays to be viewed as lists.
 *
 *此类包含各种用于处理数组的方法(例如排序和搜索)。此类还包含一个静态工厂,该工厂可以将数组视为列表。
 */
public class Arrays {
    // Suppresses default constructor, ensuring non-instantiability.
    private Arrays() {}
//常用方法
Integer[] arr = {10, 25, 32, 65, 47, 125, 845, 52};
System.out.println(Arrays.toString(arr)); //对数组进行遍历

Arrays.sort(arr);//排序,默认升序
System.out.println(Arrays.toString(arr));

Arrays.sort(arr, new Comparator() { //自定义排序
    @Override
    public int compare(Object o1, Object o2) {
        Integer n1 = (Integer) o1;
        Integer n2 = (Integer) o2;
        if (n1 > n2) {
            return -1;
        } else if (n1 < n2) {
            return 1;
        }
        return 0;
    }
});
System.out.println(Arrays.toString(arr));

Integer[] array = {85, 45, 25, 36, 521, 100};
Arrays.sort(array);
System.out.println(Arrays.toString(array));
// 二分法查找:找出指定数组中的指定元素对应的索引,必须是一个有序数组
// 如果找到,就是对应的下标
// 如果没有,就返回 -(low+1) low:应该存在的下标
System.out.println(Arrays.binarySearch(array, 455));

String[] strArr = new String[]{"a", "bc", "de", "fgh", "h", "e", "llo"};
//如果拷贝的长度在有效范围1 ~ arr.length , 就拷贝指定的个数
//拷贝的长度 >  arr.length , 多余用null占位, 小于0就会报错
String[] newArr = Arrays.copyOf(strArr, 2); //复制数组
System.out.println(Arrays.toString(newArr));

String[] newArr2 = Arrays.copyOfRange(strArr, 2, 4); //区间复制,左开右闭
System.out.println(Arrays.toString(newArr2));

System.out.println(strArr.equals(newArr)); //判断数组的值是否相等

int[] arr2 = {10, 20, 30};
Arrays.fill(arr2, 40); // 数组的填充
System.out.println(Arrays.toString(arr2));

List<int[]> list = Arrays.asList(arr2); //将数组转换成list
System.out.println(list.size());

System类

/**
 * The <code>System</code> class contains several useful class fields
 * and methods. It cannot be instantiated.
 *
 * <p>Among the facilities provided by the <code>System</code> class
 * are standard input, standard output, and error output streams;
 * access to externally defined properties and environment
 * variables; a means of loading files and libraries; and a utility
 * method for quickly copying a portion of an array.
 *
 * System类包含几个有用的类字段和方法。无法实例化。
 * System类提供的功能包括标准输入,标准输出和错误输出流。 访问外部定义的属性和环境变量;一种加载文件和库的方法; 以及用于快速
 * 制阵列的一部分的实用方法。
 * @author  unascribed
 * @since   JDK1.0
 */
public final class System {
 public static void main(String[] args) {
        // arraycopy :复制数组元素,比较适合底层调用,一般使用Arrays.copyOf完成复制数组.
        int[] src = {1, 2, 3}; //源数组
        int[] dest = new int[3];//目标数组
        /**解读
         * @param      src      源数组
         * @param      srcPos   源数组中的起始位置
         * @param      dest     目标数组
         * @param      destPos  目标数据中的起始位置
         * @param      length   要复制的数组元素的数量
         */
        System.arraycopy(src, 1, dest, 1, 2);
        System.out.print(Arrays.toString(dest));
        System.out.println();

        for (int i = 0; i < 10; i++) {
            if (i == 6) {
                System.exit(0); //退出程序
            }
            System.out.println(i);
        }

BigInteger/BigDecimal类

/**
 * Immutable arbitrary-precision integers.  All operations behave as if
 * BigIntegers were represented in two's-complement notation (like Java's
 * primitive integer types).  BigInteger provides analogues to all of Java's
 * primitive integer operators, and all relevant methods from java.lang.Math.
 * Additionally, BigInteger provides operations for modular arithmetic, GCD
 * calculation, primality testing, prime generation, bit manipulation,
 * and a few other miscellaneous operations.
 *
 * 不可变的任意精度整数,适合保存比较大的整型
 */
public class BigInteger extends Number implements Comparable<BigInteger> {}

/**
 * Immutable, arbitrary-precision signed decimal numbers.  A
 * {@code BigDecimal} consists of an arbitrary precision integer
 * <i>unscaled value</i> and a 32-bit integer <i>scale</i>.  If zero
 * or positive, the scale is the number of digits to the right of the
 * decimal point.  If negative, the unscaled value of the number is
 * multiplied by ten to the power of the negation of the scale.  The
 * value of the number represented by the {@code BigDecimal} is
 * therefore <tt>(unscaledValue &times; 10<sup>-scale</sup>)</tt>.
 *
 * 不可变,任意精度的带符号十进制数字,适合保存精度更高的浮点型(小数)
 */
public class BigDecimal extends Number implements Comparable<BigDecimal> {}
public class TestBig {
    public static void main(String[] args) {
        System.out.println("整数-------------------------------------------------------------------");
        //long num=855451236958545452125L;存储不了
        BigInteger num1 = new BigInteger("855451236958545452125");
        System.out.println(num1);

        //运算方法
        BigInteger num2 = new BigInteger("41455288452565565656336655454588545");
        System.out.println(num1.add(num2)); //加
        System.out.println(num2.subtract(num1)); //减
        System.out.println(num1.multiply(num2)); //乘
        System.out.println(num2.divide(num1)); //除

        System.out.println("浮点数-------------------------------------------------------------------");
        //精度损失了
        double d1 = 4567888888888888888888888888888888888888222222222222222222222222222222222222228888888.23;
        System.out.println(d1);
        BigDecimal d = new BigDecimal("45678888888888888888888888888888888888882222222222222222222222222222222222222222222222222222222222222222222222222222288888888888888888888888888.23");
        BigDecimal d2 = new BigDecimal(33);
        System.out.println(d);
        System.out.println(d.add(d2)); //加
        System.out.println(d.subtract(d2)); //减
        System.out.println(d.multiply(d2)); //乘
        //没有后面没有参数,则会提示:ArithmeticException:Non-terminating decimal expansion; no exact representable decimal result.
        System.out.println(d.divide(d2, BigDecimal.ROUND_CEILING)); //除
    }
}

日期类

使用的时候去查API手册即可!

第一代日期类

public class TestDate {
    public static void main(String[] args) throws ParseException {
        Date date= new Date();
        System.out.println(date);
        System.out.println(date.getTime()); //获取某个时间对应的毫秒数

        //使用SimpleDateFormat进行格式化输出, "yyyy-MM-dd HH:mm:ss E" 各个字母是格式化符合,是规定好的
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
        System.out.println(dateFormat.format(date));

        //通过一个毫秒,得到对应的日期
        Date d2 = new Date(1606924829078L);
        System.out.println(dateFormat.format(d2));

        //将一个String 格式化转成Date对象,s格式需要和dateFormat格式匹配,否则ParseException
        String s="2020-02-03 00:01:40 星期四";
        Date format = dateFormat.parse(s);
        System.out.println(format.getTime());
    }
}

格式化日期要求的字母格式

格式化日期的字母格式

第二代日期类

第二代日期类,主要就是 Calendar类(日历)

/**
 * The <code>Calendar</code> class is an abstract class that provides methods
 * for converting between a specific instant in time and a set of {@link
 * #fields calendar fields} such as <code>YEAR</code>, <code>MONTH</code>,
 * <code>DAY_OF_MONTH</code>, <code>HOUR</code>, and so on, and for
 * manipulating the calendar fields, such as getting the date of the next
 * week. An instant in time can be represented by a millisecond value that is
 * an offset from the <a name="Epoch"><em>Epoch</em></a>, January 1, 1970
 * 00:00:00.000 GMT (Gregorian).
 *
 *  Calendar类是一个抽象类,提供用于在特定时间点和一组calendar fields例如YEAR ,MONTH ,DAY_OF_MONTH ,HOUR等)之间
 *	进行转换的方法,以及用于处理日历字段(例如获取下一星期日期)的方法。时间的瞬间可以用毫秒值表示
 *	该值是从1970年1月1日格林尼治标准时间(Gregorian)到Epoch的偏移量。
 *
 *	Calendar提供了一个类方法getInstance ,用于获取这种类型的通常有用的对象。 
 *	Calendar的getInstance方法返回一个Calendar对象,该对象的日历字段已使用当前日期和时间初始化:
 *	Calendar rightNow = Calendar.getInstance();
 */
public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar>
public class TestCalendar {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getClass());

        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH);
        int date = calendar.get(Calendar.DATE);
        int hour = calendar.get(Calendar.HOUR);
        int minute = calendar.get(Calendar.MINUTE);
        int second = calendar.get(Calendar.SECOND);
        int week = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        System.out.printf("%d-%d-%d %d:%d:%d 星期%d", year, month, date, hour, minute, second, week);
        
        calendar.set(Calendar.YEAR,2000);
        calendar.set(Calendar.MONTH,2);
        calendar.set(Calendar.DATE,28);
        int year2 = calendar.get(Calendar.YEAR);
        int month2 = calendar.get(Calendar.MONTH);
        int date2 = calendar.get(Calendar.DATE);
        System.out.printf("%d-%d-%d", year2, month2, date2);//原日期会变
    }
}

第三代日期类

前两代日期类都有不足的地方,JDK 1.0中包含了一个java.util.Date类,但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。

  • 可变性 : 像日期和时间这样的类应该是不可变的。

  • 偏移性 : Date中 的年份是从1900开始的,而月份都从0开始。

  • 格式化 : 格式化只对Date有用,Calendar则不行。

第三代日期类常见方法:LocalDate(日期)、LocalTime(时间)、LocalDateTime(日期时间)

public class TestDate03 {
    public static void main(String[] args) {
        //now()-:获取当前的日期,时间,日期+时间
        LocalDate date= LocalDate.now(); //获取当前的日期
        System.out.println(date);
        LocalTime time=LocalTime.now();
        System.out.println(time); //获取当前的时间
        LocalDateTime dateTime=LocalDateTime.now();//,获取当前日期+时间
        System.out.println(dateTime);

        //of():设置指定的日期,时间,日期+时间
        LocalDate date1=LocalDate.of(2010,5,25);
        LocalTime time1=LocalTime.of(10,15,25);
        LocalDateTime dateTime1=LocalDateTime.of(date1,time1);
        System.out.println(dateTime1);

        System.out.println(dateTime.getYear());
        System.out.println(dateTime.getMonth());
        System.out.println(dateTime.getMonthValue());
        System.out.println(dateTime.getDayOfMonth());
        System.out.println(dateTime.getDayOfWeek());
        System.out.println(dateTime.getHour());
        System.out.println(dateTime.getMinute());
        System.out.println(dateTime.getSecond());

        LocalDateTime localDateTime=dateTime.withYear(1998); //with:设置日期
        System.out.println(localDateTime);
        System.out.println(dateTime); //原日期不会跟着新日期改动就变化

        LocalDateTime plusYears = localDateTime.plusYears(10); //plus:加操作
        System.out.println(plusYears);
        LocalDateTime minusMonths = localDateTime.minusMonths(6); //minus:减操作
        System.out.println(minusMonths);
        //API还有很多方法
    }
}

文件类

File

/**
 * An abstract representation of file and directory pathnames.
 *
 * 文件和目录路径名的抽象表示,也就是把文件和文件夹封装成了一个对象,可以用程序操作它
 */
 public class File
    implements Serializable, Comparable<File>
{
public class TestFile {
    public static void main(String[] args) throws IOException {
        /**创建文件对象File
         * new File(String pathname)             根据路径构建一个File对象
         * new File(File parent,String child):  根据父目录文件+子路径构建
         * new File(String parent,String child)  根据父目录+子路径构建
         */
        File file1 = new File("E:\\testA.txt"); //路径分隔符:\\或者/,是Windows系统私有
        File file2 = new File("E:\\", "testB.txt");
        File parent = new File("E:\\");
        File file3 = new File(parent, "testC.txt");
        /**
         * File.separator属性帮我们获取当前操作系统的路径拼接符号
         * windows系统中,默认用"\"作为路径分隔符
         * unix和Linux系统中,默认用"/"作为路径分隔符
         */
        File file = new File("E:" + File.separator + "testD.txt");

        //文件常用方法
        if (file1.exists()) { //exists():判断文件是否存在
            file1.delete(); //delete():删除文件
        } else {
            file1.createNewFile();  //createNewFile():创建文件
        }

        System.out.println(file1.canRead()); //文件是否可读
        System.out.println(file1.canWrite()); //文件是否可写
        System.out.println(file1.getName()); //获取文件名字
        System.out.println(file1.getParent()); //获取上一级目录
        System.out.println(file1.length()); //获取文件的大小
        System.out.println(file1.isDirectory()); //是否目录
        System.out.println(file1.isFile()); //是否文件
        System.out.println(file1.isHidden()); //是否隐藏
        System.out.println(file1.getPath()); //获取相对路径,相对于一个参照物的路径
        System.out.println(file1.getAbsolutePath()); //获取绝对路径,文件的完整路径

        File way = new File("a/b/c/test.txt");
        System.out.println("绝对路径:" + way.getAbsolutePath());
        System.out.println("相对路径:" + way.getPath()); //此参照的是当前工作目录

        
        //目录常用方法
        File path = new File("E:\\a");
        if (path.exists()) {
            path.delete(); //只会删除空的单层目录
        } else {
            path.mkdir(); //只会创建单层目录
        }
        File path2 = new File("E:/a/b/c");
        path2.mkdirs(); //可以创建多层目录

        //获取
        String[] list = path.list();
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("----------------");
        for (File listFile : path.listFiles()) {
            System.out.println(listFile + "," );
        }
		
		//文件具体数据内容的操作是以io流方式操作
    }
}

还是那句话,具体的详细信息还是要通过源码或者API帮助文档查找,经常用的API用着用着就熟练了,不常用的查看手册!

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值