8.常用类

引言

本节讨论java中提供的一些基础类，它们在各个细小的领域有这比较丰富的功能，虽然叫常用类，但是有些类并非经常使用。api在线文档
https://tool.oschina.net/apidocs/apidoc?api=jdk_7u4

一.Object类

java.lang下

1.常用方法

hashCode() : int
这个方法的作用是获得该对象的哈希码，hashcode折射出的是该对象的地址信息（并不是直接地址）
toString() : String
这个方法的作用是获得对象的字符串表达形式。默认实现的方案是 全类名+@+16进制的hashcode.
这个方法通常需要我们自己重写一下。
equals( Object other) : boolean
这个方法用于判断两个对象是否相等，默认比较的方式是 == 比较地址，如果需要比较属性，需要重写。
getClass: class
这个方法的作用是获得 对象类型信息,比如获得类名，属性信息，方法信息等。
finalize() void
这个方法的作用是，当对象被标记为垃圾时，回调的方法，一个对象的这个方法只会调用一次，对象被标记为垃圾后，进入回收队列
wait() notify() notifyAll()
线程等待 线程唤醒 方法
clone( ) : Object
复制一个对象的方法。通常一个对象要支持克隆需要实现一个 Cloneable 接口，否则引发 CloneNotSupportedException 。如果不实现这个接口，需要手动创建对象填充属性值。

二.String 类

String 类是一个常用基础类型，但是被设计为一个不可变字符串（Java.lan下）
属于引用数据类型 用equals 比较

string是不可变的字符串。 string可以使用+号进行拼接 但是StingBuffer 只能用append添加 需要用toString() 方法来转字符串
和 String 类不同的是，StringBuffer（单线程） 和 StringBuilder（多线程） 类的对象能够被多次的修改，并且不产生新的未使用对象

StringBuffer 类（线程安全）：

每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
1 StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2 StringBuffer reverse() 将此字符序列用其反转形式取代。
3 delete(int start, int end)移除此序列的子字符串中的字符。
4 insert(int offset, int i)将 int 参数的字符串表示形式插入此序列中。
5 insert(int offset, String str)将 str 参数的字符串插入此序列中。
deleteAT(); 删除下标位置的指定字符；
replace(起始位置，终止位置，替换字符串)
1 int capacity()返回当前容量。
2 char charAt(int index) 返回此序列中指定索引处的 char 值。
3 void ensureCapacity(int minimumCapacity)
确保容量至少等于指定的最小值。
4 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此序列复制到目标字符数组 dst。
5 int indexOf(String str)
返回第一次出现的指定子字符串在该字符串中的索引。
6 int indexOf(String str, int fromIndex)
从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
7 int lastIndexOf(String str)
返回最右边出现的指定子字符串在此字符串中的索引。
8 int lastIndexOf(String str, int fromIndex)
返回 String 对象中子字符串最后出现的位置。

9 int length()
返回长度（字符数）。
10 void setCharAt(int index, char ch)
将给定索引处的字符设置为 ch。
11 void setLength(int newLength)
设置字符序列的长度。
12 CharSequence subSequence(int start, int end)
返回一个新的字符序列，该字符序列是此序列的子序列。
13 String substring(int start)
返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
14 String substring(int start, int end)
返回一个新的 String，它包含此序列当前所包含的字符子序列。
15 String toString()
返回此序列中数据的字符串表示形式。

StringBuilder 类（快 线程不安全）：

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

三.包装类

包装类(封装类) : 直接把基本数据类型表示成一个类，在执行数据类型转换时就会使用到包装类
基本类型 封装类型
byte Byte
char Character
int Integer
long Long
float Float
double Double
boolean Boolean
short Short
*/

装箱： 把一个基本数类型 变成引用 数据类型
拆箱： 把引用数据类型变成 基本数据类型

public class WarpDemo {
    public static void main(String[] args) {
        // JDK.1.5以前 手动完成 装箱 和 拆箱
        // 装箱： 把一个基本数类型 变成引用 数据类型
        int num = 100;                        // 基本数据类型
        Integer numPlus = new Integer( num ); // 引用数据类型
        // 拆箱： 把引用数据类型变成 基本数据类型
        Integer nPlus = new Integer(100);      //引用类型
        int n = nPlus.intValue();              // 基本数据类型
    }
}

自动装箱与拆箱[jdk5+]

public class WarpDemo {
    public static void main(String[] args) {
       //JDK 1.5+ 自动 装箱拆箱 , 使转换更容易。
       int x = 10;
       Integer xPlus = x; //自动装箱
       Integer yPlus = 100;
       int y = yPlus;     //自动拆箱
    }
}

3.4 包装类提供的方法

使用包装类，提供的静态方法完成一些简单功能。

