Java常用类库

Object类

1. Object类是所有Java的父类。
2. 如果使用Object类作为类型去实例化一个子类，那么这个子类就是上传型对象，这个子类定义的自定义方法将无法通过上转型对象进行访问，上转型对象的特点就是会失去一些后定义的属性和方法。

toString方法

1. toString方法返回Object对象的字符串表现形式
2. 此方法可以在任何类中进行重写，重写以后将得到一个新的字符串返回形式

equals方法

1. 用来判断给对的对象是否与当前对象相等
2. public boolean equals(Object target);

(1) 如果当前对象与target相等则返回true

(2) 如果当前对象与target不相等则返回false

getClass方法

1. getClass方法返回当前对象的运行时类（Class）对象
2. public final Class getClass();此方法不允许子类进行重写

hashCode方法

1. hashCode方法返回该对象的int类型哈希码值
2. public int hashCode();

(1) 此方法为提高哈希表的性能而支持，子类进行重写通常没有实际意义

 

Integer包装类

1. Integer类对基本类型int进行包装，它包含一个int值。
2. Integer类提供了多个方法，能在int类型和String类型之间互相转换，还提供了处理int类型时非常有用的其他一些常量和方法。
3. 定义类成员属性常使用Integer替代int从而可以应用更多Integer的功能。
4. 例子：

(1) public Integer(int value);

(2) public Integer(String str); str参数必须是若干数字组成的字符串

Integer字段常量

1. public static final int MAX_VALUE //int类型能够表示的最大值
2. public static final int MIN_VALUE //int类型能够表示的最小值
3. public static final int SIZE //二进制补码形式表示int值的比特位数
4. public static final int BYTES //int类型在JVM中占用空间的字节数

 

compareTo方法

1. public int compaTo(Integer target)
2. 如果当前Integer对象所包含的int值大于target包含的值则返回1，如果小于返回-1，如果相等则返回0。

 

intValue方法

1. 以int类型返回该Integer的值。实现从对象类型转换为值类型，其它类似方法：

(1) byteValue();shortValue;longValue();floatValue();doubleValue()

 

 

parseInt方法

1. public static int parseInt(String s)

(1) 将给定的字符串s转换为10进制int值类型返回，s字符串除了第一个字符可以使用-表示有符号的负数以外，其他字符都必须保证是0~9的数字，否则转换出现NumberFormatException异常。

1. public static int parseInt(String s,int radix)

(1) 将给定的字符串s转换为以以radix标识进制的int值类型返回。

(2) radix的取值通常为2，8，10，16，27

(3) 任何不符合格式的s都将出现NumberFormatException异常

 

valueOf方法

1. 例子：

(1) public static Integer valueOf(int i)

1. 返回一个表示指定的int值的Integer实例。如果不需要新的Integer实例，则通常应优先使用该方法从而提供JVM效率及节省资源。类似方法：

(1) public static Integer valueOf(String s)

(2) public static Integer valueOf(String s,int radix)

 

toBinaryString方法

1. public static String toBinaryString(int i)
2. 将给定的int类型参数i转换为二进制字符串形式返回。
3. 返回的字符串形式省略前导0。类似方法：

(1) toOctalString 转换为8进制字符串

(2) toHexString转换为18进制字符串

 

创建Character实例

1. Character类提供了唯一定义了char类型参数的构造器实例化对象

(1) public Character(char value)

1. 静态方式获取Character实例引用

(1) public static Character valueOf(char c)

 

Character实例方法

1. public char charValue() //返回此Character对象的char值
2. public int compareTo(Character get) //比较大小，返回1，-1，0
3. public String toString() //返回此对象包含char值的字符串形式

 

Character检验字符方法

1. public static boolean isDefine(int ch) //是否是被定义为Unicode中的字符(0-65533)
2. public static boolean isDigit(int ch) //是否是数字
3. public static boolean isLetter(int ch) //是否为字母
4. public static boolean isLetterOrDigit(int ch) //是否为字母或数字
5. public static boolean isLowerCase(int ch) //是否为小写字母
6. public static boolean isUpperCase(int ch) //是否是大写字母
7. public static boolean isSpaceChar(int ch) //是否是空格
8. public static boolean isWhitespace(int ch) //是否为空格符（提倡）
9. public static int toLowerCase(int ch) //返回转换为小写的字符
10. public static int toUpperCase(int ch) //返回转换为大写的字符

 

System实用方法

