java字符串常用方法大全一篇足矣

最新推荐文章于 2023-11-23 12:38:05 发布

长大的一哲

最新推荐文章于 2023-11-23 12:38:05 发布

阅读量723

点赞数

文章标签： java 正则表达式

本文链接：https://blog.csdn.net/weixin_45717072/article/details/116334410

版权

一、字符串的内存图

1、String类的位置：java.lang.String
2、String表示字符串类型，属于引用数据类型，不属于基本数据类型
3、Java中规定，双引号括起来的字符串是不可变的，如字符串"as300"从出生到死亡不会变，不能变成"as3000"，字符串一旦创建不可变。
4、双引号括起来的字符串是存储在"方法区"的"字符串常量池"当中，
因为字符串在实际的开发中使用很频繁，为了提高执行效率，所以将字符串存储在方法区的字符串常量池当中。

package Test;
public class StringTest01 {
    public static void main(String[] args) {
        //以下两行代码创建了三个字符串对象
        String str1 = "dfh";
        String str2 = "dhf"+"var";

        //使用new的方式创建字符串对象
        String str3 = new String("var");
    }
}

package Test;

public class User {
    int id;
    String name;

    public User() {
    }

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


package Test;

public class UserTest {
    public static void main(String[] args) {
        User u = new User(111,"袁世凯");

    }
}

package Test;

public class StringTest03 {
    public static void main(String[] args) {

        String s1 = "java";
        //该句中的字符串"java"已经在字符串常量池中存在了，所以不会新建
        String s2 = "java";

        String s3 = new String("java");
        String s4 = new String("java");

        //双等号比较的是变量中保存的内存地址
        System.out.println(s1==s2);//true
        System.out.println(s3==s4);//false

        //String类重写Object类的equals方法
        System.out.println(s3.equals(s4));//true
    }
}

二、字符串的创建

1、String对象的实例化的方式：

方式一：用双引号括起来实例化String对象

如:

"bgp200"

方式二：通过String类的构造方法：public String(String str) 实例化String对象，

如:

new String("ip address");

方式三：通过String类的构造方法：public String(byte[] bytes) 实例化String对象，

如:

byte[] bytes = {97,98,99,100} * new String(bytes);

方式四：通过String类的构造方法：public String(byte[] bytes,int offset,int length) 实例化String对象，

如 :

byte[] bytes = {97,98,99,100,101}

new String(bytes,1,3);

方式五：通过String类的构造方法：public String(byte[] bytes,String charset) 实例化String对象

如：

byte[] bytes02 = {-42 ,-48, -71 ,-6 ,-56, -53}; *

String str = new String(bytes02,"GBK");

System.out.println(str);//中国人

方式六：通过String类的构造方法：public String(byte[] bytes,int offset,int length,String charset) 实例化String对象

如：

byte[] bytes02 = {-42 ,-48, -71 ,-6 ,-56, -53};

String str = new String(bytes02,0,4,"GBK");

System.out.println(str);//中国

方式七：通过String类的构造方法：public String(char[] value) 实例化String对象

方式八：通过String类的构造方法：public String(char[] value,int offset,int count) 实例化String对象

如：

char[] chars = {',','/','中','\\','?','z','4'};

String str = new String(chars);

System.out.println(str);// ,/中\?z4 */

package Test;

import java.io.UnsupportedEncodingException;

public class StringTest02 {
    public static void main(String[] args) throws UnsupportedEncodingException {

        //用双引号括起来实例化String对象
        String str1 = "dfh";

        //通过String类的构造方法：public String(String str) 实例化String对象
        String str2 = new String("var");
        System.out.println(str2);

        //通过String类的构造方法：public String(byte[] bytes) 实例化String对象
        byte[] bytes = {97,98,99,100,101};
        String str3 = new String(bytes);
        System.out.println(str3);//abcde

        //通过String类的构造方法：public String(byte[] bytes,int offset,int length) 实例化String对象
        String str4 = new String(bytes,1,2);
        System.out.println(str4);//bc

        byte[] bytes01 = "中国人".getBytes("GBK");
        for (int i = 0;i<bytes01.length;i++) {
            if (i == bytes01.length-1){
                System.out.println(bytes01[i]);
                break;
            }
            System.out.print(bytes01[i]+" ");
        }

        //通过String类的构造方法：public String(byte[] bytes,String charset) 实例化String对象
        byte[] bytes02 = {-42 ,-48, -71 ,-6 ,-56, -53};
        String str5 = new String(bytes02,"GBK");
        System.out.println(str5);//中国人

        //通过String类的构造方法：public String(byte[] bytes,int offset,int length,String charset) 实例化String对象
        String str6 = new String(bytes02,0,4,"GBK");
        System.out.println(str6);//中国

        //通过String类的构造方法：public String(char[] value) 实例化String对象
        char[] chars = {',','/','中','\\','?','z','4'};
        String str7 = new String(chars);
        System.out.println(str7);// ,/中\?z4

        //通过String类的构造方法：public String(char[] value,int offset,int count) 实例化String对象
        char[] chars01 = {'程','序','员','都','会','有','美','丽','的','女','朋','友'};
        String str8 = new String(chars01,6,2);
        System.out.println(str8);//美丽

    }
}

三、面试题

package Test;
//面试题：分析以下程序一共创建了几个对象？
public class StringTest04 {
    public static void main(String[] args) {
        //以下程序一共创建了三个对象：堆内存中两个+方法区的字符串常量池中一个
        String s1 = new String("java");
        String s2 = new String("java");
    }
}

四、字符串与字符

1、public char charAt(int index)
    返回字符串指定索引处的char值(索引从0开始)
2、public char[] toCharArray()
    将字符串中的数据以字符数组的形式返回

package Test;
public class StringTest05 {
    public static void main(String[] args) {
        //测试charAt(int index)
        String str1 = "明月几时有，把酒问青天";
        System.out.println(str1.charAt(2));//几

        //测试toCharArray()
        String str2 = "sdhj233sdjfh43852_d9rfs.html";
        char[] chars = str2.toCharArray();
        String log_id = "";
        for (int i = 0; i < chars.length ; i++) {
            if (chars[i]>='0' && chars[i]<='9'){
              log_id += chars[i];
            }else {
                continue;
            }
        }
        System.out.print(log_id+'\n');//233438529
    }
}

五、字符串与字节

1、public byte[] getBytes()
     将字符串转变为字符数组
2、public byte[] getBytes(String charsetName) throws UnsupportedEncodingException
    将字符串转变为指定字符集的byte序列
3、public String(byte[] bytes,String charsetName)
     把全部字节数组按指定字符集转变为字符串
 关于以上方法的说明：
     1、getBytes(String charsetName)和 String(byte[] bytes,String charsetName)要
       抛出UnsupportedEncodingException异常
     2、getBytes(String charsetName)将返回操作系统默认的编码格式的字符串，如果程序能在
        Windows上运行但部署到mac或者Linux上可能存在乱码的问题。
     3、String(byte[] bytes,String charsetName)与getBytes(String charsetName)相对应，
        可以用String(byte[] bytes,String charsetName)来还原字符串，将字符数组解析成指定
        编码的字符串。
     4、如下代码的中的例子说明：
         一个字符在每种字符编码中占的字节数：
            字符集      中文字符占的字节数    英文字符占的字节数
             GBK             2个字节             1个字节
             utf-8           3个字节             1个字节
           iso8859-1        没有中文字符         1个字节
      综上，所以
               1)字符串"hi,中国"用GBK字符集转变成字符数组的长度为：7 = 1+1+1+2*2
               2)字符串"hi,中国"用utf-8字符集转变成字符数组的长度为：9 = 1+1+1+2*3
               3)字符串"hi,中国"用iso8859-1字符集转变成字符数组的长度为：5 = 1+1+1+1+1，
                 因为ISO8859-1的编码格式将中文解析成了 63，ASCII中63为？，所以用
                 new String(byte_ISO,"iso8859-1")来还原字符串"hi,中国"为"hi,??"

