Java笔记（5）-String、StringBuffer、StringTokenizer、Date、Calendar

最新推荐文章于 2024-01-18 03:00:00 发布

伍Wu哈Ha

最新推荐文章于 2024-01-18 03:00:00 发布

阅读量1.3k

点赞数 1

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/Peng_Hong_fu/article/details/52575929

版权

Java 专栏收录该内容

36 篇文章 5 订阅

订阅专栏

浮云一别后，流水十年间。—–韦应物《淮上喜会梁川故人 / 淮上喜会梁州故人》

String类

构造字符串对象

Java专门提供了处理字符串的String类，在java.lang包中默认引入，为final类

public class Main {
    public static void main(String[] args) {
        //常量对象
        String s1 = "你好";
        String s2 = "12.89";
        System.out.println(""+s1+" "+s2);

        //字符串对象
        String s3;
        s3 = new String("we are family");
        System.out.println(" "+s3);
        //String tom =String(s3);

        //效果同上
        char a[] = {'j','a','v','a'};
        String s4 = new String(a);
        System.out.println(" "+s4);

        char b[] = {'零','壹','贰','叁','肆','伍'};
        String s5 = new String(b,2,4);
        System.out.println(" "+s5);
        //String s = new String("贰叁肆伍");

        //字符串常量是对象，字符串的引用赋值给一个字符串变量
        //在内存中s6,s7都指向堆中的how are you
        String s6,s7;
        s6 = "how are you";
        s7 = "how are you";
        System.out.println(" "+s6+"  "+s7);

    }
}

你好 12.89
 we are family
 java
 贰叁肆伍
 how are you  how are you

String常用方法

public class StringMethod {
    public static void main(String[] args) {
        int n1, n2;
        String china = "我爱中国10";
        n1 = china.length();
        n2 = "字母abc".length();
        System.out.println("n1:" + n1 + "\nn2:" + n2);// 6 5

        String tom = new String("天道酬勤");
        String boy = new String("知心朋友");
        String jerry = new String("天道酬勤");
        System.out.println("" + tom.equals(boy));//false
        System.out.println("" + tom.equals(jerry));//true
        System.out.println(tom == jerry);//false

        String s3, s4;
        s3 = "胖子";
        s4 = "胖子";
        System.out.println(s3 == s4);//true

        String weather = "天气预报,阴有小雨";
        String result = "比赛结果,中国队获胜";
        weather.startsWith("天气");
        result.endsWith("获胜");
        System.out.println("  " + weather.startsWith("天气"));//true
        System.out.println("  " + result.endsWith("获胜"));//true

    }
}

public int compareTo(String s) 按字典序与参数s指定的字符串比较大小

    String str = "abcde";
    System.out.println(str.compareTo("boy"));//-1
    System.out.println(str.compareTo("eoy"));//-4
    System.out.println(str.compareTo("abcde"));//0
    System.out.println(str.compareTo("aba"));//2

public boolean contains(String s) 是否含有指定的字符串

    String str1 = "student";
    System.out.println(str1.contains("stu"));//true
    System.out.println(str1.contains("sdu"));//true

public int indexOf(String s) 字符串索引

    String str2 = "I am a good cat";
    System.out.println(str2.indexOf("a"));//2
    System.out.println(str2.indexOf("o"));//8
    System.out.println(str2.indexOf("good",2));//7 从2处开始查
    System.out.println(str2.indexOf("u"));//-1 没有检索到
    System.out.println(str2.indexOf("a",7));//13

public String substring(int startpoint) 获取当前字符串的子串

    String str3 = "我爱吃西瓜";
    System.out.println(str3.substring(1, 3));//爱吃

public String trim() 去掉前后空格

    String str4 = "   I am a good boy";
    System.out.println(str4);//   I am a good boy
    System.out.println(str4.trim());//I am a good boy