public class WarpApi {
    public static void main(String[] args) {
        // 1. 查看类型的 取值区间
        System.out.println(  Integer.MIN_VALUE+ "-"+ Integer.MAX_VALUE  );
        // 2. 转进制
        System.out.println(Integer.toBinaryString(10));
        System.out.println(Integer.toHexString(10));
        // 3. 比较大小
        System.out.println(Integer.max(10, 50));
        System.out.println(Integer.min(10, 50));
        System.out.println(Integer.compare(10, 3));
    }
}

3.5 数值类型与字符串转换[掌握]

开发中很多时候，需要把字符串类型 转成 数值类型，比如需要把 String “99.8” 变成 double 99.8 。
字符串转数值类型，需要找到对应的包装类型，比如要转int 找Integer 转double就找Double。 包装类提供 parseByte() parseShort() parseInt() parseLong() parseFloat() parseDouble

public class WarpApi {
    public static void main(String[] args) {
        System.out.println("------------------   String==> 数值  ----------------------");
        Scanner scanner = new Scanner(System.in);
        String price = scanner.next();
        double money =  Double.parseDouble( price );
        double xx  = money * 0.8;
        System.out.println(xx); 
        System.out.println("------------------  数值 ==> String  ----------------------");
        double abc = 120.0;
        String s=  String.valueOf(abc);
        System.out.println(s);
    }
}

3.6 BigDecimal

由于java中浮点数计算不精确，可以使用BigDecimal解决问题，需要注意的是必须以字符串方式构造BigDecimal。
BigDecimal 提供了API来计算：

1. add( BigDecimal other ):BigDecimal
2. subtract( BigDecimal other ):BigDecimal
3. multiply( BigDecimal other ):BigDecimal
4. divide( BigDecimal other ,int scale , int rondModel ):BigDecimal

重点说明：
对于除法，因为存在无限循环小数，所以可能会引发异常，通过 参数 scale 控制小数点位数， rondModel控制取舍策略。
常用取舍策略：
ROUND_UP = 0
ROUND_DOWN =1
ROUND_CEILING =2
ROUND_FLOOR = 3
ROUND_HALF_UP = 4 四舍五入

public class BigDecimalDemo {
    public static void main(String[] args) {
        double a = 1.0;
        double b = 0.9;
        System.out.println(a-b);//0.99999999998 不精确
        //包装
        BigDecimal n1 = new BigDecimal(   String.valueOf(a)  );
        BigDecimal n2 = new BigDecimal(   String.valueOf(b)  );
        System.out.println("-------加法------");
        BigDecimal result1 = n1.add(n2);
        System.out.println(result1.doubleValue());
        System.out.println("-------减法------");
        BigDecimal result2 = n1.subtract(n2);
        System.out.println(result2.doubleValue());
        System.out.println("-------乘法--------");
        BigDecimal result3 = n1.multiply(n2);
        System.out.println(result3.doubleValue());
        System.out.println("-------除法--------");
        BigDecimal result4 = n1.divide(n2,2,BigDecimal.ROUND_HALF_UP);
        System.out.println(result4.doubleValue());
    }
}

3.7 BigInteger

当运算数据非常大的情况下，基本数据类型无法完成运算，比如两个long的最大值相加，没有办法直接运算，这时可以借助 BigInter包装类使用API运算，API与BigDecimal完全一致

// 大数运算
public class BigInteDemo {
    public static void main(String[] args) {
        long x1 = 9223372036854775807L;
        long x2 = 9223372036854775807L;
        BigInteger n1 = new BigInteger( String.valueOf(x1) );
        BigInteger n2 = new BigInteger( String.valueOf(x2) );
        BigInteger result = n1.add(n2);
        System.out.println(ru); //18446744073709551614 
    }
}

四.日期类

4.1 Date类

是用来描述时间的。一个时刻，一个瞬间都是 Date的实例。在java.util包中。
Date的常用方法：

public class TestDateApi {
    public static void main(String[] args) {
        Date date = new Date();
        //1. 获得时间的毫秒数
        long time = date.getTime();
        System.out.println(time);
        //2. 日期比较 after before
        Date date2= new Date(1618191582373L);
        boolean after = date.before(date2);
        System.out.println(after);
        //3. 过期的方法
        System.out.println(date.getYear()+1900);
        System.out.println(date.getMonth()+1);
        System.out.println(date.getDate());
    }
}

4.2 SimpleDateFormat 类[掌握]

创建对象：

 //SimpleDateFormat sdf = new SimpleDateFormat("包含格式符号的模板字符串");
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

核心方法：