package Test;

import java.io.UnsupportedEncodingException;
import java.util.Scanner;
public class StringTest06 {
    public static void main(String[] args) throws UnsupportedEncodingException {

        //测试public byte[] getBytes(String charsetName)
        byte[] byte_gbk = "hi,中国".getBytes("GBK");
        traversal(byte_gbk);// 104 105 44 -42 -48 -71 -6
        System.out.println(byte_gbk.length);// 7

        byte[] byte_utf = "hi,中国".getBytes("utf-8");
        traversal(byte_utf);// 104 105 44 -28 -72 -83 -27 -101 -67
        System.out.println(byte_utf.length);// 9

        byte[] byte_ISO = "hi,中国".getBytes("iso8859-1");
        traversal(byte_ISO);// 104 105 44 63 63
        System.out.println(byte_ISO.length);// 5

        //测试public String(byte[] bytes)
        String bytes_to_String1 = new String(byte_gbk,"GBK");
        System.out.println(bytes_to_String1);// hi,中国

        String bytes_to_String2 = new String(byte_utf,"utf-8");
        System.out.println(bytes_to_String2);// hi,中国

        String bytes_to_String3 = new String(byte_ISO,"iso8859-1");
        System.out.println(bytes_to_String3);// hi,??

        //以下程序是getBytes()方法的应用
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请输入：");
            String str = sc.next();
            int ret = input_check(str);
            if(0 == ret){
                break;
            }else{
                continue;
            }
        }
    }

    public static void traversal(byte[] arr){
        for (int i = 0; i < arr.length ; i++) {
            if(i == (arr.length-1)){
                System.out.println(arr[i]);
                break;
            }
            System.out.print(arr[i]+" ");
        }
    }

    public static int input_check(String str){
        byte[] bytes = str.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            if (bytes[0]>90||bytes[0]<65){
                System.out.println("您的输入不正确，首字母必须大写");
                return 1;
            }
            if (bytes[i]>122||bytes[i]<48 || bytes[i]>57&&bytes[i]<65 || bytes[i]>90&&bytes[i]<97){
                System.out.println("您的输入非法，输入必须为字符和数字");
                return 1;
            }
        }
        return 0;
    }
}

