Java-常用实用类

1.字符串

1.1 字符串的创建

 ///字符串常量用双引号扩起
	 String s1="hello world!";
	 ///字符串的声明
	 String s; //s==null

	 ///创建字符串的构造方法
	 public String()//空串
	 public String(String original)//由字符串对象创建
	 public String(char a[])//由字符数组创建
	 ///由字符数组或者Unicode码数组创建 startIndex:数组起始元素下标 count:截取的个数
	 public String(char a[],int startIndex,int count)
	 public String(int codePoints[],int startIndex,int count)

	String s1 = new String("Hello!");
	char[] charArr = {'H','e','l','l','o'};
	String s2 = new String(charArr);
	String s3 = new String(charArr,0,4);

   

package test;
import java.lang.String;
public class test {
 public static void main(String args[])
 {
	String hello = "你好";
	String test1 = "你"+"好";///常量并运算结果在常量池
	System.out.println(hello==test1);//true
	System.out.println("你好"==test1);//true
	System.out.println("你好"==hello);//true
	
	String you = "你";
	String hi = "好";
	String test2 = you + hi ;///变量并运算结果在动态区
	System.out.println(hello==test2);//false
	String test3 = you + hi;
	System.out.println(test2 == test3);//false

 }
}

//java中判断空串和空对象
	//空字符串：长度为0的字符串，即:""
	//空对象：String对象的引用为空，即:null
	 String s=null;
     String s="";

//判断一个String对象是否是空串，有以下方法
	 s.equals("");
	 s.length()<1;
	 s.empty();
	 
	 //判断一个String对象是否是空对象，可以用:
	 s == null;

1.2 字符串的常用方法

//public int length()
	 String Tom = "我们是学生";
	 System.out.println(Tom.length());//5
	 
	//public boolean equals(String s)
	//比较两个字符串是否相等（非同一）
	String s = ";";
	System.out.println(s.equals(""));//false
	
	//public boolean startsWith(String s)
	//判断字符串的前缀是否是指定字符串s
	String wea = "天气预报，阴有小雨";
	System.out.println(wea.startsWith("天气"));//true

	//public boolean endsWith(String s)
	//判断字符串的前缀是否是指定字符串s
	String wea1 = "天气预报，阴有小雨";
	System.out.println(wea1.endsWith("小雨"));//true
	System.out.println(wea1.endsWith("大雨"));//false
	
	public boolean regionMatches(int firstStart,String other,int otherStart,int length)
	//从当前字符串firstStart指定位置开始，取长度为length的一个子串1;other是比较字符串，从otherStart指定的位置开始，取长度为length的另一个子串2
	//如果两个子串相同则返回true，否则返回false
	
	public int compareTo(String s)
	//当前字符串与s相同，返回0
	//当前字符串大于s，返回正值
	//当前字符串小于，返回负值

package test;
import java.lang.String;
public class test {
 public static void main(String args[])
 {
	//public int compareTo(String s)
	//当前字符串与s相同，返回0
	//当前字符串大于s，返回正值
	//当前字符串小于，返回负值
	 int count = 0;
	 String s="dcba";
	 char a[];
	 a = new char[s.length()];
	 s.getChars(0, s.length(), a, 0);
	 for(int i=0;i<s.length()-1;i++)
	 {
		 for(int j=i+1;j<s.length();j++)
		 {
			 if(a[j]<a[i])
			 {
				 char temp = a[i];
			     a[i]=a[j];
			     a[j]=temp;
			 }
		 }
	 }
    System.out.println(a);//abcd
 }
}

public int indexOf(String s)
//查找子串s的出现位置，并返回首次出现的位置
//如果未包含子串s，则返回-1
//重载方法
indexOf(String s,int startspoint)
//类似方法
lastIndexOf(String s)

//获取子串，该子串从startpoint开始到串末尾
//重载方法
substring(int start,int end)
//[start,end)
System.out.println("hello".substring(4,5));//o