SN(序号)	方法描述
1	char charAt(int index) 返回指定索引处的 char 值。
2	int compareTo(Object o) 把这个字符串和另一个对象比较。
3	int compareTo(String anotherString) 按字典顺序比较两个字符串。
4	int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。
5	String concat(String str) 将指定字符串连接到此字符串的结尾。
6	boolean contentEquals(StringBuffer sb) 当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。
7	static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String。
8	static String copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String。
9	boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
10	boolean equals(Object anObject) 将此字符串与指定的对象比较。
11	boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。
12	byte[] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
13	byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
14	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。
15	int hashCode() 返回此字符串的哈希码。
16	int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
17	int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
18	int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。
19	int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
20	String intern() 返回字符串对象的规范化表示形式。
21	int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
22	int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
23	int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
24	int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
25	int length() 返回此字符串的长度。
26	boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
27	boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
28	boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
29	String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
30	String replaceAll(String regex, String replacement 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
31	String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
32	String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
33	String[] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。
34	boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
35	boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36	CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列，它是此序列的一个子序列。
37	String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
38	String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。
39	char[] toCharArray() 将此字符串转换为一个新的字符数组。
40	String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
41	String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
42	String toString() 返回此对象本身（它已经是一个字符串！）。
43	String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
44	String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
45	String trim() 返回字符串的副本，忽略前导空白和尾部空白。
46	static String valueOf(primitive data type x) 返回给定data type类型x参数的字符串表示形式。

字符串与基本类型的转换

java.lang包中的Interger类调用此类方法

public static int parseInt(String s)

转换为基本数据类型

       //"数字"字符 转为int型数据
    String str5 = "966";
    String str6 = "127";//-128-127
    int x;
    x = Integer.parseInt(str5);
    System.out.println(x);

    long x1 = Long.parseLong(str5);
    Short x2 = Short.parseShort(str5);
    Float x3 = Float.parseFloat(str5);
    Double x4 =Double.parseDouble(str5);
    Byte x5 = Byte.parseByte(str6);
    System.out.println(x1+" "+x2+" "+x3+" "+x4+" "+x5);
    //966
    //966 966 966.0 966.0 127

基本类型转换为字符串

    String str7 = String.valueOf(12);
    System.out.println(str7);

    public static String vaueOf(byte n);
    public static String vaueOf(int n);
    public static String vaueOf(long n);
    public static String vaueOf(float n);
    public static String vaueOf(double n);

对象的字符串表示

TV.java

public class TV{
    String name;
    public TV() {

    }
    public TV(String name) {
        this.name = name;
    }
    public String toString(){
        String oldstr = super.toString();
        return oldstr+"\n这是电视机,品牌是:"+name;
    }
}

Main2.java

import java.util.Date;

public class Main2 {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(""+date.toString());
        TV tv = new TV("TCL");
        System.out.println(""+tv.toString());
    }
}

Mon Sep 19 11:00:23 CST 2016
com.string.TV@70dea4e
这是电视机,品牌是:TCL

字符串与字符、字节数组

字符串与字符数组 toCharArray() - getChars()

public void getChars(int start,int end,char c[],int offset) 字符串调用该方法，将一部分字符复制到c数组中

public char[] toCharArray() 字符串对象调用该方法返回一个字符数组

public class Main3 {
    public static void main(String[] args) {
        char[] a,b;
        String s = "2016年9月19日我在图书馆";
        a = new char[2];
        s.getChars(11, 13, a, 0);
        System.out.println(a);
        b = "我在喝恒大冰泉,..".toCharArray();
        for(char ch:b){
            System.out.print(ch);
        }
    }
}

在图
我在喝恒大冰泉,..

字符串与字节数组 String (byte [],int offset,int length)

String (byte [],int offset,int length) 从offsset位置开始取length个字节构造一个字符串对象

    try {
        byte[] d = "java你好".getBytes("GB2312");//字符编码
        System.out.println("字节数组的长度是:"+d.length);//一个汉字占两个字节
        String s8 = new String (d,6,2);//d数组，从位置6取2个字节
        System.out.println(s8);
        s8 = new String(d,0,6);
        System.out.println(s8);
    } catch (UnsupportedEncodingException e) {
        System.out.println("UnsupportEncodingException异常");
    }

    字节数组的长度是:8
    好
    java你

字符串的加密算法

EncryptAndDecrypt.java

public class EncryptAndDecrypt {
    String encrypt(String sourceString, String password) {
        char[] p = password.toCharArray();
        int n = p.length;
        char[] c = sourceString.toCharArray();
        int m = c.length;
        /**
         * sourceString里的每个字符都会加上password的特定字符组成加法运算
         */
        for (int k = 0; k < m; k++) {
            int mima = c[k] + p[k % n];
            c[k] = (char) mima;
        }
        return new String(c);
    }