六、字符串比较

1、public boolean equals(String anObject)
     区分大小写的相等判断
2、public boolean equalsIgnoreCase(String anotherString)
     不区分大小写比较
3、public int compareTo(String anotherString)
     按字典顺序比较两个字符串,它从第一位开始比较，如果遇到不同的字符，
     则马上返回这两个字符的ascii值的差值，返回值是int类型。
       返回值           比较结果
         >0            前大后小
         =0            相等
         <0           前小后大
4、public int compareToIgnoreCase(String str)
     不区分大小写进行字符串大小的比较

package Test;

public class StringTest07 {
    public static void main(String[] args) {

        //测试 equals(String anObject)
        String str1 = "中国";
        boolean flag1 = "中国".equals(str1);
        System.out.println(flag1?"两字符串相等":"两字符串不相等");//两字符串相等

        String str2 = new String("中国");
        boolean flag2 = "中国".equals(str2);
        System.out.println(flag2?"两字符串相等":"两字符串不相等");//两字符串相等

        //测试 equalsIgnoreCase(String anotherString)
        String str3 = "sdf";
        String str4 = "SDF";
        System.out.println(str3.equals(str4));//false
        System.out.println(str3.equalsIgnoreCase(str4));//true

        //测试compareTo(String anotherString)
        /*
          1、当比较的字符串是英文且长度不等时
            1)长度短的字符串与长度长的字符串的相对应的字符一样，则返回的结果是两个长度相减(前-后)的值
               String str5 = "good";
               String str6 = "go";
               System.out.println(str5.compareTo(str6));//2
            2) 长度不一样且相对应的字符也不一样，从第一位开始找，当找到不一样的字符时，则返回的值是这两个
                字符比较的值。
                String str8 = "good";
                String str9 = "god";
                System.out.println(str8.compareTo(str9));// 11 = 111(o的ascii值) - 100(d的ascii值)
          2、当比较的字符串是英文且长度相等时
            1)长度为1的字符串的比较,返回单个字符ascii码的差值
                String str10 = "d";
                String str11 = "o";
                System.out.println(str11.compareTo(str10));// 11 = 111(o的ascii值) - 100(d的ascii值)
            2)长度大于1的字符串的比较，从第一位开始找，当找到不一样的字符时，则返回的值是这两个字符比较的值
                String str12 = "god";
                String str13 = "goo";
                System.out.println(str12.compareTo(str13));// -11 = 100(o的ascii值) - 111(d的ascii值)
         */
        String str5 = "good";
        String str6 = "go";
        String str7 = "goodlanguage";
        System.out.println(str5.compareTo(str6));// 2 = 4 -2
        System.out.println(str5.compareTo(str7));// -8 = 4 - 12
        System.out.println(str7.compareTo(str5));//8 = 12 - 4

        String str8 = "good";
        String str9 = "god";
        System.out.println(str8.compareTo(str9));// 11 = 111(o的ascii值) - 100(d的ascii值)
        System.out.println(str9.compareTo(str8));// -11 = 100(d的ascii值) - 111(o的ascii值)

        String str10 = "d";
        String str11 = "o";
        System.out.println(str11.compareTo(str10));// 11 = 111(o的ascii值) - 100(d的ascii值)

        String str12 = "god";
        String str13 = "goo";
        System.out.println(str12.compareTo(str13));// -11 = 100(o的ascii值) - 111(d的ascii值)

        //测试compareToIgnoreCase(String str)
        String str14 = "aD";
        String str15 = "ao";
        System.out.println(str14.compareToIgnoreCase(str15));//-11

        String str16 = "Ad";
        String str17 = "aD";
        System.out.println(str16.compareToIgnoreCase(str17));//0
    }
}