public String replaceAll(String oldString,String newString)
public String trim()//去掉字符串前后的空格

package test;
import java.lang.String;
import java.util.*;
public class test {
 public static void main(String args[])
 {
    // public String[]split(String reg)
    //以reg作为分隔符，获取分隔后的字符串数组
    String[] sArr = "1,100".split(",");
    System.out.println(sArr[0]+" "+sArr[1]);//1 100
    String[] sArr2 = "1,,100".split(",");
    System.out.println(sArr2[0]+" "+sArr2[1]);//1
 }
 
}

1.3 字符串与基本数据的相互转化

   //使用基本类型的包裹类提供的静态方法："parase类型"
	 Integer.parseInt("123");
	 Byte.parseByte("4");
	 Short.parseShort("5");
	 Long.parseLong("6");
	 Float.parseFloat("7.17");
	 Double.parseDouble("8.1888");

//将数值转化为字符串	 
 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);

 1.4 对象的字符串表示 

// Object类有一个 public String toString()方法，可以获得
    	// 该类对象的字符串表示。
    	public class TV{
    		String name;
    		public TV(){}
    		public TV(String s)
    		{
    			name = s;
    		}
    		public String toString()
    		{
    			String oldStr = super.toString();
    			return oldStr+"\n这是电视机，品牌是："+name;
    		}
       }

import java.util.Date;
public class test {
    public static void main(String args[])
    {
       Date date = new Date();
       System.out.println(date.toString());
       //Tue Apr 13 22:32:01 CST 2021
       TV tv = new TV("长虹电视");
       System.out.println(tv.toString());
       //test.TV@70dea4e
      // 这是电视机，品牌是：长虹电视
    	
    }
}

1.5 字符串与字符数组

//字符数组
//public void getChars(int start,int end,char c[],int offset)
//[start,end)
//必须保证数组c能容纳下要被拷贝的字符数
    String s="12345";
    char c[]=new char[8];
    s.getChars(0, 3, c, 0);
    for(int i=0;i<3;i++)
        System.out.println(c[i]);

package test;

import java.util.Date;

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

public class test {
	public static void main(String args[]) {
		byte d[] = "Java你好".getBytes();
		System.out.println("数组d的长度是:" + d.length);
		String s = new String(d, 6, 2);//汉字是两个byte,英文是一个byte
		System.out.println(s); // 输出：好
		s = new String(d, 0, 6);
		System.out.println(s); // 输出：Java你
	}
}

package test;

import java.util.Date;

public class test {
	public static void main(String args[]) {
		try
		{
			byte d[] = "Java你好".getBytes("GB2312");
		    System.out.println("1数组d的长度是："+d.length);
		    d="Java你好".getBytes("GBLK");
		    System.out.println("2数组d的长度是："+d.length);
		    d="Java你好".getBytes("UTF-8");
		    System.out.println("3数组d的长度是："+d.length);
		    //Unhandled exception type 必须放在try catch里面
		}catch(Exception e){};
		
	}
}

1.6 正则表达式

正则表达式：一些具有特殊含义字符的集合，它指定了字符串的匹配规则

[abc]:代表a、b、c中任何一个
[^abc]：代表a、b、c以外的任何一个
[a-zA-Z]：代表英文字母（大小写）中任意一个
[a-d]：代表字母a-d中任何一个
[a-d[m-p]]：代表a~d，或m~p中任何一个
[a-f&&[^bc]]:代表a、d、e、f中任何一个

public class bl {

	public static void main(String args[])
	{
		String str="abc123you你是谁?";
		String regex = "\\D+";
		//将形如"ab123you"中非数字字符全部剔除，得到字符串"123"
		str = str.replaceAll(regex, "");
		System.out.println(str);//123
	}
}

 1.7 StringTokenizer类

字符串分析器，能够从一个字符串中根据指定的分隔符拆分出若干单词

