Java--常用类总结

String类：代表字符串，一旦初始化后不可改变，这个类被final所修饰，无法继承

 常用方法：
 1.获取：
 
 1.1获取字符串的长度：length();
 1.2根据角标获取这个角标上的字符：charAt(int index);
 1.3根据某个字符获取这个字符在字符串的位置
  int indexOf(int ch):返回的是字符在字符串中第一次出现的角标位置
  int indexOf(int ch,int index):从指定的index角标位置索引字符在字符串中第一次出现的角标位置
  int lastIndexOf(int ch):返回此字符在字符串中最后一次出现的角标位置
  int lastIndexOf(int ch,int lastIndex):返回此字符在字符串中最后一次出现的角标位置，从指定角标把握反向索引
 1.4根据子字符串获取这个子字符串在字符串中第一次出现的位置
  int indexOf(String st):返回st这个字符串在字符串中第一次出现的角标位置
  int indexOf(String st,in index):从指定位置开始索引，查找子字符串出现的位置
  int lastIndexOf(String st):返回子字符串在字符串中最后一次出现的位置
  int lastIndexOf(Stirng st,int index):从指定的index位置反向索引，返回子字符串在字符串中最后一次出现的角标位置
 1.5获取字符串的子串
  String substring(int begin):从指定的位置获取字符串中的子串
  String substring(int begin,int end):从指定的开始和结束位置获取子字符串(包含头不包含尾)
 
 2.判断：
 
 2.1判断字符串中是否包含指定子字符
  boolean contains(CharSequence st):返回true或false
 2.2判断字符串是否以指定的字符串开头(如果指定的字符串是空或和字符本身相同，则返回true)
  boolean startsWith(String start):返回true或false
 2.3判断字符串是否以指定的字符串结束
  boolean endsWith(String end):返回true或false
 2.4判断字符串是否相同
  boolean equals(Object str):
 2.5判断字符串是否相同忽略大小写
  boolean equalsIgnoreCase(String str):
  
 3.转换：
 
 3.1将字符数组转换成字符串
  构造函数：String(char[]);
 3.2将字符串转换成字符数组
  char[] toCharArray();
 3.3将字节数组转换成字符串
  构造函数：String(byte[]);
 3.4将字符串转换成字节数组
  byte[] getBytes();
 3.5将基本数据类型转换成字符串
  xxx String.valueOf(xxx);
 3.6将字符串转换成基本数据类型
  xxx Xxx.parseXxx(String);
 3.6将字符串两端的空格删除
  String trim();
  
 4.替换
  String replace(String old,String new):
 5.切割
  String[] split(regex):
 6.将字符串转换成大写或小写
  String toUpperCase():转换成大写
  String toLowerCase():转换成小写
 7.对两个字符串进行自然排序的比较
  int compareTo(String str):按字典顺序对二个字符串进行排序比较，大于参数字符串返回一个正数，等于返回0，
  小于返回一个负数
  
  
 示例：模拟String中的一些方法

class MyString{
			//去除字符串两端的空白
			/*
				先将字符串转换成数组，再对字符数组的首尾进行判断，
				用二个计数器进行统计首尾的空白数
			*/
			public static String myTrim(String str){
				char[] ch=str.toCharArray();
				int start=0;
				int end=ch.length-1;
				//这里要注意的是当for循环中没有执行体时可以用;来代替，不然这个语句是错误的
				for(;ch[start]==' '&&start<end;start++)
				;
				for(;ch[end]==' '&&start<end;end--)
				;
				return str.substring(start,end+1);
			}
			//将字符串反转
			/*
				分析：先将字符串转换成数组，再将数组的首尾进行交换
			*/
			public static String myReversal(String str){
				char[] ch=str.toCharArray();
				int start=0,end=ch.length-1;
				reversal(ch,start,end);
				String newstr=new String(ch);
				return newstr;
			}
			public static void reversal(char[] ch,int start,int end){
				for(;start<end;start++,end--)
					swap(ch,start,end);
			}
			public static void swap(char[] ch,int start,int end){
				char temp=ch[start];
				ch[start]=ch[end];
				ch[end]=temp;
			}
			
			
			//获取指定字符串在字符串中出现的次数
			/*
				分析：先判断这个字符串中是否有指定的字符串，如果有，记录下子字符串在字符串中出现的
				位置，第二次索引时就从这个位置加上子字符串的长度的位置开始索引，直到索引返回值为-1
			*/
			public static int myCount(String str,String str2){
				int count=0;
				int index=0;
				for(;(index=str.indexOf(str2,index))!=-1;index=index+str2.length())
					count++;
				return count;
			}
			//获取二个字符串中最大相同的子串
			public static String getMaxString(String str1,String str2){
				String max,min;
				if(str1.length()>str2.length()){
					max=str1;
					min=str2;
				}else{
					max=str2;
					min=str1;
				}
				int length=min.length()-1;
				String temp=min;
				while(!max.contains(temp)){
					temp=min.substring(length-1,length);
				}
				//System.out.println(a);
				return temp;
			}	
		}
		public class StringTest1{
			public static void main(String[] args){
				String str="lidaofulidaofulifuffg yferffulidds";
				String str2="lidaofufuldaso";
				String str1="daolilidaofu";
				System.out.println(MyString.getMaxString(str2,str1));
				System.out.println(MyString.myTrim(str));
				System.out.println(MyString.myReversal(str));
				System.out.println(MyString.myCount(str,str1));
			}

		}
		

 

