Java基础 常用使用类

第八章 常用使用类

8.1 String类

• 在java.lang中

• 构造

  • 常量对象

  • 字符串对象

    • 字符串

    • 数组对象

      String(char [ ] , int startIndex , int count)

  • 引用字符串常量对象

• String类常用方法
  public int length()
public boolean equals(String s)

  Example1.java

  package example1;
  
  public class Example1 {
      public static void main(String args[]) {
          String s1 = new String("天道酬勤");
          String s2 = new String("天道酬勤");
          System.out.println(s1.equals(s2));
          System.out.println(s1 == s2);
          String s3 = "勇者无敌";
          String s4 = "勇者无敌";
          System.out.println(s3.equals(s4));
          System.out.println(s3 == s4);
      }
  }
  

  • public boolean startwith(String s) 和 public boolean endsWith(String s)
  • public int compareTo(String s) 和 public int compareToIgnoreCase(String s)
    
    • < 0
    • = 0
    • > 0

  Example2.java

  package example2;
  class SortString{
      public static void sort(String [] a) {
          int couut = 0;
          for(int i = 0;i < a.length - 1;i++) {
              for(int j = i + 1;j < a.length ;j++) {
                  if(a[i].compareTo(a[j]) > 0 ) {
                      String temp = a[i];
                      a[i] = a[j];
                      a[j] = temp;
                  }
              }
          }
      }
  }
  
  public class Example2 {
      public static void main(String args[]) {
          String [] a = {"melon","apple","pear","banana"};
          String [] b = {"西瓜","苹果","梨","香蕉"};
          System.out.println("按字典序排列数组a:");
          SortString.sort(a);
          for(int i  = 0;i < a.length;i++) {
              System.out.print("  " + a[i]);
          }
          System.out.println("\n按字典序排列数组b:");
          SortString.sort(b);
          for(int i = 0;i < b.length ;i++) {
              System.out.print("  " + b[i]);
          }
      }
  }
  

  从上面的例子可以看出，如果方法不需要操作实例变量，则可以将该方法做为类方法定义

  • public boolean contains(String s)
  • public int indexOf(String s)
    
    • public int indexOf(String s) 没有则返回-1
    • public int indexOf(String s , int startpoint)
    • public int lastIndexOf(String s)
  • public String subString(int sartpoint)
    
    • public String subString(int start, int end)
      
      • 返回的是star到end-1的字符串
  • public String trim()
    
    • 得到一个字符串，这个字符串是s去掉前后空格后的字符串

Example3.java

package example3;

public class Example3 {
    public static void main(String args[]) {
        String path = "c:\\book\\javabook\\Java Programmer.doc";
        int index = path.indexOf("\\");
        index = path.indexOf("\\",index);
        String  sub = path.substring(index);        //\book\javabook\Java Programmer.doc
        System.out.println(sub);
        index = path.lastIndexOf("\\");
        sub = path.substring( index + 1);
        System.out.println(sub);        //Java Programmer.doc
        System.out.println(sub.contains("Programmer"));     //true
    }
}

转意符’\’不占位置

• 字符串与基本数据的相互转换

  • public static int parseInt(String s)
    
    • 包含在java.lang中的Integer类中
    • 类似的有
      
      • public static byte ParseByte(String s) throws NumberFormatException
      • public static short ParseShort(String s) throws NumberFormatException
      • public static long ParseLong(String s) throws NumberFormatException
      • public static float ParseFloat(String s) throws NumberFormatException
      • public static double ParseDouble(String s) throws NumberFormatException
  • public static String valueOf(byte n)
    
    • 类似的有
    • public static String valueOf(int n)
    • public static String valueOf(long n)
    • public static String valueOf(float n)
    • public static String valueOf(double n)

  Example4.java

  package example4;
  
  public class Example4 {
      public static void main(String args[]) {
          //double aver = 0;
          double sum = 0;
          double item = 0;
          boolean show = true;
          for(String s:args) {
              try {
                  item = Double.parseDouble(s);
                  sum += item;
              }
              catch(NumberFormatException e) {
                  System.out.println("您输入了非法的数字" + e);
                  System.out.println(e.getMessage());
                  show = false;
              }
          }
          if(show) {
              System.out.println("sum = " + sum);
          }
      }
  }
  