• StringTokenizer(String s) 使用默认分割符集合，即：空格符、换行符、回车符、Tab符、进纸符
•  StringTokenizer(String s, String delim) 指定分隔符集合，delim中的字符被作为分隔符
• 注意：delim中的任意字符组合都被看作一个分隔符。例如：delim="abc"那么："a", "b", "c", "ab", "ac", "bc", "abc", "bca", "bac", "cba", "cbaacc"……都被看作 一个分隔符。

常用方法

• String nextToken():逐个获取字符串中的单词
• boolean hasMoreTokens()：是否还有未析取的单词
• int countTokens()：统计剩余的单词数

package test;
import java.util.*;
public class bl {

	public static void main(String args[])
	{
		String s="Hello!I'm yaoming,nice to meet u!";
		StringTokenizer st=new StringTokenizer(s,"!,");
		while(st.hasMoreTokens())
		{
			System.out.print(st.nextToken()+'/');
			//Hello/I'm yaoming/nice to meet u/
		}
	}
}

public static void main(String args[])
	{
		String s="you are welcome(thank you),nice to meet you";
	    StringTokenizer fenxi=new StringTokenizer(s,"(),");
	    int number=fenxi.countTokens();
	    while(fenxi.hasMoreTokens())
	    {
	    	String str=fenxi.nextToken();
	    	System.out.println(str+"");
	    }
	    System.out.println("共有单词："+number+"个");
        //you are welcome
       //thank you
       //nice to meet you
       //共有单词：3个

	}

public static void main(String args[])
	{
		String s="you are welcome(thank you),nice to meet you";
	    StringTokenizer fenxi=new StringTokenizer(s,"(),");
	    int number=fenxi.countTokens();
	    while(fenxi.hasMoreTokens())
	    {
	    	String str=fenxi.nextToken();
	    	System.out.println(str+"");
	    }
	    System.out.println("共有单词："+number+"个");
       //you
       //are
       //welcome
       //thank
       //you
       //nice
       //to
       //meet
       //you
       //共有单词：9个
	}

1.8 Scanner类

import java.util.*;

• 解析从键盘输入的数据

nextBoolean()
nextByte()
nextShort()
nextInt()
nextLong()
nextFloat()
nextDouble()

next():以空格或回车键作为结束符
nextline()：以回车键作为结束符

public static void main(String args[])
	{
		System.out.println("请输入若干个数，每输入一个数回车确认");
		System.out.println("最后输入数字0结束输入操作");
		Scanner reader = new Scanner(System.in);
		double sum=0;
		double x=reader.nextDouble();
		while(x!=0)
		{
			sum+=x;
			x=reader.nextDouble();
		}
		System.out.println("sum="+sum);
	}

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

Scanner将空格作为分割标记来解析字符串中的单词。

– 调用next()方法依次返回字符串中的单词

– 调用hasNext()方法判断是否解析结束

– 对于解析出的数字单词，可以用nextInt()等转化为相应类型的数据

– 对于非数字单词，如果用nextInt()等方法会发生

InputMismatchException异常，在异常处理时可以调用next()方法返 回非数字化单词

public static void main(String args[])
	{
		String cost="TV costs 876 dollar.Computer costs 2398 dollar.telephone costs 1278 dollar";
		Scanner scanner =new Scanner(cost);
		double sum=0;
		while(scanner.hasNext())
		{
			try
			{
				double price=scanner.nextDouble();
				sum=sum+price;
				System.out.println(price);
			}
			catch(InputMismatchException exp)
			{
				String t=scanner.next();
			}
		}
		System.out.println("总消费:"+sum+"元");
//876.0
//2398.0
//1278.0
//总消费:4552.0元
	}

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

Scanner对象可以调用方法

useDelimiter(正则表达式)

package test;
import java.util.*;
public class bl {