    String decrypt(String sourceString, String password) {
        char[] p = password.toCharArray();
        int n = p.length;
        char[] c = sourceString.toCharArray();
        int m = c.length;
        for (int k = 0; k < m; k++) {
            int mima = c[k] - p[k % n];
            c[k] = (char) mima;
        }
        return new String(c);
    }
}

PasswordTest.java

import java.util.Scanner;
public class PasswordTest {
    public static void main(String[] args) {
        String sourceString = "今晚十点进攻";
        EncryptAndDecrypt person = new EncryptAndDecrypt();
        System.out.println("输入密码加密:" + sourceString);
        Scanner scanner = new Scanner(System.in);
        String password = scanner.nextLine();
        String secret = person.encrypt(sourceString, password);
        System.out.println("密文:" + secret);
        System.out.println("输入解密密码:");
        password = scanner.nextLine();
        String source = person.decrypt(secret, password);
        System.out.println("明文:" + source);
    }
}

输入密码加密:今晚十点进攻
nihao123
密文:伸曃厩焚遊敬
输入解密密码:
nihao123
明文:今晚十点进攻

正则表达式及字符串的替换和分解

正则表达式

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，’n’ 匹配字符 “n”。’\n’ 匹配一个换行符。序列 ‘\\’ 匹配 “\” 而 “\(” 则匹配 “(“。
^	匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 ‘\n’ 或 ‘\r’ 之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 ‘\n’ 或 ‘\r’ 之前的位置。
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，’zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，”do(es)?” 可以匹配 “do” 或 “does” 中的”do” 。? 等价于 {0,1}。
{n}	n 是一个非负整数。匹配确定的 n 次。例如，’o{2}’ 不能匹配 “Bob” 中的 ‘o’，但是能匹配 “food” 中的两个 o。
{n,}	n 是一个非负整数。至少匹配n 次。例如，’o{2,}’ 不能匹配 “Bob” 中的 ‘o’，但能匹配 “foooood” 中的所有 o。’o{1,}’ 等价于 ‘o+’。’o{0,}’ 则等价于 ‘o*’。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，”o{1,3}” 将匹配 “fooooood” 中的前三个 o。’o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 “oooo”，’o+?’ 将匹配单个 “o”，而 ‘o+’ 将匹配所有 ‘o’。
.	匹配除 “\n” 之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符，请使用象 ‘[.\n]’ 的模式。
(pattern)	匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$ 9 属性。要匹配圆括号字符，请使用 ‘$’ 或 ‘$’。
(?:pattern)	匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 “或” 字符 (\|) 来组合一个模式的各个部分是很有用。例如， ‘industr(?:y\|ies) 就是一个比 ‘industry\|industries’ 更简略的表达式。
(?=pattern)	正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，’Windows (?=95\|98\|NT\|2000)’ 能匹配 “Windows 2000” 中的 “Windows” ，但不能匹配 “Windows 3.1” 中的 “Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如’Windows (?!95\|98\|NT\|2000)’ 能匹配 “Windows 3.1” 中的 “Windows”，但不能匹配 “Windows 2000” 中的 “Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
x\|y	匹配 x 或 y。例如，’z\|food’ 能匹配 “z” 或 “food”。’(z\|f)ood’ 则匹配 “zood” 或 “food”。
[xyz]	字符集合。匹配所包含的任意一个字符。例如， ‘[abc]’ 可以匹配 “plain” 中的 ‘a’。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如， ‘[^abc]’ 可以匹配 “plain” 中的’p’、’l’、’i’、’n’。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，’[a-z]’ 可以匹配 ‘a’ 到 ‘z’ 范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，’[^a-z]’ 可以匹配任何不在 ‘a’ 到 ‘z’ 范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配”never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
\B	匹配非单词边界。’er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。
\cx	匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\f	匹配一个换页符。等价于 \x0c 和 \cL。
\n	匹配一个换行符。等价于 \x0a 和 \cJ。
\r	匹配一个回车符。等价于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于 \x09 和 \cI。
\v	匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w	匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。
\W	匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’。
\xn	匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，’\x41’ 匹配 “A”。’\x041’ 则等价于 ‘\x04’ & “1”。正则表达式中可以使用 ASCII 编码。
\num	匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，’(.)\1’ 匹配两个连续的相同字符。
\n	标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
\nm	标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
\nml	如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
\un	匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

POSIX 字符类（仅 US-ASCII）

字符	描述
/p{Lower}	小写字母字符：[a-z]
/p{Upper}	大写字母字符：[A-Z]
/p{ASCII}	所有 ASCII：[/x00-/x7F]
/p{Alpha}	字母字符：[/p{Lower}/p{Upper}]
/p{Digit}	十进制数字：[0-9]
/p{Alnum}	字母数字字符：[/p{Alpha}/p{Digit}]
/p{Punct}	标点符号：!”#$%&’()*+,-./:;<=>?@[/]^_`{
/p{Graph}	可见字符：[/p{Alnum}/p{Punct}]
/p{Print}	可打印字符：[/p{Graph}/x20]
/p{Blank}	空格或制表符：[ /t]
/p{Cntrl}	控制字符：[/x00-/x1F/x7F]
/p{XDigit}	十六进制数字：[0-9a-fA-F]
/p{Space}	空白字符：[ /t/n/x0B/f/r]

public boolean matches(String regex) 判断当前字符串对象是否和参数regex指定的正则表达式匹配

Main4.java

import java.util.Scanner;

public class Main4 {
    public static void main(String[] args) {
        String regex = "[159]ABC";
        System.out.println("5ABC".matches(regex));

        String regex2 = "hello[2468]?";//x? x出现0次或一次
        System.out.println("hello".matches(regex2));
        System.out.println("hello2".matches(regex2));
        System.out.println("hello4".matches(regex2));
        System.out.println("---------------------");
        String regex3 = "hello[2468]*";//x* x出现0次或多次
        System.out.println("hello".matches(regex3));
        System.out.println("hello222".matches(regex3));
        System.out.println("hello4442".matches(regex3));

        String regex4 = "[a-zA-Z]+";//出现一次或多次
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入字符:");
        String str = scanner.nextLine();
        if(str.matches(regex4)){
            System.out.println(str+"中的字符都是英文字母");
        }
    }
}

true
true
true
true
---------------------
true
true
true
输入字符:
sfjslfj
sfjslfj中的字符都是英文字母

字符串的替换- replaceAll(regex,replacement)

public String replaceAll(String regex,String replacemet) 返回当前字符串中所有和参数regex指定的正则表达式匹配的子字符串被参数repex指定的字符串替换后的字符串

Main5.java

public class Main5 {
    public static void main(String[] args) {
        String str = "123jkfdj323";
        String result = str.replaceAll("[a-zA-Z]", "你好");
        String result2 = "123jkfdj323".replaceAll("[a-zA-Z]+", "你好");
        System.out.println(result);
        System.out.println(str);// replaceAll并不会改变字当前符串
        System.out.println(result2);

        String str2 = "欢迎大家访问http://www.baidu.com了解、参观公司";
        String regex = "(http://|www)\56?\\w+\56{1}\\w+\56{1}\\p{Alpha}+";
        System.out.printf("剔除\n\"%s\"\n中的网站链接\n", str2);
        str2 = str2.replaceAll(regex, "");
        System.out.println(str2);
    }
}

123你好你好你好你好你好323
123jkfdj323
123你好323
剔除
"欢迎大家访问http://www.baidu.com了解、参观公司"
中的网站链接
欢迎大家访问了解、参观公司

字符串的分解 - split(String regex)

public String[] split(String regex) 使用参数指定的regex作为分隔符标记分解出其中的单词，并将分解出的单词放在字符数组中

Split.java

import java.util.Scanner;

public class Split {
    public static void main(String[] args) {
        String str = "1931年 09月18日晚,日本发动侵华战争,请记住这个日子";
        String regex = "\\D+";
        String digitWord[] = str.split(regex);
        for (String ch : digitWord) {
            System.out.println(ch);
        }

        System.out.println("输入一行文本:");
        Scanner scanner = new Scanner(System.in);
        String str2 = scanner.nextLine();
        String regex2 = "[\\s\\d\\p{Punct}]+";
        String words[] = str2.split(regex2);
        System.out.println("--------遍历1-------");
        for (String ch2 : words) {
            System.out.println("单词 " + ch2);
        }
        System.out.println("-------遍历2--------");

        for (int i = 0; i < words.length; i++) {
            int m = i + 1;
            System.out.println("单词" + m + ":" + words[i]);
        }
    }
}

1931
09
18
输入一行文本:
we are famliy (hello)
--------遍历1-------
单词 we
单词 are
单词 famliy
单词 hello
-------遍历2--------
单词1:we
单词2:are
单词3:famliy
单词4:hello

StringBuffer类

String字符串不能修改、删除或替换字符串中的某个字符，即String对象一旦创建，那么实体是不能改变的。

String s = new String ("我喜欢散步");

这里写图片描述

StringBuffer类，该类能创建可修改的字符串序列，该类的对象的实体的内存空间可以自动地改变大小，便于存放一个可变的序列。

StringBuffer类有3个构造方法：

StringBuffer() 初始容量16个字符
StringBuffer(int size) 指定初始容量
StringBuffer(String s) 指定字符串

StringBuffe方法

StringBuffer append(boolean b)	这些方法都是向字符串缓冲区“追加”元素，但是，这个“元素”参数可以是布尔量、字符、字符数组、双精度数、浮点数、整型数、长整型数对象类型的字符串、字符串和StringBuffer类等。如果添加的字符超出了字符串缓冲区的长度，Java将自动进行扩充。
StringBuffer append(char c)	同上
StringBuffer append(char[] str)	同上
StringBuffer append(char[] str, int offset, int len)	同上
StringBuffer append(double d)	同上
StringBuffer append(float f)	同上
StringBuffer append(int i)	同上
StringBuffer append(long l)	同上
StringBuffer append(Object obj)	同上
StringBuffer append(String str)	同上
StringBuffer append(StringBuffer sb)	同上
int capacity()	返回当前StringBuffer对象（字符串缓冲区）的总空间，而非字符号串的长度。
char charAt(int index)	在当前StringBuffer对象中取索引号为index的字符。第一个字符的索引为“0”
StringBuffer delete(int start, int end)	删除当前StringBuffer对象中以索引号start开始，到end结束的子串。
StringBuffer deleteCharAt(int index)	删除当前StringBuffer对象中索引号为index的字符。
void ensureCapacity (int minimumCapacity)	重新设置字符号串缓冲区的总空间。如果minimumCapacity大于当前的总空间，则新的空间被设置：一种结果是minimumCapacity；另一种结果是{“老空间”乘2加2}。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)	从当前StringBuffer对象的索引号srcBegin开始，到srcEnd结束的子串，赋值到字符数组dst中，并且从dst的索引号dstBegin开始。
int indexOf(String str)	返回当前StringBuffer对象中，第一个满足str子串的位置。
int indexOf(String str, int fromIndex)	从当前StringBuffer对象的fromIndex开始查找，返回第一个满足str子串的位置。
StringBuffer insert(int offset, boolean b)	这些方法都是在当前StringBuffer对象中插入一个元素，在索引号offset处插入相应的值。
StringBuffer insert(int offset, char c)	同上
StringBuffer insert(int offset, char[] str)	同上
StringBuffer insert(int index, char[] str, int offset, int len)	同上
StringBuffer insert(int offset, double d)	同上
StringBuffer insert(int offset, float f)	同上
StringBuffer insert(int offset, int i)	同上
StringBuffer insert(int offset, long l)	同上
StringBuffer insert(int offset, Object obj)	同上
StringBuffer insert(int offset, String str)	同上
int lastIndexOf(String str)	返回当前StringBuffer对象中，最后一个满足str子串的位置。
int lastIndexOf(String str, int fromIndex)	从当前StringBuffer对象的fromIndex开始查找，返回最后一个满足str子串的位置。
int length()	返回当前StringBuffer对象（字符缓冲区）中，字符串的长度。注意：此方法与capacity() 不同。
StringBuffer replace(int start, int end, String str)	替换当前StringBuffer对象的字符串。从start开始，到end结束的位置替换成str。
StringBuffer reverse()	将字符串翻转。
void setCharAt(int index, char ch)	设置索引号index的字符为ch。
void setLength(int newLength)	重新设置字符串缓冲区中字符串的长度，如果newLength小于当前的字符串长度，将截去多余的字符。
String substring(int start)	取当前StringBuffer对象中，从start开始到结尾的子串。
String substring(int start, int end)	取当前StringBuffer对象中，从start开始到end的子串。
String toString()	将当前StringBuffer对象转换成String对象

MyStringbuffer.java

public class MyStringbuffer {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("我喜欢");
        System.out.println("old:" + buffer);
        buffer.append("玩篮球");
        System.out.println("new:" + buffer);

        System.out.println("length:" + buffer.length());// 字符序列的长度
        System.out.println("capacity:" + buffer.capacity());// 实际容量

        buffer.setCharAt(0, 'p');
        System.out.println("setCharAt:" + buffer);

        buffer.insert(2, "ww");
        System.out.println("insert:" + buffer);

        int index = buffer.indexOf("篮球");// 6
        buffer.replace(index, buffer.length(), "足球");
        System.out.println("replace:" + buffer);
    }
}