1. System.out 获取标准输出流
2. System.in 获取标准输入流
3. System.err 获取错误输出流

 

Sytem实用方法2

1. public static void exit(int status) //退出系统，返回一个退出状态码
2. public static void gc() //通知垃圾回收系统期望快速回收垃圾以释放内存空间
3. public static long currentTimeMillis() //获取当前系统时间毫秒表示
4. public static Properties getProperties() //获取当前系统属性map集合
5. public static String getProperty(String key) //按照给定的名称获取当前系统属性字符串表示

 

/**
 * 1 使用Eclipse 工具建立一个java程序, 定义一个自定义类,此类能够对Object类的toString方法进行重写,
 * 重写实现判断此对象是否是Object的子类,如果是返回”Yes” 否则返回”No”
 */

public class Mission1 {
    public static void main(String[] args) {
        Mission1 mission1 = new Mission1();
        String str = mission1.toString();
        System.out.println("此对象是否是Object的子类 "+str);
    }

    @Override
    public String toString() {
        Mission1 mission1 = new Mission1();
        boolean bool1 = mission1 instanceof Object; //判断是否是Object类的子类
        if (bool1){
            return "Yes";
        }else
        return "No";
    }
}

 

------------------------------------分割线-----------------------------------

/**
 * 2使用Eclipse 工具建立一个java程序,定义一个接口,接口中
 * 提供名称是count的计算方法,此方法需要对其在接口中进行重载
 * ,一个带有2个double类型参数, 一个带有2个String 类型参数;
 * 编写一个实现以上接口的普通类并实现对count抽象方法的实现算法,
 * 应考虑字符串类型参数在什么样的情况下才能被计算.
 */

package interfaces;

public interface CountInterfaces {
    //定义一个count方法和两个重载方法
    void count();
    double count(double num1, double num2);
    String count(String str1, String str2);
}

/**
 * 2使用Eclipse 工具建立一个java程序,定义一个接口,接口中
 * 提供名称是count的计算方法,此方法需要对其在接口中进行重载
 * ,一个带有2个double类型参数, 一个带有2个String 类型参数;
 * 编写一个实现以上接口的普通类并实现对count抽象方法的实现算法,
 * 应考虑字符串类型参数在什么样的情况下才能被计算.
 */

package imp;

import interfaces.CountInterfaces;

public class Count implements CountInterfaces {
    public static void main(String[] args) {
        Count cou = new Count();
        double num3 = cou.count(23,56);
        System.out.println("double类型计算的返回结果是："+num3);

        String str3 = cou.count("123","456");
        System.out.println("String类型计算的返回结果是："+str3);
    }


    @Override
    public void count() {

    }

    @Override
    public double count(double num1, double num2) {
        return num1+num2;
    }

    @Override
    public String count(String str1, String str2) {
        //将String类型转换为int型
        int parseInt1 = Integer.valueOf(str1).intValue();
        int parseInt2 = Integer.valueOf(str2).intValue();
        //计算得出结果以后再转换为String类型返回
        String parseString = String.valueOf(parseInt1+parseInt2);

        return parseString;
    }
}

------------------------------------分割线------------------------------------------

/**
 *3使用Eclipse 工具建立一个java程序,定义一个验证类并编写一个验证方法, 完成用户对于输入用户密码的验证功能, 验证功能如下:
 * 1)密码长度必需位于6-16个字符之间;
 * 2)密码中必需至少有大写英文字母,小写英文字母,数字和下划线否则不符合要求
 * 3)此方法应返回boolean值,如果符合要求则返回true 否则返回false.
 * 提示: 参照String 类的API 中的toCharArray() 方法,此方法返回char型数组.  length()方法获取字符串长度
 */

import java.util.Scanner;

public class Identify {
    public static void main(String[] args) {
        //先来一个Scanner接收用户输入
        Scanner input = new Scanner(System.in);

        //定义一个字符串接收用户输入
        System.out.println("请输入您的密码：");
        String pwd = input.next();

        boolean bool1 = identifyPassword(pwd);

        System.out.println("您输入的密码是否符合要求："+bool1);
        System.out.println("您的密码是："+pwd);


    }