七、字符串查找

1、public boolean contains(String s)
      判断子字符串是否存在
2、public int indexOf(String str)
      从左向右查找指定字符串的位置，找不到返回-1
3、public int indexOf(String str,int fromIndex)
      从指定位置从左向右查找指定字符串的位置，找不到返回-1
4、public int lastIndexOf(String str)
      从后向前查找指定字符串的位置，找不到返回-1
5、public int lastIndexOf(String str,int fromIndex)
      从指定位置从后向前查找指定字符串的位置，找不到返回-1
6、public boolean startsWith(String prefix)
      判断是否以指定的字符串开头
7、public boolean startsWith(String prefix,int toffset)
      从指定位置判断是否以指定的字符串开头
8、public boolean endsWith(String prefix)
         判断是否以指定的字符串结尾

package Test;

public class StringTest08 {
    public static void main(String[] args) {
        String[] str = {"jh1s.ja1.265","gd@sha@2569fjk@ds","@@test##javademo!!","pythontestdemo"};

        //测试contains(String s)
        System.out.println("中国上海浦东".contains("浦西"));//false
        System.out.println("中国上海浦东".contains("浦东"));//true

        //测试indexOf(String str)
        int ret1 = str[0].indexOf("java");
        int ret2 = str[0].indexOf(".");
        System.out.println(ret1>=0?"查找的字串存在":"查找的字串不存在，返回值为："+ret1);//查找的字串不存在，返回值为：-1
        System.out.println(ret2>=0?"查找的字串存在,返回值为："+ret2:"查找的字串不存在");//查找的字串存在,返回值为：3

        //测试indexOf(String str,int fromIndex)
        int ret3 = str[1].indexOf("@",3);
        System.out.println(ret3>=0?"查找的字串存在,返回值为："+ret3:"查找的字串不存在");//查找的字串存在,返回值为：6

        //测试lastIndexOf(String str)
        int ret4 = str[0].lastIndexOf(".");
        System.out.println(ret4>=0?"查找的字串存在,返回值为："+ret4:"查找的字串不存在");//查找的字串存在,返回值为：7

        //测试lastIndexOf(String str,int fromIndex)
        int ret5 = str[1].lastIndexOf("@");
        System.out.println(ret5>=0?"查找的字串存在,返回值为："+ret5:"查找的字串不存在");
        int ret6 = str[1].lastIndexOf("@",6);
        System.out.println(ret6>=0?"查找的字串存在,返回值为："+ret6:"查找的字串不存在");//查找的字串存在,返回值为：6

        //测试startsWith(String prefix)
        boolean ret7 = str[2].startsWith("@@");
        System.out.println("判断是否以@@开头? "+ ret7);

        //测试startsWith(String prefix,int toffset)
        boolean ret8 = str[2].startsWith("##",6);
        System.out.println("判断指定位置是否以##开头? "+ ret8);

        //测试endsWith(String prefix)
        boolean ret9 = str[2].endsWith("!!");
        System.out.println("判断是否以!!结尾? "+ ret9);
    }
}

八、字符串替换

1、public String replace(CharSequence target, CharSequence replacement)
        将目标字符序列替换成第二个参数位置上的字符序列，返回新的字符串，不支持正则
2、public String replaceAll(String regex,String replacement)
        将目标字符子串或者符合正则的子串，替换成第二个参数位置上的字符序列，返回新的字符串，支持正则
3、public String replaceFirst(String regex,String replacement)
        将目标字符子串或者匹配正则的第一个符合条件的子串，替换成第二个参数位置上的字符序列，返回新的字符串，支持正则

package Test;