old:我喜欢
new:我喜欢玩篮球
length:6
capacity:19
setCharAt:p喜欢玩篮球
insert:p喜ww欢玩篮球
replace:p喜ww欢玩足球h

StringTokenizer类

StringTokenizer对象分解字符串，和split()方法不同，StringTokenizer对象不使用正则表达式做分割标记。
有时需要分析字符串并将字符串分解为可独立使用的单词，这些单词叫做语言符号。

StringTokenizer(String s) 为字符串s构造一个分析器。使用默认的分割标记，即空格符(若干空格看作一个空格),换行符，回车符，Tab符，进纸符做分隔标记。
StringTokenizer(String s,String delim) 为字符串s构造一个分析器，参数delim中的字符被作为分隔标记。
分割标记的组合仍然是分隔标记。

MyStringtokenizer.java

import java.util.StringTokenizer;

public class MyStringtokenizer {
    public static void main(String[] args) {
        StringTokenizer fenxi = new StringTokenizer("you are welcome");
        StringTokenizer fenxi2 = new StringTokenizer("you are; welcome ", ", ;");
        int number = fenxi.countTokens();
        System.out.println("共有语言符号:" + number);

        //有语言符号时hasMoreTokens()返回true
        while (fenxi.hasMoreTokens()) {
            String str = fenxi.nextToken();
            System.out.println(str + "");
        }
    }
}