• 对象的字符串表示

  • 所有的对象都是Object的子类或者间接子类
    
    • Object在java.lang中
  • public String toString()
    
    • 返回对象名@引用
    • 可以重写

Example5.java

    ```
    package example5;
    import java.util.Date;
    class TV{
        String name;
        public TV() {}
        public TV(String name) {
            this.name = name;
        }
        public String toString() {
            String oldStr = super.toString();
            return oldStr + "\n这是电视机，品牌是:" + name;
        }
    }
    public class Example5 {
        public static void main(String args []) {
            Date date = new Date();
            System.out.println(date.toString());
            TV tv = new TV("长虹电视");
            System.out.println(tv.toString());
        }
    }

    ```

• 字符串与字符、字节数组

  • 字符串与字符数组

    • public void getChars(int start , int end , char c[] , int offset)
      
      • start到end-1放到c中offset开始的地方
      • 必须得放得下
    • public char[] toArray()

  • 字符串与字节数组

    • String类的构造函数是String(Byte [])

      • String(byte [],int offset,int length) 也是

    • 当前字符串转换为一个字符数组

      • public byte[] getBytes()
        
        • 使用平台默认的字符编码
      • public byte[] getBytes(String charsetName)
        
        • 使用参数指定的字符编码
        • 抛出的异常类是UnsupportedEncodingException

  Example6.java

package example6;
public class Example6 {
    public static void main(String argsp[]){
        char [] a,c;
        String s = "1945年8月15日是抗战胜利日";
        a = new char[4];
        s.getChars(11, 15, a, 0);
        System.out.println(a);
        c = "十一长假期间，学校都放假了".toCharArray();
        for(int i = 0;i < c.length ;i++) {
            System.out.print(c[i]);
        }
        System.out.println("");
    }
}

Example7.java

package example7;

import java.io.UnsupportedEncodingException;

public class Example7 {
    public static void main(String args[]) {
        try {
            byte [] d = "Java你好".getBytes("GB2312");
            System.out.println("字节数组的长度:" + d.length);
            String s = new String(d,6,2);       //好
            System.out.println(s);
            s = new String(d,0,6);      //Java你
            System.out.println(s);
        }
        catch(UnsupportedEncodingException e) {
            System.out.println("Something wrong");
            System.out.println(e.getMessage());
            System.out.println("原来情况如下");
            System.out.println("好");
            System.out.println("Java你");
        }
        finally {
            System.out.println("程序结束");
            System.exit(0);
        }
    }
}

• 正则表达式及字符串的替换与分解
  
  • 正则表达式
    正则表达式是含有一些特殊意义字符的字符串
    public boolean matches(String regex) //判断当前字符串中是否和regex指定的正则表达式匹配

元字符	正则表达式	意义
·	·	代表任何一个字符
\d	\\d	代表0～9任何一个数字字符
\D	\\D	代表任意一个非数字字符
\s	\\s	代表空格类字符, ‘\t’ , ‘\n’ , ‘\x0B’ , ‘\f’ , ‘\r’
\S	\\S	代表非空个类字符
\w	\\w	代表可用于标志符的字符(不含$)
\W	\\W	代表不能用于标志符的字符
\p{Lower}	\\p{Lower}	小写字母[a~z]
\p{Upper}	\\p{Upper}	大写字母[A~Z]
\p{ASCII}	\\p{ASCII}	ASCII字符
\p{Alpha}	\\p{Alpha}	字母
\p{Digit}	\\p{Digit}	数字字符[0~9]
\p{Alnum}	\\p{Alnum}	数字或字母
\p{Punct}	\\p{Punct}	标点符号:!@#$%^&*()-+{}[];:’”<.,?/`~
\p{Graph}	\\p{Graph}	可视字符\p{Alnum} \p{Punct}
\p{Print}	\\p{Print}	可打印字符
\p{Blank}	\\p{Blank}	空格或制表符[\t]
\p{Cntrl}	\\p{Cntrl}	控制字符:[\x00-\x1F\x7F]