public class TestSimpleDateFormat {
    public static void main(String[] args) {
        Date date = new Date();
        //格式化输出
        /**
         * 格式模板 yyyy-MM-dd hh:mm:ss
         * y:年   M:月  d:日   h:时   m:分  s:秒
         */
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        String strDate = sdf.format(date);
        System.out.println(strDate);
    }
}

把一个字符串 转换成日期对象，往往用户输入的都是字符串，即便是一个时间也是以一个字符串输入的比如 2008-10-10，而程序中需要的是一个对象。

Scanner scanner = new Scanner( System.in );
System.out.println("输入生日");
String birthdy = scanner.next(); // 2008-10-10
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
Date parseDate  = sdf2.parse(birthdy);
System.out.println(parseDate);

4.3 Calander 类

日历类，Date 绝大部分api过期了，很多功能就需要借助 Calander 完成。日历除了当前时间以外，还存储了与此相关的其他信息（日历字段）和处理日期一些方法。位于java.util包

4.3.1创建对象：

public class TestCalendar {
    public static void main(String[] args) {
        //获得实例
        Calendar calendar = Calendar.getInstance();
    }
}

4.3.2 核心方法

1. get( int field):int
2. set( int field , int value )
3. add( int field , int amount)
4. getActualMaximum(int field)
5. getActualMinimum(int field)

**

package case1.calander;
import java.util.Calendar;
public class TestCalendar {
    public static void main(String[] args) {
        //获得实例
        Calendar calendar = Calendar.getInstance();
        // get(int x):int 获得日历字段
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH);
        int day = calendar.get(Calendar.DATE);
        int h = calendar.get(Calendar.HOUR);
        int m = calendar.get(Calendar.MINUTE);
        int s = calendar.get(Calendar.SECOND);
        System.out.println( year );
        System.out.println( month+1);
        System.out.println( day );
        System.out.println("------------------------------");
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
        //  set( int field , int value ): 修改日历字段值
        // calendar.set( Calendar.YEAR , 2099);
        // add( int filed, int amont ): 增加日历字段值
         calendar.add(Calendar.MONTH,1);
        // 获得当月最大实际日历信息
       // int maxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
       // int minDay = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
        //System.out.println(maxDay+"  "+minDay);
    }
}

4.3.3 日历案例

package case1.calander;
import java.util.Calendar;
import java.util.Map;
//日历
public class DisplayCalendar {
    public static void main(String[] args) {
        //获得日历
        Calendar calendar = Calendar.getInstance();
        calendar.set(2021,5,1);
        //输出日历头部
        String[] days = {"一","二","三","四","五","六","日"};
        for ( String day : days){
            System.out.print(day+"\t");
        }
        System.out.println();
        //输出日历身体
        int min = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
        int max = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        int xq = calendar.get(Calendar.DAY_OF_WEEK);
        //输出首行空格
        for(int i=1; i<=xq-2;i++){
            System.out.print("\t");
        }
        // 输出全部号数
        for(int i=min; i<=max; i++){
             System.out.print(i+"\t");
             calendar.set(Calendar.DAY_OF_MONTH,i); //把日历指向这一天
             int x=  calendar.get(Calendar.DAY_OF_WEEK) ; //如果这一天是星期天 则换行
             if (x==1){
                 System.out.println();
             }
        }
    }
}

五.其他类

5.1 Arrays

它是一个数组的工具类，提供很多数组操作的方法。核心方法：

package case1.arrays;
import java.util.Arrays;
// 数组工具类
public class TestArrays {
    public static void main(String[] args) {
        int[] arr = {45,29,16,5,20,23,22,9,4};
        // 1. toString(T[] arr)    // 数组转字符串
        System.out.println(  Arrays.toString(arr)  );
        // 2.  sort(T[] )          //  排序
        Arrays.sort(arr);
        System.out.println( Arrays.toString(arr));
        // 3.  binarySearch(T[] T key) // 二分查找
        System.out.println(Arrays.binarySearch(arr, 20));
        // 4. copyOf(int[] arr , int len)  // 数组拷贝
        int[] newArr = Arrays.copyOf(arr, 5);
        System.out.println(Arrays.toString(newArr));
        // 5.  copyOfRange(T[] arr, int from, int to)  // 数组区间拷贝
        int[] newArr2 = Arrays.copyOfRange(arr, 3, 7);
        System.out.println(Arrays.toString(newArr2));
        // 6. equals(T[] a1, T[] a2)  // 两数组相等比较
        int[] xrr = {1,2,3};
        int[] yrr = {1,2,3,4};
        System.out.println(Arrays.equals(xrr, yrr));
        // 7 .fill(T[] arr , int value)   // 数组元素填充
        int[] zrr = new int[10];
        Arrays.fill( zrr,2,5, -1 );
        System.out.println(Arrays.toString(zrr));
    }
}

5.2 Random