共有语言符号:3
you
are
welcome

Data类

构造Date对象

import java.util.Date;

public class MyDate {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);

        // 系统默认格林威治时间(1970年1月1日0时)
        Date date2 = new Date(1000);// 北京时区8时,后1000毫秒
        System.out.println("1000:" + date2);
        Date date3 = new Date(-1000);// 北京时区8时,前1000毫秒
        System.out.println("-1000:" + date3);

    }
}

Mon Sep 19 21:10:28 CST 2016
1000:Thu Jan 01 08:00:01 CST 1970
-1000:Thu Jan 01 07:59:59 CST 1970

日期格式化

Date的默认时间格式为：星期、月、日、小时、分、秒、年。
使用java.text包中的DateFormat的子类SimpleDateFormat来实现日期的格式化。

字母	表示	日期或时间元素	示例
G	公元标志	Text	AD或公元
y	2位数字的年	Year	96
M	年中的月份	Month	July; Jul; 07
w	年中的周数	Number	27
W	月份中的周数	Number	2
D	年中的天数	Number	189
d	月份中的天数	Number	10
F	月份中的星期	Number	2
E	星期中的天数	Text	Tuesday; Tue
a	Am/pm 标记	Text	PM
H	一天中的小时数（0-23）	Number	0
k	一天中的小时数（1-24）	Number	24
K	am/pm 中的小时数（0-11）	Number	0
h	am/pm 中的小时数（1-12）	Number	12
m	小时中的分钟数	Number	30
s	分钟中的秒数	Number	55
S	毫秒数	Number	978
z	时区	General time zone	CST