• 可以用[]括多个字符表示一个元字符
  
  • [159]ABC
    
    • [abc]
    • [^abc]
    • [a-zA-Z]
    • [a-d]
    • [a-d[m-p]] //a到d或m到p的任一个，并运算
    • [a-z&[def]] //d or e or f,交运算
    • [a-z&[^def]] //差运算
  • 由于.表示任何一个字符，因此.需要用[.]或者\56表示
  • 限定修饰符
    
    • regex = “hello[246]X”
      
      • hello,”hello2”,”hello4”,”hello6”都是匹配的

带限定符号的模式	意义
X？	X出现0次或1次
X*	X出现0次或多次
X+	X出现1次或多次
X{n}	X恰好出现n次
X{n,}	X至少出现n次
X{n,m}	X出现n至m次
XY	X的后缀是Y
X|Y	X或Y

* 有关正则表达式可以查看java.util.regex
* “@w{4}”可以和”@abcd” , “@天道酬勤” , “@Java” , “@bird”匹配上
* 字符串的替换
* public String replaceAll(String regex,String replacement)
* 当前的字符串与指定的正则表达式regex匹配的所有子字符串用replacement替换
* String s = "12hello567bird".replaceAll("[a-zA-Z]","你好");
* 字符串的分解
* public String[] split(String regex)

Example8.java

package example8;
public class Example8 {
    public static void main(String args[]) {
        String str = "1949年10月01日";
        String regex = "\\D+";
        System.out.println(str);
        str = str.replaceAll(regex, "/");
        System.out.println(str);
        str = "14987532468¥";
        System.out.println(str);
        System.out.println(str.replaceAll(regex, ""));
    }
}

Example9.java

package example9;
import java.util.Scanner;
public class Example9 {
    public static void main(String args[]) {
        Scanner reader = new Scanner(System.in);
        System.out.println("请输入一行文本");
        String str = reader.nextLine();
        String regex = "[\\s\\d\\p{Punct}]+";       //正则表达式
        String words[] = str.split(regex);
        for(int i = 0;i < words.length; i++) {
            System.out.println("第" + i + "个单词：" + words[i]);
        }
    }
}

---

8.2 StringTokenizer类

• 位于java.util中
• 用来分解字符串，但不需要使用正则表达式

• StringTokenizer(String s)

  • 为字符串s构造一个分析器
  • 使用默认分隔标记，即空格符(多个连续的将被看作一个)、换行符、回车符、Tab符、进纸符
  • StringTokenizer fenxi = new StringTokenizer("you are welcome");

• StringTokenizer(String s,String delim)

  • delim中的参数作为分隔标记
  • StringTokenizer fenxi = new StringTokenizer("you,are;welcome",",;")

• StringTokenizer的一个对象为一个字符串分析器

  • 分析器可以使用nextToken()方法逐个获取字符串中的语言符号
    
    • 每次获得一个后，负责计数的计数器自减一，初始值等于字符串中的单词数量
  • 通常用while循环来逐个获取语言符号
    
    • 使用hasMoreTokens()方法
      
      • boolean型，true <==> 计数器>0
    • countTokens()得到分析器中计数变量的值

Example10.java

package example10;
import java.util.StringTokenizer;
public class Example10 {
    public static void main(String args[]) {
        String s = "You are wellcom(thank you),nice to meet you";
        StringTokenizer analysis = new StringTokenizer(s,"() ,");       //此处有空格
        int number = analysis.countTokens();
        while(analysis.hasMoreTokens()) {
            String str = analysis.nextToken();
            System.out.print(str +" ");
            //System.out.println(analysis.countTokens());       countToken() 随着调用nextToken()会自减一
        }
        System.out.println("共有" + number + "个单词");
    }
}

---

8.3 Scanner类

使用Scanner 类的对象从字符串中解析程序所需的信息