    public static boolean identifyPassword(String pwd){
        //先把字符串转换为char类型的数组
        char array1[] = pwd.toCharArray();

        //定义4个变量存储大写英文字母，小写英文字母，数字和下划线的数量
        int upLetter = 0;   //大写字母数量，默认0
        int lowLetter = 0;  //小写字母数量，默认0
        int countNum = 0;   //数字数量，默认0
        int lowLine = 0;    //下划线数量，默认0


        //判断用户输入的密码是否符合要求
        if(array1.length>=6&&array1.length<=16){
            for (int i=0;i<=array1.length-1;i++){
                if(Character.isUpperCase(array1[i])){   //判断是否是大写字母
                    upLetter++;
                }else if (Character.isLowerCase(array1[i])){    //判断是否是小写字母
                    lowLetter++;
                }else if(Character.isDigit(array1[i])){     //判断是否是数字
                    countNum++;
                }else if(array1[i]=='_'){       //判断是否是下划线
                    lowLine++;
                }
            }
            if (upLetter!=0&&lowLetter!=0&&countNum!=0&&lowLine!=0){
                return true;
            }else
                return false;
        }else
            return false;


    }
}

-----------------------------------------分割线---------------------------------------------------

import java.util.Scanner;

/**
 * 4使用Eclipse 工具建立一个java程序,定义一个验证类并编写一个方法,
 * 此方法能够实现对给定的int类型参数计算有多少个数字组成,并返回组成这
 * 个int类型数值的数字个数.
 */

public class Test {
    public static void main(String[] args) {
        //先来一个Scanner接收用户输入
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个int类型的数字：");
        int num1 = input.nextInt();
        int num2 = CountIntDigit.countDigit(num1);
        System.out.println("您输入了"+num2+"个数字");
    }


}

/**
 * 4使用Eclipse 工具建立一个java程序,定义一个验证类并编写一个方法,
 * 此方法能够实现对给定的int类型参数计算有多少个数字组成,并返回组成这
 * 个int类型数值的数字个数.
 */

public class CountIntDigit {
    public static int countDigit(int num1){
        //把int类型转换为String类型
        String str = String.valueOf(num1);
        //再把String类型转换为数组类型
        char[] array1 = str.toCharArray();
        //返回数组长度
        return array1.length;
    }
}

----------------------------------分割线------------------------------------

/**
 * 5 设计一个接口,此接口中定义若干3个如下抽象方法,
 * int  statistics(int number); // 预计实现对number 组成的每个数值的某种计算
 * int  statistics(int number,int number2 ); // 预计实现对number 和 number2 长度的比较
 * int  statistics(int [ ] intArr, char target); // 预计实现对intArr 数组中是否包含给定的target字符,包含几个
 * 编写一个类作为上述接口的适配器类, 定义一个包含main方法的测试类,使用内部匿名对象实现接口中方法的功能.
 */
package interfaces;

public interface Computer {
    int statistics(int number);
    int statistics(int number, int number2);
    int statistics(int [] intArr,char target);
}

/**
 * 5 设计一个接口,此接口中定义若干3个如下抽象方法,
 * int  statistics(int number); // 预计实现对number 组成的每个数值的某种计算
 * int  statistics(int number,int number2 ); // 预计实现对number 和 number2 长度的比较
 * int  statistics(int [ ] intArr, char target); // 预计实现对intArr 数组中是否包含给定的target字符,包含几个
 * 编写一个类作为上述接口的适配器类, 定义一个包含main方法的测试类,使用内部匿名对象实现接口中方法的功能.
 */

package adaptor;

import interfaces.Computer;

public class ComputerAdaptor implements Computer {
    @Override
    public int statistics(int number) {
        return 0;
    }

    @Override
    public int statistics(int number, int number2) {
        return 0;
    }

    @Override
    public int statistics(int[] intArr, char target) {
        return 0;
    }
}

/**
 * 5 设计一个接口,此接口中定义若干3个如下抽象方法,
 * int  statistics(int number); // 预计实现对number 组成的每个数值的某种计算
 * int  statistics(int number,int number2 ); // 预计实现对number 和 number2 长度的比较
 * int  statistics(int [ ] intArr, char target); // 预计实现对intArr 数组中是否包含给定的target字符,包含几个
 * 编写一个类作为上述接口的适配器类, 定义一个包含main方法的测试类,使用内部匿名对象实现接口中方法的功能.
 */

package main;

import adaptor.ComputerAdaptor;