某些格式可以连续重复的出现，yyyy用4位数字表示年。
MyDate.java

import java.text.SimpleDateFormat;
import java.util.Date;

public class MyDate {
    public static void main(String[] args) {
        Date nowtime = new Date();
        System.out.println(nowtime);
        String pattern = ("yyyy-MM-dd");
        SimpleDateFormat SDF = new SimpleDateFormat(pattern);
        String timePattern = SDF.format(nowtime);
        System.out.println("" + timePattern);

        pattern = "G yyyy年MMMd 日 E HH 时 mm 分 ss秒z";
        SDF = new SimpleDateFormat(pattern);
        timePattern = SDF.format(nowtime);
        System.out.println("" + timePattern);
        long time = System.currentTimeMillis();
        System.out.println("现在是公元后" + time + "毫秒");
    }
}

Mon Sep 19 21:48:16 CST 2016
2016-09-19
公元 2016年九月19 日 星期一 21 时 48 分 16秒CST
现在是公元后1474292896423毫秒

Calendar类

Calendar类在java.util包中，使用Calendar类的static方法个头Instance()可以初始化一个日历对象。

Calendar 的 month 从 0 开始，也就是全年 12 个月由 0 ~ 11 进行表示。
而 Calendar.DAY_OF_WEEK 定义和值如下：
Calendar.SUNDAY = 1
Calendar.MONDAY = 2
Calendar.TUESDAY = 3
Calendar.WEDNESDAY = 4
Calendar.THURSDAY = 5
Calendar.FRIDAY = 6
Calendar.SATURDAY = 7