这类是一个生成伪随机数类，底层原理使用 使用线性同余公式 ，生成的数字，如果种子相同，进行相同次数的调用得到的值是相同的。
nextInt( int n): int 生成一个0-N之间的整数
nextDouble() ：double 生成一个浮点数
nextBoolean(): boolean 生成一个Boolean值

public class TestRandom {
    public static void main(String[] args) {
        Random rd = new Random(100);// 100为随机数种子
        for (int i= 0; i<4; i++){
            int num = rd.nextInt(100);
            System.out.println(num);
        }
    }
}

5.3 UUID

这个类用于生成 唯一字符串序列

public class TestUUID {
    public static void main(String[] args) {
        //获得一个随机的UUID
        UUID uuid =  UUID.randomUUID();
        //获得UUID字符串
        String uuidStr = uuid.toString();
        //替换 -
        uuidStr =  uuidStr.replace("-","");
        System.out.println(uuidStr);
    }
}

5.4 Math

它是一个数学工具类，提供了数学计算上的一些方法。全部是静态方法

public class TestMath {
    public static void main(String[] args) {
        System.out.println(Math.PI);        // 获得 PI
        System.out.println(Math.abs(-100)); // 计算绝对值
        System.out.println(Math.pow(2, 11));// 计算次方 
        System.out.println( (int)(Math.random()*10)  ); // 随机数0.0-1.0间
        System.out.println(Math.round(3.7)); // 四舍五入
        System.out.println(Math.floor(3.9)); // 向下取整
        System.out.println(Math.ceil(3.1));  // 向上取整
        System.out.println(Math.sqrt(81));   // 开平方根
    }
}

5.5 Runtime

它的对象表示运行环境的对象，通过这个对象可以获得，运行平台的相关信息。

public class TestRuntime {
    public static void main(String[] args) throws IOException {
        //获得实例
        Runtime runtime = Runtime.getRuntime();
        //获得运行环境信息
        int n = runtime.availableProcessors(); // 获得处理器个数的
        System.out.println(n);
        //runtime.exec("C:/Program Files (x86)/Tencent/QQLive/QQLive.exe"); //打开一些软件
        //runtime.exit(0);  //立即退出
        long freeMemory = runtime.freeMemory();
        System.out.println(freeMemory/1024/1024);  // 返回 Java 虚拟机中的空闲内存量。
        long maxMemory = runtime.maxMemory();     // 返回 Java 虚拟机试图使用的最大内存量。
        System.out.println(maxMemory/1024/1024);
        long totalMemory = runtime.totalMemory(); //   返回 Java 虚拟机中的内存总量。
        System.out.println(totalMemory/1024/1024);
        System.out.println("over");
    }
}

5.6 System

System 类包含一些有用的类字段和方法。它不能被实例化。
在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。

public class TestSystem {
    public static void main(String[] args) {
        // 输入流
        Scanner sc = new Scanner( System.in );
        //输出流
        System.out.println(  "hello");
        //错误，打印错误信息
        System.err.println("world");
        // 读取环境变量
        Map<String, String> info = System.getenv();
        System.out.println(info.get("KEY"));
    }
}

课后习题：

生成随机的字符串

class Str1{
    public static String getRandomString(int length) {
        String str = "abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ1234567890";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
// 从1-62的字符中随机取出一位
            int number = random.nextInt(62);
            sb.append(str.charAt(number));
        }
        return sb.toString();
    }
}

找到子字符串在字符串中出现的位置

class str3{
    public void m1(){
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个字符串：");
        String str = sc.next();
        System.out.print("请输入一个子串：");
        String st = sc.next();
        int index=0;
        while(true){
            int i = str.indexOf(st,index);
            if (i==-1){
                break;
            }
            System.out.println("出现的位置是："+i);
            index+=i+st.length();
        }
    }
}

统计数字出现的次数：

class num {
    public void getcount(){
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个字符串(整数)：");
        String str = sc.next();
        char[] arr = str.toCharArray();
        int[] counter = new int[10];
        for (int i = 48; i <58 ; i++) {
            int count=0;
            for (int j = 0; j <arr.length ; j++) {
                if (arr[j]==i)count++;
            }
            counter[i-48]=count;
        }
        for (int i = 0; i <counter.length ; i++) {
            System.out.println(i+"出现的次数为："+counter[i]);
        }
    }
}

统计每个字符出现的字数

class zifu{
    public void getZifu(){
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个字符串：");
        String str = sc.next();
        char[] arr = str.toCharArray();
        char[] c = new char[57];
        for (char i = 65; i < 123; i++) {
            int count=0;
            for (int j = 0; j <arr.length ; j++) {
                if(arr[j]==i)count++;
            }
            if(count!=0)System.out.println(i+"出现的次数为："+count);
        }
    }
}