public class Test extends ComputerAdaptor {
    public static void main(String[] args) {
        /**
         *  int  statistics(int number); // 预计实现对number 组成的每个数值的某种计算
         */
        //定义一个int变量，目的是计算这个int变量所有数字的累加和，此处其实可以使用Scanner接收用户输入，为了节省测试时间没写
        int number1 = 12346578;
        //运行静态方法ComputerMethod1,new一个父类类型的匿名类对象，在这个类里面重写父类接口的方法并具体实现它
        //这玩意儿真的有点绕，他把,ComputerAdaptor com1 = new ComputerAdaptor();拆开了，
        //等号左边放到了主方法外自定方法的参数里，等号右边放到了主方法里调用自定义方法的参数里面
        ComputerMethod1(number1,new ComputerAdaptor(){
            @Override
            public int statistics(int number) {
                //把int类型转换为String类型
                String str1 = String.valueOf(number);
                //再把String类型转换为数组类型
                char[] array1 = str1.toCharArray();
                //定义一个局部变量统计数组累加的和
                int countNumber1 = 0;
                //累加这个数组
                for(int i = 0;i < array1.length;i++){
                    countNumber1+=Integer.valueOf(array1[i]);
                }
                return countNumber1;
            }
        });

        /**
         * int  statistics(int number,int number2 ); // 预计实现对number 和 number2 长度的比较
         */
        //定义两个int变量，目的是对这两个变量的长度进行比较，此处其实可以使用Scanner接收用户输入，为了节省测试时间没写
        int number2 = 123456;
        int number3 = 123456789;
        //运行静态方法ComputerMethod2,new一个父类类型的匿名类对象，在这个类里面重写父类接口的方法并具体实现它
        ComputerMethod2(number2,number3,new ComputerAdaptor(){
            @Override
            public int statistics(int number, int number2) {
                //把int类型转换为String类型
                String str1 = String.valueOf(number);
                String str2 = String.valueOf(number2);
                //再把String类型转换为数组类型
                char[] array1 = str1.toCharArray();
                char[] array2 = str2.toCharArray();
                //定义两个局部变量统计数组累加的和
                int countNumber1 = 0;
                int countNumber2 = 0;
                //遍历数组每一个元素，进行累加
                for (int i = 0;i<array1.length;i++){
                    countNumber1++;
                }
                for (int i = 0;i<array2.length;i++){
                    countNumber2++;
                }
                //比较累加的和并打印比较的结果
                if (countNumber1>countNumber2){
                    System.out.println("number2:"+number+" 比 "+"number3:"+number2+" 多 "+(countNumber1-countNumber2)+"位");
                }else if(countNumber1<countNumber2){
                    System.out.println("number:"+number2+" 比 "+"number2:"+number+" 多 "+(countNumber2-countNumber1)+"位");
                }else if (countNumber1==countNumber2){
                    System.out.println("number2:"+number+" 和 "+"number3:"+number2+"位数相等");
                }else{
                    return 0;
                }
                return 0;
            }
        });

        /**
         * int statistics(int [] intArr,char target); //预计实现对intArr数组中是否包含给定的target字符,包含几个
         */
        //定义一个int数组intArr和char target字符
        int intArr[] = {9,9,1,3,8,9,5,5,8};
        char target = 9;
        ComputerMethod3(intArr,target,new ComputerAdaptor(){
            @Override
            public int statistics(int[] intArr, char target) {
                //先把char转换为int方便比较
                int num = Integer.valueOf(target);
                //定义一个累加变量
                int countNumber = 0;
                for (int i = 0;i<intArr.length;i++){
                    if (intArr[i]==num){
                        countNumber++;
                    }
                }
                return countNumber;
            }
        });

    }
    //定义一个静态的方法计算number数字之和,定义一个以父类Computer为类型的匿名类对象com1作为这个方法的参数
    public static void ComputerMethod1(int number,ComputerAdaptor com1){
        //调用匿名类对象的方法并传参
        int countNumber1 = com1.statistics(number);
        //输出返回的结果
        System.out.println("number1："+number+" 内所有数字累加的和为"+countNumber1);
    }

    //定义一个方法比较number和number2的长度，定义一个以父类Computer为类型的匿名类对象com2作为这个方法的参数
    public static void ComputerMethod2(int number,int number2,ComputerAdaptor com2){
        //调用匿名类对象的方法并传参
        com2.statistics(number,number2);
    }

    //定义一个静态的方法检查intArr数组中包含几个target字符，定义一个以父类Computer为类型的匿名类对象com3作为这个方法的参数
    public static void ComputerMethod3(int[]intArr,char target,ComputerAdaptor com3){
        //调用匿名类对象的方法并传参
        int countNumber = com3.statistics(intArr,target);
        System.out.println("intArr[]数组里一共有"+countNumber+"个target");
    }
}