Calendar方法

// 获取指定日期的毫秒数，常用来比较两个日期的大小。
date.getTime();


// 使用Calendar获取当前系统时间，需要获取Calendar对象后转换成Date输出
Calendar calendar = Calendar.getInstance();


// 这个方法相当于Date中的getTime，获取当前时间的毫秒数
calendar.getTimeInMillis();


// 获取指定日期所在周的第一天的日期，默认的一周的第一天是周日
calendar.getFirstDayOfWeek();


// 返回当前calendar日期所在的年，如2016
calendar.get(1);


// Calendar转Date，输出结果：Tue May 03 09:31:59 CST 2016
Date date2 = calendar.getTime();
System.out.println(date2);


// Calendar设置年、月、日，输出结果：Mon Jun 03 09:31:59 CST 2013
// 相关常用重载方法：calendar.set(year, month, date, hourOfDay, minute);
// calendar.set(year, month, date, hourOfDay, minute, second);参数均为int
calendar.set(2013, 5, 3);
System.out.println(calendar.getTime());


// 使用Calendar设置年，输出结果：Fri Jun 03 09:42:43 CST 2011
calendar.set(Calendar.YEAR, 2011);
System.out.println(calendar.getTime());


// 使用Calendar和数字设置月，注意月份从0开始，代表1月，输出结果：Mon Jan 03 09:45:32 CST 2011
calendar.set(Calendar.MONTH, 0);
System.out.println(calendar.getTime());


// 使用Calendar和自带常量设置月，注意月份从0开始，代表1月，输出结果：Thu Feb 03 09:47:07 CST 2011
calendar.set(Calendar.MONTH, Calendar.FEBRUARY);
System.out.println(calendar.getTime());


// 使用Calendar和数字设置日，输出结果：Sat Feb 05 09:48:25 CST 2011
// calendar.set(Calendar.DAY_OF_MONTH, 5)结果一样;
calendar.set(Calendar.DATE, 5);
System.out.println(calendar.getTime());


// 设置小时
calendar.set(Calendar.HOUR, 15);
System.out.println(calendar.getTime());


// 根据毫秒数设置Calendar时间
calendar.setTimeInMillis(0);


// Date转String，输出结果：2016-05-03 09:25:29
String forDate = dateToString(new Date());
System.out.println(forDate);


// String转Date，输出结果：Thu Nov 12 13:23:11 CST 2015
Date strDate = stringToDate("2015-11-12 13:23:11");
System.out.println(strDate);


// Date转Calendar，输出结果：2015
Calendar calendar2 = dateToCalendar(strDate);
System.out.println(calendar2.get(1));

示例-输出日历

CalendarBean.java

import java.util.Calendar;

public class CalendarBean {
    String[] day;
    int year = 0;
    int month = 0;