• 使用默认分隔标记解析字符串

  • 创建Scanner对象，并将要解析的字符串传递给所构造的对象
  • String NBA = "I love this game";
  • Scanner scanner = new Scanner(NBA)
    
    • 调用next()方法一次返回NBA中的单词
      
      • hasNext()方法对应是否还有单词。
        
        • boolean型
    • 数字型单词则可以用nextInt()或nextDouble()
      
      • 异常类是InputMismatchException

  Example11.java

  package example11;
  import java.util.Scanner;
  import java.util.InputMismatchException;
  public class Example11 {
      public static void main(String args[]) {
          String cost = "The TV costs 876 dollars.The computer costs 2398 dollars.The telephone costs 1278 dollars";
          Scanner scanner = new Scanner(cost);
          double sum = 0;
          while(scanner.hasNext()) {
              try {
                  double price = scanner.nextDouble();
                  sum += price;
              }
              catch(InputMismatchException e) {
                  String str = scanner.next();
              }
          }
          System.out.println("总共花费" + sum + "美刀");
      }
  }
  

• 使用正则表达式作为分隔标记解析字符串

  • 使用useDelimiter(String regex)方法，将于正则表达式匹配的字符作为分隔标记符

  Example12.java

  package example12;
  import java.util.*;
  public class Example12 {
      public static void main(String args[]) {
          String cost  = "话费清单：市话费76.79元，长度电话费276.38元，短信费12.68元";
          Scanner reader = new Scanner(cost);
          String regex = "[^0123456789.]+";       //不用+则只匹配一个
          reader.useDelimiter(regex);
          double sum = 0;
          while(reader.hasNext()) {
              try {
                  double price = reader.nextDouble();
                  System.out.println(price);
                  sum += price;
              }
              catch(InputMismatchException e) {
                  String str = reader.next();
              }
          }
          System.out.println("总共的话费为" + sum + "元");
      }
  }
  

---

8.4 Date类和Calendar类

8.4.1 Date类

• 使用无参数构造方法
  
  • 获得本机的当前日期和时间
  • Date noTime = new Date()
• 使用带参数的构造方法
  
  • 计算机系统时间的“公元”时间 1970年01月01日0时(格林尼治时间)
  • Date(long time)
    
    • 正数表示之后，单位：ms
    • 负数表示之前，单位：ms
    • System类的静态方法public long currentTimeMills()获得所在时区当前时间距离“公元“的时间，单位：ms
      
      • 存疑 貌似是Calendar类中的

8.4.2 Calendar类

• Calendar类的static方法getInstance()初始化一个日历对象
  
  • Calendar calendar = calendar.getInstance()
• 将日历翻到一个时间
  
  • public final void set(int year , int month , int day)
  • public final void set(int year , int month , int day , int hour , int minute)
  • public final void set(int year , int month , int day , int hour , int minute , int second)
• 获得相关年月日等的信息
  
  • public int get(int field)
    
    • calendar.get(Calendar.MONTH);
      
      • 0表示1月
    • calendar.get(Calendar.DAY_OF_WEEK);
      
      • 1表示周日，7表示周六
    • ……..

Example13.java

package example13;
import java.util.*;
public class Example13 {
    public static void main(String args[]) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());       //设置成了当前时间
        int year = calendar.get(calendar.YEAR);
        int month = calendar.get(calendar.MONTH) + 1;
        int day = calendar.get(calendar.DAY_OF_MONTH);
        int week = calendar.get(calendar.DAY_OF_WEEK);
        int hour = calendar.get(calendar.HOUR_OF_DAY);
        int minute = calendar.get(calendar.HOUR);
        int second = calendar.get(calendar.SECOND);
        System.out.println("现在的时间是" + year + "年" + month + "月" + day + "日" + "星期" + week + hour + "时" + minute + "分" + second + "秒");
        year = 2012;
        month = 8;
        day = 1;
        calendar.set(year, month , day);
        long time1 = calendar.getTimeInMillis();
        year = 2016;
        month = 6;
        day = 1;
        calendar.set(year, month, day);
        long time2 = calendar.getTimeInMillis();
        long subDays = (time2 - time1) / (24 * 60 * 60 * 1000);
        System.out.println(" " + new Date(time1));
        System.out.println("与" + new Date(time2));
        System.out.println("相差" + subDays);
    }
}