	public static void main(String args[])
	{
	    String  cost="话费清单:市话费76.89元，长途话费：167.38元，短信费12.68元";
		Scanner scanner =new Scanner(cost);
		scanner.useDelimiter("[^0123456789.]+");
		double sum=0;
		while(scanner.hasNext())
		{
			try
			{
				double price=scanner.nextDouble();
				sum=sum+price;
				System.out.println(price);
			}
			catch(InputMismatchException exp)
			{
				String t=scanner.next();
			}
		}
		System.out.println("总消费:"+sum+"元");
//		76.89
//		167.38
//		12.68
//		总消费:256.95元
	}
}

 1.9 StringBuffer类

• String 对象是不可修改的，即String对象一旦创建，那么实体是不可以再发生变化的。
• 执行String的trim、replaceAll、subString等方法时，实质上是创建了一个新的实体，然后改变String对象的引用
• 如果一个字符串经常发生改变，显然会浪费大量内存
• StringBuffer类能创建可修改的字符串序列，也就是说，该类的对象的实体的内存空间可以自动的改变大小，适合存放一个可变的字符序列。

//构造方法
StringBuffer()：默认容量16个字符，可自动扩充
StringBuffer(int size)：指定容量size 
StringBuffer(String s)：容量为s的长度外加16个字符

//常用方法
append()：追加字符串，有许多重载方法
char charAt(int n)：获取指定位置字符
void setCharAt(int n,char c)：替换指定字符
StringBuffer insert(int n,String s)：插入字符串，将s插入到参数n指定的位置
StringBuffer reverse()：翻转字符串
StringBuffer delete(int start,int end)：删除指定位置范围的字符，从start到end-1
StringBuffer replace(int start,int end ,String s)：替换指定位置范围的字符，从start到end-1

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

2.时间和日期

引用类

java.util.Date  //表示日期

java.util.Calendar  //表示日历

java.text.DateFormat //日期显示格式

 public static void main(String args[])
 {
	 Date d=new Date();
	 //运行这个程序的时间
	 System.out.println(d);//Wed Apr 14 19:35:51 CST 2021
	 d.setYear(81);
	 d.setMonth(9);
	 d.setDate(24);
	 System.out.println(d);//Sat Oct 24 19:35:04 CST 1981
 }

import java.util.Date;
 public static void main(String args[])
 {
	 Calendar c=Calendar.getInstance();
	 //使用Calendar类的static方法getInstance()可以初始化一个日历对象
	 //默认指向当前时间
	 System.out.println(c.getTime());//Wed Apr 14 19:37:41 CST 2021
     // void set(int year,int month,int date);
	 // void set(int year,int month,int date,int hour,int minute,int second);
	 //void setTime(Date d);
	 c.set(2015,5,4);
	 //0代表1月
	 System.out.println(c.getTime());//Thu Jun 04 19:42:20 CST 2015
     c.set(194,4,10);
     //194代表公元194年
     System.out.println(c.getTime());//Fri May 10 19:43:51 CST 194
     c.setTime(new Date());
     System.out.println(c.getTime());//Wed Apr 14 19:43:51 CST 2021
     //获取日历的设定日期信息
     //calendar.get(Calendar.MONTH);
     System.out.println(c.get(c.MONTH));//输出是3,实际是3+1=4月份
     System.out.println(c.getTime());//Wed Apr 14 20:04:12 CST 2021
     System.out.println(c.getTimeInMillis());//1618401877194
     //返回长整数，表示距离1970年1月1日零时零分零秒的毫秒数
     
 }