public class StringTest09 {
    public static void main(String[] args) {

        String str = "中国:南京:雨花台区";
        //测试replace(CharSequence target, CharSequence replacement)
        System.out.println(str.replace(":",","));//中国,南京,雨花台区

        //测试replaceAll(String regex,String replacement)
        String new_str = str.replaceAll(":","|");
        System.out.println(new_str);//中国|南京|雨花台区

        //删除非字母与数字
        String str1 = "dhsj2F65#4%*(.FDksLDS/】、‘。oo";
        String regex ="[^a-zA-Z0-9]";
        System.out.println(str1.replaceAll(regex, ""));//dhsj2F654FDksLDSoo

        //将手机号中间四位替换成*
        String str2 = "18723490456";
        String regex1   = "(\\d{3})(\\d{4})(\\d{4})";
        System.out.println(str2.replaceAll(regex1, "$1****$3"));//187****0456

        //测试replaceFirst(String regex,String replacement)
        /*
            将源字符串中的反斜杠替换成正斜杠
            注意在java中 \\表示反斜杠
         */
        String str3 = "12\\dgh3\\4jdj\\a2";
        String regex2 = "\\\\";
        System.out.println(str3.replaceFirst(regex2, "/"));// 12/dgh3\4jdj\a2

    }
}

九、字符串拆分

1、public String[] split(String regex)
     按照指定的字符串进行全部拆分，返回字符串数组
2、public String[] split(String regex, int 
     按照指定的字符串进行部分拆分，最后返回的数组长度由limit决定

package Test;

public class StringTest10 {
    public static void main(String[] args) {
        //按: 拆分
        String str1 = "中国:南京:雨花台区";
        String[] arr1 = str1.split(":");
        traversal(arr1);//中国、南京、雨花台区

        //把字符串拆成单个
        String str2 = "12345678901234567890322322";
        String[] arr2 = str2.split("");
        traversal(arr2);//1、2、3、4、5、6、7、8、9、0、1、2、3、4、5、6、7、8、9、0、3、2、2、3、2、2

        //把字符串按.号拆分
        String str3 = "192.34.56.8";
        String[] arr3 = str3.split("\\.");
        traversal(arr3);//192、34、56、8

        //字符串进行二次拆分
        String str4 = "语文=87|数学=99|英语=95|物理=100";
        String[] arr4 = str4.split("\\|");
        traversal(arr4);//语文=87、数学=99、英语=95、物理=100
        for (int i = 0; i <arr4.length ; i++) {
            String[] temp = arr4[i].split("=");
            if (i==arr4.length-1){
                System.out.println(temp[0]+"、"+temp[1]);
                break;
            }
            System.out.print(temp[0]+"、"+temp[1]+"、");
        }//语文、87、数学、99、英语、95、物理、100

        //限制拆分长度，按照数字进行拆分
        String str5 = "sdk23fdjh5kdfh23d2n4m23";
        String[] arr5 = str5.split("\\d+");
        traversal(arr5);//不指定长度拆分结果：sdk、fdjh、kdfh、d、n、m
        String[] arr6 = str5.split("\\d+",3);
        traversal(arr6);//指定长度拆分结果：sdk、fdjh、kdfh23d2n4m23

    }

    public static void traversal(String[] arr){
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length-1) {
                System.out.println(arr[i]);
                return;
            }
            System.out.print(arr[i]+"、");
        }
    }
}

十、字符串截取

1、public String substring(int beginIndex)
        从指定索引处截取到末尾(包含索引处)
2、public String substring(int beginIndex, int endIndex)
        截取指定索引范围中的子字符串(左闭右开)

public class StringTest11 {
    public static void main(String[] args) {
        //测试substring(int beginIndex)
        String str1 = "中国:南京:雨花台区";
        System.out.println(str1.substring(3));//南京:雨花台区

        //测试substring(int beginIndex, int endIndex)
        //将手机号中间四位替换成*的另一种实现
        String str2 = "18734560988";
        String sub_str1 = str2.substring(0,3);
        String sub_str2 = str2.substring(7);
        System.out.println(sub_str1+"****"+sub_str2);//187****0988
    }
}

十一、字符串的其他操作

（一）字符串的连接：
     1、public String contact(String str)
     2、+  eg: "a"+1
（二）判断字符串是否为空：
     1、public boolean isEmpty()
（三）计算字符串的长度：
     1、public int length()
（四）去除左右空格：
     1、public String trim()