CalendarBean.java

package example14;
import java.util.*;
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];
        Calendar cd = Calendar.getInstance();
        cd.set(year,month - 1 ,1);
        int weekDay = cd.get(cd.DAY_OF_WEEK);;
        int day = 0;
        if(month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
            day = 31;
        }
        else if(month == 2) {
            if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
                day = 29;
            }
            else {
                day = 28;
            }
        }
        else {
            day = 30;
        }
        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;
    }
}

Example14.java

package example14;
public class Example14 {
    public static void main(String args[]) {
        CalendarBean cb = new CalendarBean();
        cb.setYear(2016);
        cb.setMonth(7);
        String [] a = cb.getCalendar();
        char [] str = "日一二三四五六".toCharArray();
        for(char c:str)
        {
            System.out.printf("%3c", c);
        }
        System.out.println("");
        for(int i = 0;i < a.length ; i++) {
            if(i % 7 == 0) {
                System.out.println("");
            }
            System.out.printf("%-4s", a[i]);
        }
    }
}

---

8.5 Math类

• public static double abs(double a)
• public static double max(double a , double b)
• public static double min(double a , double b)
• public static double random()
• public static double pow(double a , double b)
• public static double sqrt(double a)
• public static double log(double a)
• public static double sin(double a)
• public static double asin(double a)

---

8.6 StringBuffer类

StringBuffer创建的是可修改的字符串序列

8.6.1 StringBuffer对象的创建

• 有三个构造方法
  
  • StringBuffer()
    
    • 初始容量可容纳16个字符
    • 超过时自动增加
  • StringBuffer(int size)
    
    • 指定初始容量
    • 超过自动增加
  • StringBuffer(String s)
    
    • 指定初始容量为s.length() + 16
    • 超过自动增加
    • 将s存入StringBuffer对象
• length()方法获得长度
• capacity()方法获得当前实体的容量

8.6.2 StringBuffer类的常用方法

• append方法
  
  • StringBuffer append(String s)
  • StringBuffer append(int n )
    
    • double n等等都可以
  • StringBuffer append(Object o)
    
    • 添加一个对象的字符串标志符
• public charAt(int n) 和 public void setCharAt(int n ,char ch)
• StringBuffer insert(int index , String str)
• public StringBuffer reverse()
• StringBuffer delete(int startIndex , int endIndex)
  
  • delete charAt(int index)
• StringBuffer replace(int startIndex , int endIndex , String str)
• Remark
  
  • 可以用String的构造方法String(StringBuffer bufferstring)创建一个字符串对象

Example15.java

package example15;
public class Example15 {
    public static void main(String args[]) {
        StringBuffer str = new StringBuffer();
        str.append("大家好");
        System.out.println("str:" + str);
        System.out.println("length:" + str.length());
        System.out.println("capacity:" + str.capacity());
        str.setCharAt(0,'w');
        str.setCharAt(1 , 'e');
        System.out.println("str");
        str.insert(2, "are all");
        int index = str.indexOf("好");
        str.replace(index, str.length(), " right");
        System.out.println(str);
    }
}

---

8.7 System类

System.exit(int status)

• 0 或者非零数字
  
  • 0表示正常关闭
  • 其他数字表示出现问题而关闭

Example16.java

package example16;
import java.util.*;
public class Example16 {
    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        int sum = 0;
        System.out.println("输入一个整数:");
        while(scanner.hasNextInt()) {
            int item = scanner.nextInt();
            sum += item;
            System.out.println("目前sum:" + sum);
            if(sum >= 800) {
                System.exit(0);
            }
            System.out.println("请输入一个整数(输入一个非整数以结束):");
        }
        System.out.println("总和" + sum);
    }
}

---

8.8 小结

• 熟练掌握String类的常用方法
• 掌握String类和StringBuffer类的不同，以及二者之间的联系
• 使用StringTokenizer、Scanner类分析字符串，获取字符串中被分隔符分隔的单词
• 当程序需要处理时间时，使用Date类和Calendar类

以上内容均根据《Java基础教程(第三版)》整理而成