public static void main(String args[])
 {
	Calendar calendar = Calendar.getInstance();
	int year = calendar.get(Calendar.YEAR);
	int month = calendar.get(Calendar.MONTH)+1;
	int day = calendar.get(Calendar.DAY_OF_MONTH);
	int hour = calendar.get(Calendar.HOUR_OF_DAY);
	int minute = calendar.get(Calendar.MINUTE);
	int second = calendar.get(Calendar.SECOND);
	System.out.print("现在时间是：");//现在时间是：2021年4月14日20时18分16秒
	System.out.print(""+year+"年"+month+"月"+day+"日");
	System.out.println(""+hour+"时"+minute+"分"+second+"秒");
	int y=2012,m=9,d=1;
	calendar.set(y,m-1,d);//将日历翻到2012年9月1日，注意8表示9
	long time1 = calendar.getTimeInMillis();
	y=2016;
	m=7;
	day=1;
	calendar.set(y,m-1,d);//将日历翻到2016年7月1日
	long time2 = calendar.getTimeInMillis();
	long subDay = (time2-time1)/(1000*60*60*24);
	System.out.println(""+new Date(time2));//Fri Jul 01 20:18:16 CST 2016
	System.out.println(""+new Date(time1));//Sat Sep 01 20:18:16 CST 2012
	System.out.println("相隔"+subDay+"天");//相隔1399天
 }

 public static void main(String args[])
 {
	//其他用法 add
	 Calendar c=Calendar.getInstance();
	 c.set(2001,0,1);
	 c.add(Calendar.MONTH, 1);
	 System.out.println(c.getTime());//Thu Feb 01 20:21:14 CST 2001
 }

 public int getIntervalDays(Calendar startday,Calendar endday)
	 {
		 if(startday.after(endday))
		 {
			 Calendar cal = startday;
		     startday = endday;
		     endday = cal;
		 }
		 long s1=startday.getTimeInMillis();
		 long e1=endday.getTimeInMillis(); 
		 long ei=el-sl;
		 return (int)(ei/(1000*60*60*24));
	 }

 public static void main(String args[])
 {
	 Calendar a=Calendar.getInstance();
	 a.set(2011, 05,28,19,50,2);//参数为年月日时分秒
	 Calendar b=Calendar.getInstance();
	 b.set(2011, 05,28,19,50,8);//参数为年月日时分秒
	 System.out.println(a.compareTo(b));//a比b早，返回-1
 }

//可以使用String类的静态方法format，对日期进行格式化
//format(格式化模式，日期列表)
格式化模式  String.format("%tY年%tm月%td日",new Date(),new Date(),new Date());
日期列表    String.format("%tY年%tm月%td日",new Date(),new Date(),new Date());
格式化同一日期 String.format("%tY年%tm月%td日",new Date());

3.Math类

import java.lang

两个静态变量：

E=2.718281828459045

PI=3.141592653589793

4.BigInteger类

import java.math

public BigInteger(String value)   

import java.math.*; 
public static void main(String args[])
 {
	double a=5.0;
	double st=Math.sqrt(a);
	System.out.println(a+"的平方根是："+st);//5.0的平方根是：2.23606797749979
	BigInteger result = new BigInteger("0");
	BigInteger one = new BigInteger("123456789");
	BigInteger two = new BigInteger("987654321");
	result = one.add(two);
	System.out.println("和："+result);和：1111111110
	result=one.multiply(two);
	System.out.println("积："+result);//积：121932631112635269
	
 }

5.Random类

import java.util

6.数字格式化

7.Pattern类和Matcher类

模式匹配 就是检索与指定模式匹配的字符序列

1. 建立Pattern模式对象
   1. Pattern pattern = Pattern.compile(regex);
      1. String regex="good";
      2. Pattern pattern = Pattern.compile(regex);
   2. Pattern pattern =Parrern.compile(regex,flags);
      1. flags取值为以下常量之一
2. 获取Matcher匹配对象：
   1. Matcher matcher = pattern.matcher(input);
      1. String input = "Hello,good moring";
      2. Matcher matcher=pattern.matcher(input);
3. 通过matcher匹配对象，调用各种方法检索input字符串  

         

import java.util.Calendar;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.math.*;
public class TEST {
 public static void main(String args[])
 {
	String input = "hello,good morning,this is a good idea";
	String regex = "good";
	Pattern p = Pattern.compile(regex);
	Matcher m= p.matcher(input);
	while(m.find())
	{
		String s=m.group();//与前一个匹配匹配的（可能为空）子序列，以字符串形式。
		System.out.println(s);
		int n1=m.start();
		int n2=m.end();
		System.out.println(n1+","+n2);
	}
 }
}