StringBuffer类
 是字符串缓冲区，可以理解为一个容器，字符的长度是可变的
 常用方法：
 1.存储：
  StringBuffer append(数据):可以将指定数据类型的数据以字符串的形式追加到原有的数据末尾
  StringBuffer insert(index,数据):可以将数据插入到指定的index位置
 
 2.删除：
  StringBuffer delete(int start,int end):删除字符串中start到end位置的字符串，不包含end位置字符
  StringBuffer deleteCharAt(int index):删除指定位置的字符
  
 3.获取：
  char charAt(int index)  
  int indexOf(String str)
  int lastIndexOf(String str)
  String substring(int start, int end)
 
 4.修改：
  StringBuffer replace(int start,int end,String str):
  void setCharAt(int index,char ch);
 
 5.反转：
  StringBuffer reverse();将此字符序列用其反转形式取代
  
 StringBuffer与StringBuilder区别
 StringBuffer线程同步，在多线程中是安全的，效率低
 StringBuilder线程不同步，多线程中不安全，效率高，JDK1.5之后出现

 

import java.util.*;
		public class StringSort{
			/*
				需求：将一个字符串按如下形式输出
					eg:String str="abcabcdef" 输出形式：a(2)b(2)c(2)d(1)e(1)f(1)
				分析：因为要对单个字符操作，所以首先要将字符串变成字符数组；
					而输出的形式存在着键值之间的映射关系，所以可以考虑用map集合或数组来解决；
					又因为数组中操作的是明确的键值关系，所以不宜使用；因而可以用map集合来解决了
					map集合中不能存入相同的元素，所以可以一个个的试着将单个字符存入集合中，用一个变量来记录存入元
					素的次数；如果集合中能存入这个元素则表示集合中没有这个元素，则存入元素和次数；如果不能存入
					则表示集合中有这个元素，则可以将次数加1后再将元素存入
			*/
			public static void main(String[] args){
				String str="abcadiegbcbc";
				String newStr=sort(str);
				System.out.println(newStr);
			}
			
			//向集合中存入元素和元素出现的次数
			public static String sort(String str){
				char[] chs=str.toCharArray();
				HashMap<Character,Integer> hm=new HashMap<Character,Integer>();
				for(int i=0;i<chs.length;i++){
					if(!hm.containsKey(chs[i])){
						hm.put(chs[i],1);
					}else{
						int value=hm.get(chs[i]);
						hm.put(chs[i],value+1);
						}
				}
				return toStr(hm);
			}
			//将集合中的元素转换成指定的输出格式
			public static String toStr(HashMap<Character,Integer> hm){
			//建立可变字符的字符串
				StringBuffer sb=new StringBuffer();
				Set<Map.Entry<Character,Integer>> se=hm.entrySet();
				Iterator<Map.Entry<Character,Integer>> it=se.iterator();
				while(it.hasNext()){
					Map.Entry<Character,Integer> me=it.next();
					Character key=me.getKey();
					Integer value=me.getValue();
					//向可变字符串中加入字符
					sb.append(key+"("+value+")");
				}
				return sb.toString();
			}
		}

包装类：
 基本数据类型对应的包装类
 byte  Byte
 short  Short
 int  Integer
 long  Long
 float  Float
 double  Double
 char  Character
 
 字符串转成基本数据类型：xxx a = Xxx.parseXxx(String)
 示例：

public class IntegerTest{
		public static void main(String[] args){
			Integer it=34;//自动装箱，new Integer(34);
			Integer in=new Integer(45);
			int x=it+4;//先自动拆箱，it.inValue(),两数相加后再将和进行装箱
			
			Integer i=127;
			Integer j=new Integer(127);
			Integer k=127;
			
			Integer y=128;
			Integer z=128;
			System.out.println(i==j);
			System.out.println(i==k);//true,在byte所能表示的范围内，如果该值已经存在，则不会开辟新空间
			System.out.println(y==z);//false,如果不在byte所能表示的范围，则会开辟新的空间
			System.out.println(it);
			System.out.println(in);
		}
	}

Date类：表示特定的瞬间，精确到毫秒
SimpleDateFormat：是一个以与语言环境有关的方式来格式化和解析日期的具体类

示例：
		import java.text.*;
		import java.util.*;
		public class DateTest{
			public static void main(String[] args){
				Date d=new Date();
				//将模式封闭到SimpleDateFormat对象中
				SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月第W周dd日E hh:mm:ss");
				//对日期进行格式化
				String time=sdf.format(d);
				System.out.println(time);
			}
		}

 

Collections类：集合工具类，此类完全由在 collection 上进行操作或返回 collection 的静态方法组成
 常用方法：
 static <T> void fill(List<? super T> list, T obj)：使用指定元素替换指定列表中的所有元素 
 static <T> boolean replaceAll(List<T> list, T oldVal, T newVal):使用另一个值替换列表中出现的所有某一指定值
 static void reverse(List<?> list):反转指定列表中元素的顺序
 static <T> Comparator<T> reverseOrder():返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
 static <T> Comparator<T> reverseOrder(Comparator<T> cmp):返回一个比较器，它强行逆转指定比较器的顺序
 static <T extends Comparable<? super T>> void sort(List<T> list):根据元素的自然顺序 对指定列表按升序进行排序
 static <T> void sort(List<T> list, Comparator<? super T> c):根据指定比较器产生的顺序对指定列表进行排序。
 static void swap(List<?> list, int i, int j)：在指定列表的指定位置处交换元