    public void setYear(int year) {
        this.year = year;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public String[] getCalendar() {
        String[] a = new String[42];// 日历数字最多6行 6*7
        Calendar rili = Calendar.getInstance();
        rili.set(year, month-1, 1);
        System.out.println(year+"年"+month+"月日历");
        int weekday = rili.get(Calendar.DAY_OF_WEEK) -1;// 这个月1号的星期
        /**
         * 非整百年能被4整除的为闰年。（如2004年就是闰年,2100年不是闰年）
         * 能被400整除的是闰年。(如2000年是闰年，1900年不是闰年)
         */
        int day = 0;
        if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12){
            day = 31;
        }
        if (month == 4 || month == 6 || month == 9 || month == 11){
            day = 30;
        }
        if (month == 2) {
            if ((year % 4 == 0) || (year % 100 != 0) || (year % 400 == 0)) {
                day = 29;
            } else {
                day = 28;
            }
        }
        // 1号星期前存入空格到a[]
        for (int i = 0; i < weekday; i++) {
            a[i] = " ";
        }
        for (int i = weekday, n = 1; i < weekday + day; i++) {
            a[i] = String.valueOf(n);
            n++;
        }
        for (int i = weekday + day; i < a.length; i++) {
            a[i] = " ";
        }

        return a;
    }
}

TestMain.java

public class TestMain {
    public static void main(String[] args) {
        CalendarBean cb = new CalendarBean();
        cb.setMonth(9);// 0表示一月份,要减一处理 rili.set(year, month-1, 1);
        cb.setYear(2016);
        String[] a = cb.getCalendar();// 返回号码的一维数组
        char[] str = "日一二三四五六".toCharArray();
        for (char c : str) {
            System.out.printf("%6c", c);
        }
        for (int i = 0; i < a.length; i++) {
            if (i % 7 == 0) {
                System.out.println("");// 换行
            }
            System.out.printf("%3s", a[i]);

        }
    }
}

2016年9月日历
 日 一  二 三  四  五  六
              1  2  3
  4  5  6  7  8  9 10
 11 12 13 14 15 16 17
 18 19 20 21 22 23 24
 25 26 27 28 29 30

示例-输出日历2

DisplayCalendar.java

import java.text.DateFormatSymbols;
import java.util.Calendar;
import java.util.Locale;

public class DisplayCalendar {
    public static void main(String args[]) {
        Locale.setDefault(Locale.US);
        Calendar calendar = Calendar.getInstance();
        calendar.setLenient(true);// 时间格式
        int today = calendar.get(Calendar.DAY_OF_MONTH);// 当天
        int month = calendar.get(Calendar.MONTH);// 当月
        int firstDayOfWeek = calendar.getFirstDayOfWeek();// 每周从周几开始
        calendar.set(Calendar.DAY_OF_MONTH, 1);// 设置日期，与DATE同义
        System.out.println("时间:" + calendar.getTime());
        int firstday = calendar.get(Calendar.DAY_OF_WEEK);
        /**
         * 输出星期
         */
        String[] weekdayNames = new DateFormatSymbols().getShortWeekdays();
        for (int i = 1; i < 8; i++) {

            System.out.printf("%4s", weekdayNames[i]);
        }
        System.out.println();

        do {
            int day = calendar.get(Calendar.DAY_OF_MONTH);

            if (day == 1) {
                System.out.print("$");// 为了对齐
                // 输出日期1号前的空白
                for (int i = 0; i < firstday - 1; i++) {
                    System.out.print("    ");
                }
            }
            System.out.printf("%3d", day);
            if (day == today) {
                System.out.print("*");
            } else {
                System.out.print(" ");
            }
            calendar.add(Calendar.DAY_OF_MONTH, 1);// 日期加一
            if (calendar.get(Calendar.DAY_OF_WEEK) == firstDayOfWeek) {
                System.out.println();// 日期换行
                System.out.print("@");
            }
        } while (calendar.get(Calendar.MONTH) == month);
    }
}

时间:Thu Sep 01 14:30:52 CST 2016
 Sun Mon Tue Wed Thu Fri Sat
$                  1   2   3 
@  4   5   6   7   8   9  10 
@ 11  12  13  14  15  16  17 
@ 18  19  20* 21  22  23  24 
@ 25  26  27  28  29  30

参考

《java程序设计实用教程》

伍Wu哈Ha

关注

1
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
Java笔记（5）-String、StringBuffer、StringTokenizer、Date、Calendar

Java笔记（5）-String、StringBuffer、StringTokenizer、Date、Calendar
复制链接

扫一扫