一、字符串
字符串可以分为两大类:String类, StringBuffer和StringBuilder
1.String类:创建之后不会再做修改和变动。
/*String类的三种构造函数演示*/
public class StringConstructorDemo {
public static void main(String[] args){
StringConstructorDemo();
}
public static void StringConstructorDemo(){
String s = new String(); //等效于String s = "";不等效于String s = null;
//构造函数: String(byte[] bytes)
byte[] arr1 = {65, 66, 67, 68};
String s1 = new String(arr1);
System.out.println("s1 = " + s1); //s1 = ABCD
//构造函数: String(char[] value)
char[] arr2 = {'w', 'a', 'p', 'q', 'x'};
String s2 = new String(arr2);
System.out.println("s2 = " + s2); //s2 = wapqx
//构造函数: String(char[] value, int offset, int count)
String s3 = new String(arr2, 1, 3);
System.out.println("s3 = " + s3); //s3 = apq
}
}
String类的方法(按功能分):
a.能创建并返回一个新的String对象实例: concat, replace, replaceAll, substring, toLowerCase, toUpperCase, trim,toString.
b.查找: endsWith, startsWith, indexOf,,lastIndexOf.
c.比较: equals, equalsIgnoreCase,
d.字符及长度: charAt ,length.
Jdk1.5 增加了format函数: %序号$ 标识 宽度及精度 转换方式
String类的 matches, replaceAll, split可以使用正则表达式
public class StringMethodDemo {
public static void main(String[] args){
StringMethodDemo();
}
public static void StringMethodDemo(){
String s = new String("abcdabe");
System.out.println("length = "+s.length()); //获取字符串长度
//查找
System.out.println("char: "+s.charAt(2)); //根据位置获取字符
System.out.println("index: "+s.indexOf('a')); //获取字符在字符串中第一次出现的位置
System.out.println("index: "+s.indexOf('a', 1)); //从指定位置开始查找字符在剩余字符串中第一次出现的位置
System.out.println("string: "+s.indexOf("ab")); //获取指定字符串在字符串中第一次出现的位置
System.out.println("string: "+s.indexOf("ab", 2)); //从指定位置开始查找指定字符串在剩余字符串中第一次出现的位置
System.out.println("lastIndex: " +s.lastIndexOf('a')); //获取字符在字符串中最后一次出现的位置
//获取子串
System.out.println("substring: " +s.substring(2));
System.out.println("substring: " +s.substring(2,5)); //右端点取不到
//转换
String ss = "Amy. Lily. Henry";
String[] arr = ss.split("\\."); //将字串变成字符串数组(切割): String[] split(String regex);
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i]);
}
System.out.println();
char[] chs = ss.toCharArray(); //将字符串变成字符数组
for(int i = 0; i < chs.length; i++){
System.out.print(chs[i]);
}
System.out.println();
byte[] bytes = ss.getBytes(); //将字符串变成字节数组
for(int i = 0; i < bytes.length; i++){
System.out.print(bytes[i]+" ");
}
System.out.println();
System.out.println( "Abcde".toUpperCase()); //字符串中的字母转换成大写
System.out.println( "aBCDE".toLowerCase()); //字符串中的字母转换成小写
//替换
String s1 = "Hello World";
System.out.println(s1.replace('o', 'a')); //String replace(char oldCh,char newCh);
System.out.println(s1.replace("llo", "y!")); //String replace(string oldStr,string newStr);
//去除字符串两端空格
System.out.println( "-" + " ab c " .trim() + "-"); //String trim();
//连接
System.out.println( "I love ".concat("CS" )); //String concat(String str); 与"+"效果一致但效率更高
//将其他类型数据转换成字符串
System.out.println(String.valueOf(34)+1);
//判断
System.out.println(s1.equalsIgnoreCase("HELLO WORLD")); //忽略大小写比较字符串内容
System.out.println(s1.contains("llo")); //判断字符串中是否包含指定字符串
System.out.println(s1.startsWith("He")); //字符串是否以指定字符串开头,结尾
System.out.println(s1.endsWith("ld"));
//比较 int compareTo(String str);
System.out.println("ab" .compareTo("A")); //按字典序比较,如果相等返回0.
//返回字符串对象的规范化表示形式 String intern();
String s2 = new String("abc");
System.out.println(s2 == s2.intern()); //false (用equals(Object)方法判断)
}
}
/*
* 统计一个子串在整串中出现的次数
*/
public class StringTest{
public static void main(String[] args){
String str = "nbaernbatynbauinbaopnba";
String key = "nba";
int count = getKeyStringCount(str, key);
System.out.println("count = "+count);
}
public static int getKeyStringCount(String str, String key){
int count = 0;
int index = 0;
//用indexOf获取字串在字符串中出现的位置,如果找不到返回-1,跳出while循环
while((index = str.indexOf(key))!=-1){
//每找到一个字串,就把剩余字符串(substring(出现位置+子串的长度))赋给str变量,继续查找str。
str = str.substring(index + key.length());
count ++ ;
}
return count;
}
}
/*获取两个字符串中最大相同的子串*/
public class StringTest2 {
public static void main(String[] args){
String s1 = "qwerabcdtyuiop";
String s2 = "xcabcdvbn";
String s = getMaxSubstring(s1, s2);
System.out.println("s = " + s);
}
public static String getMaxSubstring(String s1, String s2){
String max = null, min = null;
//max存入较长的字符串,min存入较短的字符串
max = (s1.length() > s2.length())? s1:s2;
min = max.equals(s1)? s2:s1;
//将短的字符串依长度递减,每次递减都判断max中是否包含该长度的各种字串组合(通过a++,b++实现)。
for(int i = 0; i < min.length(); i ++){
//a代表子串的开始位置,b代表子串的结束位置。
for(int a = 0, b = min.length()-i; b != min.length()+1; a++,b++){
String sub = min.substring(a,b); //获得子串
if (max.contains(sub)) //判断max中是否包含子串
return sub;
}
}
return null;
}
}
/*
* 模拟一个trim功能方法,去除字符串两端的空白。
*/
public class StringTest3 {
public static void main(String[] args){
String s = " ab c ";
s = myTrim(s);
System.out.println("-"+s+"-");
}
public static String myTrim(String s){
int start = 0, end = s.length()-1;
//从头开始判断字符是否是空格
while(start <= end && s.charAt(start) == ' '){
start++;
}
//从尾开始判断字符是否是空格
while(start <= end && s.charAt(end) == ' '){
end--;
}
return s.substring(start, end+1);
}
}
/*
* 将一个字符串翻转
*/
public class StringTest4 {
public static void main(String[] args){
String s = "Hello World";
System.out.println("Before: "+ s);
System.out.println("After: "+ reverseStr(s));
}
public static String reverseStr(String s){
//将2字符串转换为字符数组,以便于交换
char[] ch = s.toCharArray();
//同时从头和尾开始遍历字符数组,交换头尾元素
for(int start = 0, end = s.length()-1; start < end; start++, end--){
char temp = ch[start];
ch[start] = ch[end];
ch[end] = temp;
}
//将字符数组转换为字符串
return new String().valueOf(ch);
}
}
2.StringBuffer和StringBuilder:创建之后允许再做更改和变化
StringBuffer类对象保存可修改的Unicode字符序列。在JDK1.5版本之后出现了 StringBuilder,StringBuilder与StringBuffer类似,它效率更高,不考虑线程安全性。 > StringBuffer:线程同步,有锁,效率低,用于但多线程
StringBuilder:线程不同步,无锁,效率高,用于单线程
下面详细说一说StringBuffer。
1)特点:a. 长度是可变的。(数组是固定长度)
b. 可以存储不同类型数据。(数组只能操作一种类型)
c. 最终要转成字符串进行使用。
2)构造方法
StringBuffer()
StringBuffer(int capacity)
StringBuffer(String initialString)
3)StringBuffer类的方法:append, insert, reverse, setCharAt, setLength
public class bufferMethodDemo {
public static void main(String[] args){
bufferMethod();
}
public static void bufferMethod(){
StringBuffer sb = new StringBuffer();
//添加
sb.append(4).append(5);
sb.insert(1,"numbernumber");
System.out.println(sb);
//删除
sb.delete(1,3); //StringBuffer delete(int start,int end):删除[start,end)元素
sb.deleteCharAt(2); //StringBuffer deleteCharAt(int index):删除指定位置的元素。
System.out.println(sb);
//查找
System.out.println(sb.charAt(3)); //char charAt(int index); 查找角标为index的字符
System.out.println(sb.indexOf("er")); //int indexO(String str); 查找字符串str首次出现的位置
System.out.println(sb.lastIndexOf("er")); //int lastIndexOf(String str); 查找字符串str最后一次出现的位置
//修改
sb.replace(0, 3, "reqlace"); //StringBuffer replace(int start,int end,String str);
System.out.println(sb);
sb.setCharAt(2, 'p');
System.out.println(sb); //void setCharAt(int index,char ch);
//设置、获取长度
//setLength:若小于其长度,则清除缓冲区中的一部分。若大于其长度,则扩充缓冲区,扩充部分空格填充。
//当创建的StringBuffer内容长度大于16,会创建一个新数组,长度比旧数组要长。把旧数组的内容拷贝到新数组。
sb.setLength(7);
System.out.println(sb+"--Length: "+sb.length());
//反转
System.out.println(sb.reverse());
}
}
/*
* 实例:将一个int数组变成字符串
*/
public class StringBuilderTest {
public static void main(String[] args){
int[] arr = {3, 1, 5, 4, 6};
String s = arrayToString(arr);
System.out.println(s);
}
public static String arrayToString(int[] arr){
StringBuilder sb = new StringBuilder();
sb.append("[");
for(int i = 0; i < arr.length; i++){
if(i != arr.length-1)
sb.append(arr[i]).append(",");
else
sb.append(arr[i]).append("]");
}
return sb.toString();
}
}
4)扩充知识
java.util.StringTokenizer类提供了对字符串进行分割的功能。
构造:StringTokenizer(String str, String delim);
该类的重要方法有:
public int countTokens();// 分割串的个数
public boolean hasMoreTokens();// 是否还有分割串
public String nextToken();// 得到下一分割串
二、基本数据类型对象包装类
1.概述
Java的基本数据类型用于定义简单的变量和属性将十分方便,但为了与面向对象的环境一致,Java中提供了基本数据类型的包装类(wrapper),它们是这些基本类型的面向对象的代表。
与8种基本数据类型相对应,基本数据类型的包装类也有8种,分别是:Character,Byte,Short,Integer,Long,Float,Double,Boolean。
2.特点
1)这些类都提供了一些常数:如Integer.MAX_VALUE(整数最大值), Double.NaN(非数字),Double.POSITIVE_INFINITY(正无穷)等。
2)提供了valueOf(String),toString():用于从字符串转换及或转换成字符串。
3)通过xxxxValue()方法可以得到所包装的值:如Integer对象的intValue()方法。
4)对象中所包装的值是不可改变的(immutable)。要改变对象中的值只有重新生成新的对象。
5)toString(), equals()等方法进行了覆盖。
- 除了以上特点外,有的类还提供了一些实用的方法以方便操作。例如,Double类就提供了parseDouble(), max, min方法等。
3.用途
主要用于基本类型和字符串之间的转换,其次就是十进制的转换。
1)基本类型–>字符串
a. 基本类型数值+""
b. 基本数据类型.toString(基本类型数值);
2)字符串–>基本类型
a. 使用包装类中的静态方法xxx parseXxx(“xxx”);
int parseInt(String str);
long parseLong(String str);
boolean parseBoolean(String str);
只有Character没有parse方法。
b. 如果字符串被Integer进行对象的封装,可使用另一个非静态的方法,intValue。
将一个Integer对象转成基本数据类型值。
c. 用Integer的静态方法valueOf(String s);
3)十进制–>其他进制
String toBinaryString(int i);
String toOctalString(int i);
String toHexString(int i);
String toString(int i,int radix);
4)其他进制–>十进制
int parseInt(String s, int radix);
public class WrapperDemo {
public static void main(String[] args){
//整型最大值
System.out.println(Integer.MAX_VALUE); //2147483647
//基本类型-->字符串
Integer i = new Integer(5);
System.out.println(i+"");
System.out.println(Integer.toString(12));
//字符串-->基本类型
Integer ii = new Integer("123");
System.out.println(ii.intValue()); //123
System.out.println(Integer.parseInt("123")+1); //124
System.out.println(Long.parseLong("123456789012345678")+1); //123456789012345679
System.out.println(Boolean.parseBoolean("true")); //true
System.out.println(Integer.parseInt("123")+1); //124
//十进制-->其他进制
System.out.println(Integer.toBinaryString(60)); //111100
System.out.println(Integer.toOctalString(60)); //74
System.out.println(Integer.toHexString(60)); //3c
System.out.println(Integer.toString(60, 16)); //3c
}
}
/*
* 对一个字符串中的数值进行从小到大的排序
*/
import java.util.Arrays;
public class WrapperTest {
private static final String SPACE_SEPARATOR = " ";
public static void main(String[] args){
String numStr = "20 79 9 -7 88 36 29";
System.out.println(numStr);
System.out.println(sortNumStr(numStr));
}
public static String sortNumStr(String numStr){
//将字符串变成字符数组
String[] str_arr = stringToArray(numStr);
//将字符串数组变成int数组
int[] num_arr = toIntArray(str_arr);
//对int数组排序
mySortArray(num_arr);
//将排序后的int数组变成字符串
String finalStr = arrayToString(num_arr);
return finalStr;
}
public static String[] stringToArray(String numStr){
String[] str_arr = numStr.split(SPACE_SEPARATOR);
return str_arr;
}
public static int[] toIntArray(String[] str_arr){
int[] num_arr = new int[str_arr.length];
for(int i = 0; i < str_arr.length; i++){
num_arr[i]=Integer.parseInt(str_arr[i]);
}
return num_arr;
}
public static void mySortArray(int[] num_arr){
Arrays.sort(num_arr);
}
public static String arrayToString(int[] num_arr){
StringBuilder sb = new StringBuilder();
for (int i = 0; i < num_arr.length; i++){
if(i != num_arr.length-1)
sb.append(num_arr[i]+SPACE_SEPARATOR);
else
sb.append(num_arr[i]);
}
return sb.toString();
}
}