澳门贵宾会娱乐官网java常用类的使用方法

在有一点必要在那之中我们要求抓取字段何况填充到excel表格里面,最后将excel表格转变到pdf格式进行输出,作者先是次接触这些供给时,蒙受多少个相比劳苦的题目,今后逐个列出而且提供施工方案。

java常用类的行使方法

1:excel转pdf现身乱码:

Interger:整数类型

    第三回excel转pdf是瓜熟蒂落的,第2回起先前边都已乱码,是因为自己的pdf转excel方法出现的难点,化解办法是使用java自个儿底层的方法(详见下方代码卡塔 尔(英语:State of Qatar)。

1、属性。

 public static boolean getLicense()
{
        boolean result = false;
        try {
            InputStream is =
Thread.currentThread().getContextClassLoader()
                  
 .getResourceAsStream(“license.xml”); // 
license.xml应放在..\WebRoot\WEB-INF\classes路径下
            License aposeLic = new
License();
           
aposeLic.setLicense(is);
            result = true;
        } catch (Exception e)
{               
            e.printStackTrace();
        }
        return result;
    }
    
    
    public static void
excelTransferPdf(String excelPath,String pdfPath) {
        if (!getLicense()) {
            System.out.println(“license
faile”);
            return;
        }
        
        try {     
            Workbook wb = new
Workbook(excelPath);
            FileOutputStream fileOS = new
FileOutputStream(new File(pdfPath));
            wb.save(fileOS,
com.aspose.cells.SaveFormat.PDF);
            fileOS.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

static int MAX_VALUE:再次来到最大的整型数;
static int MIN_VALUE:重返最小的整型数;
static Class TYPE :再次回到当前项目。

2:excel转pdf现身折行。

例子:
代码:
System.out.println(“Integer.MAX_VALUE: ” + Integer.MAX_VALUE );
结果为:Integer.MAX_VALUE: 2147483647
 

  excel转pdf现身折行的场合十三分广泛,因为在程序运营进程中有的是字段是抓取的,你不可能看清你的excel转成pdf会有几页,所以那时候你就无须随便设置excel的预览格式,将excel的单元格式设置自动换行。

2、构造函数。

3:抓取字段展现结果残缺:。

Integer(int value) :通过三个int的项目构造对象;
Integer(String s) :通过多个String的档期的顺序构造对象;

  当你未安装单元格大小而又不曾设置单元格自动换行,例如您的A18单元格里面包车型大巴字段超越了单元格的尺寸你还从未设置单元格大小而又从未设置单元格自动换行,就将抓取的字段填充在B18单元格里面,那么打字与印刷出来的pdf文件A18单元格超过单元相当的原委是不予显示的,当时您要么将抓取字段填充在C18单元格内要么将改进A18单元格格式

例子:
代码:
Integer i = new Integer(“1234”);
更换了叁个值为1234的Integer对象。
 

4:excel转PDF字段内容无故中间部分换行:

3、方法。
说明:

  那是自己蒙受的最坑的一个地点,那个时候你只供给在excel单元格里面安装自动换行就能够,无需代码强行自动换行(强行换行有希望只现出多行数据只展现大器晚成行卡塔 尔(英语:State of Qatar)。同有时候你须要如下代码:

  1. 具备办法均为public;
  2. 书写格式:〔修饰符〕 <重回类型>
    <方法名(〔参数列表〕卡塔 尔(阿拉伯语:قطر‎>
    如:
    static int parseInt(String s)
    表示:此办法(parseInt卡塔尔国为类情势(static卡塔尔国,重临类型为(int卡塔尔,方法所需参数为String类型。

/**
     *
取得一个字符串的长短,显示的长短,一个中华夏族民共和国字或日丹麦语长度为1,立陶宛语字符长度为0.5
     *
     * @param String
     *            s 需求获得长度的字符串
     * @return int 获得的字符串长度
     */
    public static double getLength(String s) {
        double valueLength = 0;
        if (s == null) {
            return 0;
        }
        String chinese = “[\u4e00-\u9fa5]”;
        //
获取字段值的长度,要是含中文字符,则每一种中文字符长度为2,不然为1
        for (int i = 0; i < s.length(); i++) {
            // 获取贰个字符
            String temp = s.substring(i, i + 1);
            // 判别是或不是为中文字符
            if (temp.matches(chinese)) {
                // 粤语字符长度为2
                valueLength += 2;
            } else {
                // 别的字符长度为1
                valueLength += 1;
            }
        }
        // 进位取整
        return Math.ceil(valueLength);
    }

 

    /**
     * 依据字符串长度获取行高
     *
     * @param str
     * @return
     */
    public static Float getRowHeight(String str) {

  1. byteValue():获得用byte类型表示的平头;
  2. int compareTo(Integer anotherInteger)
    :比较八个整数。相等时重临0;小于时回来负数;大于时再次回到正数。

        Integer lineCount = (int) (getLength(str) / 64) + 1;
        if (str.contains(“\n”)) {
            Integer tempLineCount = 1;
            String[] lines = str.split(“\n”);
            for (String line : lines) {
                Integer everyLineCount = (int) (getLength(line) / 64) +
1;
                tempLineCount += everyLineCount;
            }
            lineCount = lineCount >= tempLineCount ? lineCount :
tempLineCount;
        }
        Float rowHeight = (float) (lineCount * 20);
        return rowHeight;
    }

例子:
代码:

您必要先获得抓取的字符串的长度,然后经过那些点子总括行高,再将excel须要填写的该行用Java代码设置行高(行高单位是像素卡塔 尔(阿拉伯语:قطر‎,然而假设现身自个儿上边说的字段内容无故中间部分换行,那么您获取的行高就能够相差,那个时候你要求改造这些地点—–>>>>Float rowHeight = (float) (lineCount * X); 
x的值应当要安装的大学一年级行,避防现身这种景观!

Integer i = new Integer(1234);
System.out.println(“i.compareTo: ” + i.compareTo(new Integer(123)) );
结果为:i.compareTo: 1
 

 

 

  1. int compareTo(Object o)
    :将该整数与任何类进行比较。要是o也为Integer类,进行艺术2
    的操作;不然,抛出ClassCastException非常。
  2. static Integer decode(String nm) :将字符串转变为整数。
  3. double doubleValue() :得到该整数的双精度表示。
  4. boolean equals(Object obj) :比非常多少个对象。
  5. float floatValue() :得到该整数的浮点数表示。
  6. static Integer getInteger(String nm) :依据钦定名明确系统特征值。
  7. static Integer getInteger(String nm, int val) :上面包车型地铁重载。
  8. static Integer getInteger(String nm, Integer val) :上边包车型大巴重载。
  9. int hashCode() :重临该整数类型的哈希表码。
  10. int intValue() : 重临该整型数所表示的整数。
  11. long longValue() :再次来到该整型数所表示的长整数。
  12. static int parseInt(String s)
    :将字符串调换来整数。s必得是时进制数组成,不然抛出NumberFormatException极度。
  13. static int parseInt(String s, int radix)
    :以radix为基数radix重返s的十进制数。所谓的基数,正是“几进制”。

例子:
代码:

String s1 = new String(“1010”);
System.out.println(“Integer.parseInt(String s, int radix): ” +
Integer.parseInt(s1,2) );
结果为:Integer.parseInt(String s, int radix): 10
 

 

  1. short shortValue() :重返该整型数所表示的短整数。
  2. static String toBinaryString(int i) :将整数转为二进制数的字符串。
  3. static String toHexString(int i) :将整数转为十三进制数的字符串。
  4. static String toOctalString(int i) :将整数转为八进制数的字符串。
  5. String toString() :将该整数类型调换为字符串。
  6. static String toString(int i)
    :将该整数类型转变为字符串。区别的是,此为类措施。
  7. static String toString(int i, int radix)
    :将整数i以基数radix的款型转形成字符串。

例子:
代码:
int i1 = 54321;
System.out.println(“Integer.toString(int i, int radix): ” +
Integer.toString(i1,16) );
结果为:Integer.toString(int i, int radix): d431

 

  1. static Integer valueOf(String s) :将字符串转换来整数类型。
  2. static Integer valueOf(String s, int radix)
    :将字符串以基数radix的渴求调换成整数类型。
     

Float类的运用办法

Float:实数类型

1、属性。

  1. static float MAX_VALUE :
    重返最大浮点数,在分歧硬件平高雄由Float.intBitsToFloat(0x7f7fffff)总计得出。
  2. static float MIN_VALUE :
    重临最小浮点数,在差异硬件平高雄由Float.intBitsToFloat(0x1)总结得出。
  3. static float NaN :
    表示非数值类型的浮点数,在不相同硬件平新北由Float.intBitsToFloat(0x7fc00000)计算得出。
  4. static float
    NEGATIVE_INFINITY:重回负无穷浮点数,在差别硬件平高雄由Float.intBitsToFloat(0xff800000)总计得出。
  5. static float POSITIVE_INFINITY
    :再次回到正无穷浮点数,在不相同硬件平台北由Float.intBitsToFloat(0x7f800000)总结得出。
  6. static Class TYPE :重回当前项目。

2、构造函数。

Float(double value) :以double类型为参数构造Float对象。
Float(float value) :以Float类型为参数构造Float对象。
Float(String s) :以String类型为参数构造Float对象。

3、方法。
说明:

  1. 不无办法均为public;
  2. 书写格式:〔修饰符〕 <再次回到类型>
    <方法名(〔参数列表〕卡塔 尔(英语:State of Qatar)>
    如:
    static int parseInt(String s)
    表示:此方法(parseInt卡塔尔国为类格局(static卡塔 尔(英语:State of Qatar),重返类型为(int卡塔 尔(阿拉伯语:قطر‎,方法所需参数为String类型。

 

  1. byte byteValue() :重返以字节表示的浮点数。
  2. static int compare(float f1, float f2)
    :此为类措施,相比f1和f2。也就是new Float(f1).compareTo(new
    Float(f2))。要是f1与f2相等,重返0;小于关系,重回负数;大于关系,再次来到正数。
  3. int compareTo(Float anotherFloat)
    :此为对象方法,当前指标与anotherFloat相比。与2的相比较准绳同样。
  4. int compareTo(Object o)
    :当前目的与o实行相比较,假诺o归属Float类,那么,相当于3;如若是其余类,则抛出ClassCastException非凡。
  5. double doubleValue() :重回浮点数的双精度值。
  6. boolean equals(Object obj)
    :比较当前Float对象与obj的从头到尾的经过是不是意气风发律。大相当多动静是相比较五个Float对象的值是不是等于,也正是f1.floatValue()
    == f2.floatValue()的值。与2、3、4不风度翩翩的是:6再次来到boolean型。
  7. static int floatToIntBits(float value):依据IEEE
    754转速成float并出口它的十进制数值。
  8. float floatValue() :重回该浮点数对象的浮点数值。
  9. int hashCode() :重回该Float对象的哈希表码。
  10. int intValue() :再次回到该Float对象的整数值(整数片段卡塔尔国。
  11. boolean isInfinite() :决断该Float对象是或不是是无穷。
  12. static boolean isInfinite(float v)
    :与11临近,区别的是:此为类措施,判别的是v。
  13. boolean isNaN() :剖断该Float对象是或不是为非数值。
  14. static boolean isNaN(float v) :功能与13等同,只可是剖断v。
  15. long longValue() :重返该Float对象的长整数值。
  16. static float parseFloat(String s) :将字符串转换到浮点数。
  17. short shortValue() :重返该Float对象的短整数值。
  18. String toString() :将该Float对象调换来字符串。
  19. static String toString(float f) :效用与18平等,只是调换f。
  20. static Float valueOf(String s) :将字符串调换成浮点数。

例子:
代码:
Float f = new Float(1237.45);
Float fs = new Float(“123.45”);
Float fd = new Float(1234146865679824657987947924623724749.16416925);

System.out.println(“f.compare(fs): ” + f.compareTo(fs) );
System.out.println(“f.compareTo(fd): ” + f.compareTo(fd) );
System.out.println(“Float.compare(1.23f,3.25f): ” +
Float.compare(1.23f,3.25f) );
结果为:
f.compare(fs): 1
f.compareTo(fd): -1
Float.compare(1.23f,3.25f): -1

代码:
Float f = new Float(1237.45);
System.out.println(“f.equals(fs): ” + f.equals(fs) );
结果为:f.equals(fs): false

Double类的使用方法

Double:双精度类型

1、属性。

 

  1. static Double MAX_VALUE :
    再次来到最大双精度数,在差异硬件平新竹由Double.longBitsToDouble(0x7fefffffffffffffL)总计得出。
  2. static Double MIN_VALUE :
    再次回到最小双精度数,在差别硬件平台北由Double.longBitsToDouble(0x1L)计算得出。
  3. static Double NaN :
    表示非数值类型的双精度数,在区别硬件平台南由Double.longBitsToDouble(0x7ff8000000000000L)总结得出。
  4. static Double
    NEGATIVE_INFINITY:重临负无穷双精度数,在不相同硬件平台南由Double.longBitsToDouble(0xfff0000000000000L)总括得出。
  5. static Double POSITIVE_INFINITY
    :重返正无穷双精度数,在不相同硬件平台南由Double.longBitsToDouble(0x7ff0000000000000L)总计得出。
  6. static Class TYPE :再次回到当前项目。

2、构造函数。

Double(double value) :以double类型为参数成立Double对象。
Double(String s) :以String类型为参数创设String对象。

3、方法。
说明:

  1. 装有办法均为public;
  2. 书写格式:〔修饰符〕 <再次来到类型>
    <方法名(〔参数列表〕卡塔 尔(英语:State of Qatar)>
    如:
    static int parseInt(String s)
    表示:此方法(parseInt卡塔 尔(英语:State of Qatar)为类方式(static卡塔尔国,再次回到类型为(int卡塔 尔(英语:State of Qatar),方法所需参数为String类型。

 

  1. byte byteValue() :重临以字节表示的双精度数。
  2. static int compare(double d1, double d2)
    :此为类措施,相比较d1和d2。也正是new Double(d1).compareTo(new
    Double(d2))。假使d1与d2相等,重返0;小于关系,再次来到负数;大于关系,再次来到正数。
  3. int compareTo(Double anotherDouble)
    :此为对象方法,当前指标与anotherDouble比较。与2的相比较准则同样。
  4. int compareTo(Object o)
    :当前目的与o举行相比,固然o归属Double类,那么,也便是3;假诺是其余类,则抛出ClassCastException卓殊。
  5. static long doubleToLongBits(double value) :把value根据IEEE
    754转变成long并出口它的十进制数值。
  6. double doubleValue() :重临该双精度数对象的双精度数值。
  7. boolean equals(Object obj)
    :比较当前Double对象与obj的原委是或不是雷同。大超级多状态是比较七个Double对象的值是或不是等于,也便是d1.doubleValue()
    == d2.doubleValue()的值。
  8. float floatValue() :重返该浮点数对象的浮点数值。
  9. int hashCode() :再次来到该Double对象的哈希表码。
  10. int intValue() :再次回到该Double对象的整数值(整数某个卡塔尔。
  11. boolean isInfinite() :剖断该Double对象是或不是是无穷。
  12. static boolean isInfinite(double v)
    :与11相近,区别的是:此为类形式,决断的是v。
  13. boolean isNaN() :剖断该Double对象是否为非数值。
  14. static boolean isNaN(double v) :功用与13相近,只可是剖断v。
  15. long longValue() :再次回到该Double对象的长整数值。
  16. static float parseFloat(String s) :将字符串转变到双精度数。
  17. short shortValue() :重回该Double对象的短整数值。
  18. String toString() :将该Double对象转换到字符串。
  19. static String toString(Double f) :成效与18等同,只是转变f。
  20. static Double valueOf(String s) :将字符串转变到双精度数。

事例:与Float类的肖似。

 

Character类的选取办法

Character:字符类型

1、属性。

static int MIN_RADIX :重返最小基数。
static int MAX_RADIX :再次回到最大基数。
static char MAX_VALUE :字符类型的最大值。
static char MIN_VALUE :字符类型的矮小值。
static Class TYPE :再次来到当前项目。

2、构造函数。

Character(char value):以char参数构造三个Character对象。

3、方法。
说明:

  1. 怀有办法均为public;
  2. 挥洒格式:〔修饰符〕 <重返类型>
    <方法名(〔参数列表〕卡塔 尔(阿拉伯语:قطر‎>
    如:
    static int parseInt(String s)
    表示:此方法(parseInt卡塔 尔(阿拉伯语:قطر‎为类措施(static卡塔 尔(英语:State of Qatar),重返类型为(int卡塔 尔(阿拉伯语:قطر‎,方法所需参数为String类型。
  1. char charValue() :重临字符对象的值。
  2. int compareTo(Character anotherCharacter)
    :当前Character对象与anotherCharacter相比。相等关系重返0;小于关系重临负数;大于关系重临正数。
  3. int compareTo(Object o)
    :当前指标与另八个对象进行比较。若是o是Character对象,则与2效应肖似;不然,抛出ClassCastException极度。
  4. static int digit(char ch, int radix)
    :依据基数再次来到当前字符的值的十进制。倘使不满足Character.MIN_RADIX <=
    radix <=
    Character.MAX_RADIX,恐怕,ch不是radix基数中的有效值,再次来到”-1″;如若ch是“大写”的A到Z之间,则赶回ch
  • ‘A’ + 10 的值;如果是“小写”a到z之间,返回ch – ‘a’ + 10 的值。

代码:
System.out.println(“Character.MIN_RADIX: ” + Character.MIN_RADIX );
System.out.println(“Character.MAX_RADIX: ” + Character.MAX_RADIX );
System.out.println(“Character.digit(‘2’,2): ” + Character.digit(‘2’,2)
);
System.out.println(“Character.digit(‘7’,10): ” + Character.digit(‘7’,10)
);
System.out.println(“Character.digit(‘F’,16): ” + Character.digit(‘F’,16)
);
结果为:
Character.MIN_RADIX: 2
Character.MAX_RADIX: 36
Character.digit(‘2’,2): -1
Character.digit(‘7’,10): 7
Character.digit(‘F’,16): 15

  1. boolean equals(Object obj)
    :与obj对象比较。当且仅当obj不为“null”而且和当下Character对象豆蔻梢头致时再次回到“true”。
  2. static char forDigit(int digit, int radix)
    :依照特定基数判别当前数值表示的字符。4的逆运算,违法数值时重返“’/u0000’”。

代码:
System.out.println(“Character.MIN_RADIX: ” + Character.MIN_RADIX );
System.out.println(“Character.MAX_RADIX: ” + Character.MAX_RADIX );
System.out.println(“Character.forDigit(2,2): ” + Character.forDigit(2,2)
);
System.out.println(“Character.forDigit(7,10): ” +
Character.forDigit(7,10) );
System.out.println(“Character.forDigit(15,16): ” +
Character.forDigit(15,16) );
结果为:
Character.MIN_RADIX: 2
Character.MAX_RADIX: 36
Character.forDigit(2,2):
Character.forDigit(7,10): 7
Character.forDigit(15,16): f
 

 

  1. static int getNumericValue(char ch) :重临字符ch的数值。
  2. static int getType(char ch)
    :重回字符所属类型。具体有怎样项目请查看Java文书档案资料。
  3. int hashCode() :重返当前字符的哈希表码。
  4. static boolean isDefined(char ch)
    :判定字符ch在Unicode字符集是还是不是用刚毅概念。
  5. static boolean isDigit(char ch) :决断字符ch是还是不是为数字。
  6. static boolean isIdentifierIgnorable(char ch)
    :剖断字符ch是还是不是为Unicode字符聚集可忽视的字符。
  7. static boolean isISOControl(char ch)
    :判断字符ch是不是为ISO标准中的调整字符。
    14.static boolean isJavaIdentifierPart(char ch)
    :判别字符ch是不是为Java中的部分标记符。
  8. static boolean isJavaIdentifierStart(char ch)
    :判别字符ch是不是为Java中的第一个标志符。
  9. static boolean isLetter(char ch) :判别字符ch是不是为字母。
  10. static boolean isLetterOrDigit(char ch)
    :决断字符ch是否为字母或数字。
  11. static boolean isLowerCase(char ch) :剖断字符ch是还是不是为小写字母。
  12. static boolean isMirrored(char c)
    :遵照Unicode表决断字符c是不是存在与之趋势相反的字符。比方:“〔”存在与之大势相反的“〕”,结果为:true。
  13. static boolean isSpaceChar(char ch)
    :决断字符ch是或不是为Unicode中的空格。
  14. static boolean isUpperCase(char ch) :决断字符ch是不是为大写字母。
  15. static boolean isWhitespace(char ch)
    :剖断字符ch是不是为Java定义中的空字符。
    代码:
    内部包罗:
      char c1 = ‘/u0009’;//水平列表符
      char c2 = ‘/u000A’;//换行
      char c3 = ‘/u000B’;//垂直列表符
      char c4 = ‘/u000C’;//换页
      char c5 = ‘/u000D’;//回车
      char c6 = ‘/u001C’;//文件分隔符
      char c7 = ‘/u001D’;//组分隔符
      char c8 = ‘/u001E’;//记录分隔符
      char c9 = ‘/u001F’;//单元分隔符

  16. static char toLowerCase(char ch) :调换ch是不是为小写。

  17. String toString() :将眼下Character对象调换来字符串。
  18. static String toString(char c) :此为类措施,将c调换到字符串。
  19. static char toUpperCase(char ch) :转变ch是不是为大写。

代码:
System.out.println(“Character.toUpperCase(‘q’): ” +
Character.toUpperCase(‘q’) );
System.out.println(“Character.toLowerCaseCase(‘B’): ” +
Character.toLowerCase(‘B’) );
结果为:
Character.toUpperCase(‘q’): Q
Character.toLowerCaseCase(‘B’): b

 

string类的行使方法

String:字符串类型
此帖仿照效法了maxlyy朋友的帖子,在那间特别谢谢。
1、构造函数。

String() :构造一个空字符串对象。
String(byte[] bytes) :通过byte数组构造字符串对象。
String(byte[] bytes, int offset, int length)
:通过byte数组,从offset最先,总共length长的字节构造字符串对象。
String(char[] value) :通过char数组构造字符串对象。
String(char[] value, int offset, int count)
:通过char数组,从offset初阶,总共length长的字节构造字符串对象。
String(String original)
:构造二个original的别本。既,拷贝二个original。
String(StringBuffer buffer) :通过StringBuffer数组构造字符串对象;

代码:
  byte[] b = {‘a’,’b’,’c’,’d’,’e’,’f’,’g’,’h’,’i’,’j’};
  char[] c = {‘0′,’1′,’2′,’3′,’4′,’5′,’6′,’7′,’8′,’9’};

  String sb = new String(b);
  String sb_sub = new String(b,3,2);
  String sc = new String(c);
  String sc_sub = new String(c,3,2);
  String sb_copy = new String(sb);
 
  System.out.println(“sb: ” + sb );
  System.out.println(“sb_sub: ” + sb_sub );
  System.out.println(“sc: ” + sc );
  System.out.println(“sc_sub: ” + sc_sub );
  System.out.println(“sb_copy: ” + sb_copy );
结果为:
sb: abcdefghij
sb_sub: de
sc: 0123456789
sc_sub: 34
sb_copy: abcdefghij

2、方法。
说明:

  1. 负有办法均为public;
  2. 挥洒格式:〔修饰符〕 <重临类型>
    <方法名(〔参数列表〕卡塔 尔(英语:State of Qatar)>
    如:
    static int parseInt(String s)
    表示:此措施(parseInt卡塔尔国为类措施(static卡塔 尔(阿拉伯语:قطر‎,重临类型为(int卡塔 尔(阿拉伯语:قطر‎,方法所需参数为String类型。

 

  1. char charAt(int index)
    :取字符串中的某一个字符,个中的参数index指的是字符串中序数。字符串的序数从0以前到length()-1

代码:
  String s = new String(“abcdefghijklmnopqrstuvwxyz”);
  System.out.println(“s.charAt(5): ” + s.charAt(5) );
结果为:s.charAt(5): f

  1. int compareTo(String anotherString)
    :当前String对象与anotherString比较。相等关系重返0;不等于时,从三个字符串第0个字符发轫比较,重返第三个不等于的字符差,另风华正茂种状态,较长字符串的前方部分恰好是超级短的字符串,重返它们的长度差。
  2. int compareTo(Object o)
    :假若o是String对象,和2的效果与利益相符;不然抛出ClassCastException极度。

代码:
  String s1 = new String(“abcdefghijklmn”);
  String s2 = new String(“abcdefghij”);
  String s3 = new String(“abcdefghijalmn”);

  System.out.println(“s1.compareTo(s2): ” + s1.compareTo(s2)
);//重回长度差
  System.out.println(“s1.compareTo(s3): ” + s1.compareTo(s3)
);//返回’k’-‘a’的差
结果为:
s1.compareTo(s2): 4
s1.compareTo(s3): 10

 

  1. String concat(String str) :将该String对象与str连接在一块。
  2. boolean contentEquals(StringBuffer sb)
    :将该String对象与StringBuffer对象sb进行比较。
  3. static String copyValueOf(char[] data) :
  4. static String copyValueOf(char[] data, int offset, int count)
    :那多少个措施将char数组转变来String,与当中多个构造函数肖似。
  5. boolean endsWith(String suffix) :该String对象是或不是以suffix结尾。

代码:
  String s1 = new String(“abcdefghij”);
  String s2 = new String(“ghij”);
  System.out.println(“s1.endsWith(s2): ” + s1.endsWith(s2) );
结果为:s1.endsWith(s2): true

 

  1. boolean equals(Object anObject)
    :当anObject不为空况兼与这段时间String对象同样,再次来到true;否则,重临false。
  2. byte[] getBytes() :将该String对象调换到byte数组。
  3. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
    :该方法将字符串拷贝到字符数组中。当中,srcBegin为拷贝的开场地点、srcEnd为拷贝的收尾地方、字符串数值dst为对象字符数组、dstBegin为目的字符数组的正片初步地点。

代码:
  char[] s1 = {‘I’,’ ‘,’l’,’o’,’v’,’e’,’ ‘,’h’,’e’,’r’,’!’};//s1=I
love her!
  String s2 = new String(“you!”);
  s2.getChars(0,3,s1,7);  //s1=I love you!
  System.out.println( s1 );
结果为:I love you!

  1. int hashCode() :再次回到当前字符的哈希表码。
  2. int indexOf(int ch) :只找第三个匹配字符位置。
  3. int indexOf(int ch, int fromIndex)
    :从fromIndex开头找第一个相称字符地点。
  4. int indexOf(String str) :只找第多少个匹配字符串地点。
  5. int indexOf(String str, int fromIndex)
    :从fromIndex先河找第3个相配字符串地点。

代码:
  String s = new String(“write once, run anywhere!”);
  String ss = new String(“run”);
  System.out.println(“s.indexOf(‘r’): ” + s.indexOf(‘r’) );
  System.out.println(“s.indexOf(‘r’,2): ” + s.indexOf(‘r’,2) );
  System.out.println(“s.indexOf(ss): ” + s.indexOf(ss) );
结果为:
s.indexOf(‘r’): 1
s.indexOf(‘r’,2): 12
s.indexOf(ss): 12

  1. int lastIndexOf(int ch)
  2. int lastIndexOf(int ch, int fromIndex)
  3. int lastIndexOf(String str)
  4. int lastIndexOf(String str, int fromIndex)
    以上两个法子与13、14、15、16相近,差异的是:找最终三个十三分的内容。
  5. int length() :再次回到当前字符串长度。
  6. String replace(char oldChar, char newChar)
    :将字符号串中率先个oldChar替换到newChar。
  7. boolean startsWith(String prefix) :该String对象是或不是以prefix开首。
  8. boolean startsWith(String prefix, int toffset)
    :该String对象从toffset地方算起,是不是以prefix从前。

代码:
  String s = new String(“write once, run anywhere!”);
  String ss = new String(“write”);
  String sss = new String(“once”);
  System.out.println(“s.startsWith(ss): ” + s.startsWith(ss) );
  System.out.println(“s.startsWith(sss,6): ” + s.startsWith(sss,6) );
结果为:
s.startsWith(ss): true
s.startsWith(sss,6): true

  1. String substring(int beginIndex)
    :取从beginIndex地方上马到截止的子字符串。
    26.String substring(int beginIndex, int endIndex)
    :取从beginIndex地点上马到endIndex地方的子字符串。
  2. char[] toCharArray() :将该String对象转变来char数组。
  3. String toLowerCase() :将字符串调换到小写。
  4. String toUpperCase() :将字符串调换成大写。

代码:
  String s = new String(“java.lang.Class String”);
  System.out.println(“s.toUpperCase(): ” + s.toUpperCase() );
  System.out.println(“s.toLowerCase(): ” + s.toLowerCase() );
结果为:
s.toUpperCase(): JAVA.LANG.CLASS STRING
s.toLowerCase(): java.lang.class string

  1. static String valueOf(boolean b)
  2. static String valueOf(char c)
  3. static String valueOf(char[] data)
  4. static String valueOf(char[] data, int offset, int count)
  5. static String valueOf(double d)
  6. static String valueOf(float f)
  7. static String valueOf(int i)
  8. static String valueOf(long l)
  9. static String valueOf(Object obj)
    如上办法用于将各个差别类型调换来Java字符型。那一个都是类格局。

 

StringTokenizer类的施用方式

StringTokenizer:字符串分隔拆解解析类型
属于:java.util包。

1、构造函数。

  1. StringTokenizer(String str)
    :构造七个用来深入分析str的StringTokenizer对象。java私下认可的相间符是“空格”、“制表符(‘/t’)”、“换行符(‘/n’)”、“回车符(‘/r’)”。
  2. StringTokenizer(String str, String delim)
    :构造三个用来解析str的StringTokenizer对象,并提供二个钦定的分隔符。
  3. StringTokenizer(String str, String delim, boolean returnDelims)
    :构造多少个用来深入分析str的StringTokenizer对象,并提供三个点名的分隔符,同期,钦定是不是重返分隔符。

2、方法。
说明:

  1. 具备办法均为public;
  2. 书写格式:〔修饰符〕 <重回类型>
    <方法名(〔参数列表〕卡塔 尔(英语:State of Qatar)>
    如:
    static int parseInt(String s)
    表示:此方法(parseInt卡塔尔为类方式(static卡塔尔国,再次回到类型为(int卡塔 尔(阿拉伯语:قطر‎,方法所需参数为String类型。
  1. int countTokens()
    :重回nextToken方法被调用的次数。借使选拔构造函数1和2,重返的就是分隔符数量(例2)。
  2. boolean hasMoreTokens() :再次来到是还是不是还会有分隔符。
  3. boolean hasMoreElements() :结果同2。
  4. String nextToken() :再次来到从这两天地点到下三个分隔符的字符串。
  5. Object nextElement() :结果同4。
  6. String nextToken(String delim) :与4看似,以, 钦命的相间符重回结果。

例子:
代码:
    String s = new String(“The Java platform is the ideal platform for
network computing”);
    StringTokenizer st = new StringTokenizer(s);
    System.out.println( “Token Total: ” + st.countTokens() );
    while( st.hasMoreElements() ){
      System.out.println( st.nextToken() );
           }
结果为:
Token Total: 10
The
Java
platform
is
the
ideal
platform
for
network
computing
 

例2:
代码:
    String s = new
String(“The=Java=platform=is=the=ideal=platform=for=network=computing”);
    StringTokenizer st = new StringTokenizer(s,”=”,true);
    System.out.println( “Token Total: ” + st.countTokens() );
    while( st.hasMoreElements() ){
      System.out.println( st.nextToken() );
    }
结果为:
Token Total: 19

The

Java

platform

is

the

ideal

platform

for

network

computing
 

StringBuffer类的应用办法

StringBuffer:StringBuffer类型

呈报:在事实上行使中,日常回遇到对字符串实行动态改善。此时,String类的成效受到约束,而StringBuffer类能够做到字符串的动态增进、插入和替换等操作。

1、构造函数。

StringBuffer() :构造多个尚无别的字符的StringBuffer类。
StringBuffer(int length) :
:构造一个不曾别的字符的StringBuffer类,况且,其长度为length。
StringBuffer(String str) :以str为初阶值构造二个StringBuffer类。

2、方法。
说明:

  1. 不无办法均为public;
  2. 挥洒格式:〔修饰符〕 <重回类型>
    <方法名(〔参数列表〕卡塔 尔(英语:State of Qatar)>
    如:
    static int parseInt(String s)
    表示:此方法(parseInt卡塔尔国为类措施(static卡塔 尔(阿拉伯语:قطر‎,再次回到类型为(int卡塔 尔(阿拉伯语:قطر‎,方法所需参数为String类型。
  1. StringBuffer append(boolean b)
  2. StringBuffer append(char c)
  3. StringBuffer append(char[] str)
  4. StringBuffer append(char[] str, int offset, int len)
  5. StringBuffer append(double d)
  6. StringBuffer append(float f)
  7. StringBuffer append(int i)
  8. StringBuffer append(long l)
  9. StringBuffer append(Object obj)
  10. StringBuffer append(String str)
  11. StringBuffer append(StringBuffer sb)
    上述的主意都以向字符串缓冲区“追加”元素,然则,这么些“成分”参数能够是布尔量、字符、字符数组、双精度数、浮点数、整型数、长整型数对象类型的字符串、字符串和StringBuffer类等。假设加上的字符超过了字符串缓冲区的尺寸,Java将电动进行扩充。

代码:
    String question = new String(“1+1=”);
    int answer = 3;
    boolean result = (1+1==3);
   
    StringBuffer sb = new StringBuffer();
    sb.append(question);
    sb.append(answer);
    sb.append(‘/t’);
    sb.append(result);
   
    System.out.println(sb);
结果为:
1+1=3  false

  1. int capacity()
    :重返当前StringBuffer对象(字符串缓冲区卡塔尔的总空间,而非字符号串的尺寸。
  2. char charAt(int index)
    :在时下StringBuffer对象中取索引号为index的字符。第三个字符的目录为“0”
  3. StringBuffer delete(int start, int end)
    :删除当前StringBuffer对象中以索引号start开头,到end甘休的子串。
  4. StringBuffer deleteCharAt(int index)
    :删除当前StringBuffer对象中索引号为index的字符。
  5. void ensureCapacity(int minimumCapacity)
    :重新初始化字符号串缓冲区的总空间。假使minimumCapacity大于当前的总空间,则新的上空被安装:生机勃勃种结果是minimumCapacity;另生龙活虎种结果是{“老空间”乘2加2}。

代码:
    StringBuffer sb1 = new StringBuffer(5);
    StringBuffer sb2 = new StringBuffer(5);
   
    sb1.ensureCapacity(6);
    sb2.ensureCapacity(100);
   
    System.out.println( “sb1.Capacity: ” + sb1.capacity() );
    System.out.println( “sb2.Capacity: ” + sb2.capacity() );
结果为:
sb1.Capacity: 12
sb2.Capacity: 100

  1. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
    :从当下StringBuffer对象的索引号srcBegin发轫,到srcEnd停止的子串,赋值到字符数组dst中,何况从dst的索引号dstBegin开首。

代码:
    StringBuffer sb = new StringBuffer(“I love her!”);
    char[] i = {‘I’,’ ‘,’l’,’o’,’v’,’e’,’ ‘,’y’,’o’,’u’};
   
    sb.getChars(7,10,i,7);
   
    System.out.println( “sb: ” + sb );
结果为:sb: I love her!

  1. int indexOf(String str)
    :重返当前StringBuffer对象中,第叁个满意str子串的岗位。
  2. int indexOf(String str, int fromIndex)
    :从日前StringBuffer对象的fromIndex起头查找,再次回到第三个满意str子串的岗位。
  3. StringBuffer insert(int offset, boolean b)
  4. StringBuffer insert(int offset, char c)
  5. StringBuffer insert(int offset, char[] str)
  6. StringBuffer insert(int index, char[] str, int offset, int len)
  7. StringBuffer insert(int offset, double d)
  8. StringBuffer insert(int offset, float f)
  9. StringBuffer insert(int offset, int i)
  10. StringBuffer insert(int offset, long l)
  11. StringBuffer insert(int offset, Object obj)
  12. StringBuffer insert(int offset, String str)
    以上的法子都以在当前StringBuffer对象中插入贰个要素,在索引号offset处插入相应的值。
  13. int lastIndexOf(String str)
    :重返当前StringBuffer对象中,最后三个满足str子串的职位。
  14. int lastIndexOf(String str, int fromIndex)
    :从脚下StringBuffer对象的fromIndex开首查找,再次来到最终两个知足str子串的地点。
  15. int length()
    :重回当前StringBuffer对象(字符缓冲区卡塔尔中,字符串的尺寸。注意:此措施与capacity()
    分化。
  16. StringBuffer replace(int start, int end, String str)
    :替换当前StringBuffer对象的字符串。从start起先,到end结束的职位替换到str。
  17. StringBuffer reverse() :将字符串翻转。

代码:
    StringBuffer sb = new StringBuffer(“0123456789”);
    System.out.println( “sb.reverse(): ” + sb.reverse() );
结果为:sb.reverse(): 9876543210

  1. void setCharAt(int index, char ch) :设置索引号index的字符为ch。
  2. void setLength(int newLength)
    :重新恢复生机设置字符串缓冲区中字符串的长短,若是newLength小于当前的字符串长度,将截去多余的字符。

代码:
    StringBuffer sb = new StringBuffer(“0123456789”);
    sb.setLength(5);
    System.out.println( “sb: ” + sb );
结果为:sb: 01234

  1. String substring(int start)
    :取当前StringBuffer对象中,从start早先到终极的子串。
  2. String substring(int start, int end)
    :取当前StringBuffer对象中,从start开始到end的子串。
  3. String toString() :将目前StringBuffer对象调换到String对象。

 

Random类的运用办法。

属于包:java.util.Random

Random:随机类型

1、属性。

无。

2、构造函数。

Random() :创造一个新的私自数产生器。

Random(long seed) :用贰个种子(长整型卡塔尔创造叁个随便数产生器。

3、方法。
说明:

  1. 负有办法均为public;
  2. 书写格式:〔修饰符〕 <再次来到类型>
    <方法名(〔参数列表〕卡塔 尔(英语:State of Qatar)>
    如:
    static int parseInt(String s)
    表示:此措施(parseInt卡塔尔为类措施(static卡塔尔,再次来到类型为(int卡塔尔,方法所需参数为String类型。

 

  1. protected int next(int bits) :发生下一个伪随机数。

  2. boolean nextBoolean()
    :再次回到下几个从随机发生器的生机勃勃类别中获得的均匀分布的布尔值。

  3. void nextBytes(byte[] bytes) :产生随机字节数组放到钦点的数组中。

  4. double nextDouble()
    :重临下几个从随机发生器的文山会海中赢得的均匀布满的0.0到1.0的双精度类型值。

  5. float nextFloat()
    :再次回到下贰个从随机爆发器的多元中获得的均匀布满的0.0到1.0的浮点类型值。

  6. double nextGaussian()
    :再次来到下贰个从随机产生器的不胜枚举中得到的相符均匀布满的0.0的平平均数量到1.0方差的高斯布满双精度类型值。

  7. int nextInt()
    :重回下三个从随机爆发器的多级中拿走的均匀布满的整型值。

  8. int nextInt(int n)
    :重临下二个从随机发生器的风华正茂体系中获取的均匀分布的0到钦定整型数(n卡塔尔之间的整型值。

  9. long nextLong()
    :再次回到下一个从随机发生器的多如牛毛中得到的均匀布满的长整型值。

  10. void setSeed(long seed) :设置随机数发生器的种子为多个长整型数。

有关种子的叙说:
本条类的对象使用一个肆二十人的种子,
万大器晚成那些类的五个实例是用同三个种子成立的,
再者,各自对它们以同等的顺序调用方法,
则它们会产生相仿的数字连串。

上面就对下面的介绍做八个实验,
更是引人瞩目相像种猪时的结果,
举例用默许的构造函数构造对象,
他们是归于同一个种子的。

代码:
import java.util.Random;

public class TestRandom{
  public static void main(String[] args){
    Random r1 = new Random(50);
    System.out.println(“第三个种子为50的Random对象”);
    System.out.println(“r1.nextBoolean():/t” + r1.nextBoolean());
    System.out.println(“r1.nextInt():/t/t” + r1.nextInt());
    System.out.println(“r1.nextDouble():/t” + r1.nextDouble());
    System.out.println(“r1.nextGaussian():/t” + r1.nextGaussian());
    System.out.println(“—————————“);
   
    Random r2 = new Random(50);
    System.out.println(“首个种子为50的Random对象”);
    System.out.println(“r2.nextBoolean():/t” + r2.nextBoolean());
    System.out.println(“r2.nextInt():/t/t” + r2.nextInt());
    System.out.println(“r2.nextDouble():/t” + r2.nextDouble());
    System.out.println(“r2.nextGaussian():/t” + r2.nextGaussian());
    System.out.println(“—————————“);
   
    Random r3 = new Random(100);
    System.out.println(“种子为100的Random对象”);
    System.out.println(“r3.nextBoolean():/t” + r3.nextBoolean());
    System.out.println(“r3.nextInt():/t/t” + r3.nextInt());
    System.out.println(“r3.nextDouble():/t” + r3.nextDouble());
    System.out.println(“r3.nextGaussian():/t” + r3.nextGaussian());
   
    System.out.println(“结果一望而知!”);
  }
}

结果:
代码:

首先个种子为50的Random对象
r1.nextBoolean():    true
r1.nextInt():       -1727040520
r1.nextDouble():    0.6141579720626675

r1.nextGaussian():   2.377650302287946

第叁个种子为50的Random对象
r2.nextBoolean():    true
r2.nextInt():       -1727040520
r2.nextDouble():    0.6141579720626675

r2.nextGaussian():   2.377650302287946

种子为100的Random对象
r3.nextBoolean():    true
r3.nextInt():       -1139614796
r3.nextDouble():    0.19497605734770518
r3.nextGaussian():   0.6762208162903859
结果不在话下!

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注