（五）字符串的内容转大小写：
     1、public String toUpperCase()
         字符串内容转大写
     2、public String toLowerCase()
         字符串内容转小写

package Test;

public class StringTest12 {
    public static void main(String[] args) {

        //字符串的连接
        String str1 = "中国";
        String str2 = "上海";
        String str3 = str1.concat(str2);
        String str4 = str1+str2;
        System.out.println(str3);//中国上海
        System.out.println(str4);//中国上海

        //判断字符串是否为空
        String str5 = "";
        System.out.println(str5.isEmpty());//true
        System.out.println(str5.length()==0?"字符串为空":"字符串不为空");//字符串为空

        //计算字符串的长度
        //注意计算数组的长度是获取数组的属性length属性，计算字符串的长度是在调用字符串类的length()方法
        System.out.println(str4.length());//4

        //去除左右空格
        String str6 = "  java  test   ";
        System.out.println("去除前后空格之前的长度："+str6.length());//去除前后空格之前的长度：15
        String str7 = str6.trim();
        System.out.println("去除前后空格之后的长度："+str7.length());//去除前后空格之后的长度：10
        System.out.println(str7);//java  test
    }
}

十二、其他数据类型转换为字符串

（一）将基本数据类型为字符串：
    1、 public static String valueOf()
    2、可以采用 ""+ 基本数据类型的数据 的方式转为字符串
（二）将引用数据类型转化为字符串
     public static String valueOf(Object ob
     【注意】
         将引用数据类型转化为字符串其实是该对象的toString方法

package Test;

public class StringTest13 {
    public static void main(String[] args) {
        //将基本数据类型转化为字符串
        //采用 public static String valueOf()
        System.out.println(String.valueOf(12));

        System.out.println(String.valueOf('中'));

        System.out.println(String.valueOf(true));

        System.out.println(String.valueOf(1.2));

        //采用 ""+ 基本数据类型的数据 的方式
        System.out.println(""+100);

        String str = ""+true;
        System.out.println(str);

        //将引用数据类型转化为字符串
        System.out.println(String.valueOf(new Student(111)));//Student{id=111}
    }
}

class Student{
    private int id;

    public Student(){

    }

    public Student(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                '}';
    }
}

十三、字符串格式化

1、 public static String format(String format, Object... args)
        新字符串使用本地语言环境，指定字符串格式和参数生成格式化的新字符串
2、 public static String format(Locale l, String format, Object... args)
        新字符使用指定的语言环境，指定字符串格式和参数生成格式化的新字符串

package Test;

import java.util.Date;

public class StringTest14 {
    public static void main(String[] args) {
        //常规类型的格式化
        System.out.println(String.format("%s %s %s","ac","中国","xy"));//ac 中国 xy
        System.out.println(String.format("%s%s%s","ac","bd","xy"));//acbdxy
        System.out.println(String.format("%c %b %d %x %o",'t',true,23,0xA1,56));//t true 23 a1 70
        System.out.println(String.format("%.2f",23.0));//23.00
        System.out.printf("%.3f %n",3.14159,'\n');//3.142
        System.out.printf("%e %n",3.12e+5,'\n');//3.120000e+05
        System.out.println(String.format("%04d",11));//0011
        System.out.println(String.format("%+d",24));//+24
        System.out.println(String.format("%4d",24));//  24
        System.out.println(String.format("%,f",34234.45));//34,234.450000

        //常见的时间日期格式化
        System.out.printf("%tc%n",new Date());
        System.out.printf("%tF%n",new Date());
        System.out.printf("%tD%n",new Date());
        System.out.printf("%tr%n",new Date());
        System.out.printf("%tT%n",new Date());
        System.out.printf("%tR%n",new Date());
        System.out.printf("%tB%n",new Date());
        System.out.printf("%tj%n",new Date());
    }
}

长大的一哲

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
java字符串常用方法大全一篇足矣

一、字符串的内存图1、String类的位置：java.lang.String2、String表示字符串类型，属于引用数据类型，不属于基本数据类型3、Java中规定，双引号括起来的字符串是不可变的，如字符串"as300"从出生到死亡不会变，不能变成"as3000"，字符串一旦创建不可变。4、双引号括起来的字符串是存储在"方法区"的"字符串常量池"当中，因为字符串在实际的开发中使用很频繁，为了提高执行效率，所以将字符串存储在方法区的字符串常量池当中。package Test;pu...
复制链接

扫一扫