------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
第一讲 String类
一、概述
String是字符串的类类型,用于描述字符串事物,字符串是一个特殊的对象。
特殊之处就在于:String s = new String(); String s1 = " ";两种写法都是在创建对象,使用起来一样。
二、特点
字符串最大的特点:一旦被初始化就不可以被改变。
例:
String s1=“abc”;
String s2 = new String(
“abc”);
String s3 = "abc";
比较的结果:
s1==s2 ( false )
s1.equals(s2) ( true ) //String类复写了Object类中的equals方法,该方法用于判断字符串是否相同。
s1==s3 ( true ) //因为“abc”这个字符串对象已经在内存中存在,作为字符串这种特殊的对象,这种在常量池中存在的数据。s3进行初始化时,发现abc已经在内存中存在,就不会再独立开辟空间,因为再开辟空间就比较浪费空间。因此为了节约内存,在字符串对象当中只要字符串相同,那么s1和s3就指向同一个对象。
s1和s2的区别:
s1在内存中有一个对象。
s2在内存中有两个对象。
三、常见操作方法
1、获取
1.1字符串中包含的字符数,也就是字符串的长度
int length()://获取长度。
1.2根据位置获取位置上的某个字符
char charAt(int index)://当访问到字符串中不存在的角标时,会发生字符串角标越界的错误。
1.3根据字符获取该字符存在字符串的位置
int indexOf(int ch)://返回的是ch在字符串中第一次出现的位置。//传入的是字符对应的ASCII码。//如果没有找到,返回-1。
int indexOf(int ch,int fromIndex)://从fromIndex指定位置开始,获取ch在字符串中出现的位置。
int indexOf(String str)://返回的是str在字符串中第一次出现的位置。
int indexOf(String str,int fromIndex)://从fromIndex指定位置开始,获取str在字符串中出现的位置。
int lastIndexOf()://反向索引
2、判断
2.1字符串中是否包含某一个子串
booleancontains(str); //特殊之处:indexOf(str)可以索引str第一次出现的位置,如果返回-1表示该str不在字符串中存在。所以,也可以用于对指定判断是否包含。如:if(str.indexOf(“aa”)!=-1)而且该方法既可以判断,又可以获取出现的位置。如果只为判断,用contains。
2.2字符串中是否有内容
booleanifEmpty();//原理就是判断长度是否为0。
2.3字符串是否是以指定内容开头
booleanstartsWith(str);
2.4字符串是否是以指定内容结尾
booleanendsWith(str);
2.5判断字符串内容是否相同,复写了Object类中的equals方法
booleanequals(str);
2.6判断内容是否相同,并忽略大小写。
booleanequalsIgnoreCase();
3、转换
3.1将字符数组转成字符串
构造函数:
String (char[]);
String(char[],offset,count);//将字符数组中的一部分转成字符串。
静态方法:
static String copyValueOf(char[]);
staticString copyValueOf(char[] data,int offset ,int count );
static String valueOf(char[]);
3.2 将字符串转成字符数组。**
char[] toCharArray():
3.3 将字节数组转成字符串。
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串。
3.4 将字符串转成字节数组。
byte[] getBytes():
3.5 将基本数据类型转成字符串。
static String valueOf(int)
static String valueOf(double)
特殊:字符串和字节数组在转换过程中,是可以指定编码表的。
4、替换
String replace(oldchar,newchar);
5、切割
String[] split(regex);
6、子串。获取字符串中的一部分。
String substring(begin);
String substring(begin,end);
7、转换,去除空格,比较。
7.1 将字符串转成大写或者小写。
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除。
String trim();
7.3 对两个字符串进行自然顺序的比较。
int compareTo(string);
练习一:
/*模拟一个trim方法,去除字符串两端的空格。
思路:
1,判断字符串第一个位置是否是空格,如果是继续向下判断,直到不是空格为止。
结尾处判断空格也是如此。
2,当开始和结尾都判断到不是空格时,就是要获取的字符串。
*/
class TrimTest
{
public static void main(String[] args)
{
String s = " ab cd ";
sop("("+s+")");
s = myTrim(s);
sop("("+s+")");
}
public static String myTrim(String str)
{
int start = 0,end = str.length()-1;
while(start<=end && str.charAt(start)==' ')
start++;
while(start<=end && str.charAt(end)==' ')
end--;
return str.substring(start,end+1);
}
public static void sop(String str)
{
System.out.println(str);
}
}
结果:
练习二:
/*
获取一个字符串在另一个字符串中出现的次数。
"abkkcdkkefkkskk"
思路:
1、定义个计数器。
2、获取kk第一次出现的位置。
3、从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
每获取一次就计数一次。
4、当获取不到时,计数完成。
*/
class GetCountTest
{
public static int getSubCount(String str,String key)
{
int count = 0;
int index = 0;
while((index= str.indexOf(key,index))!=-1)
{
sop("index="+index);
index = index + key.length();
count++;
}
return count;
}
public static void main(String[] args)
{
String str = "Hello World all";
sop("count="+getSubCount(str,"ll"));
}
public static void sop(String str)
{
System.out.println(str);
}
}
结果:
练习三:
/*将字符串反转。
思路:
1,将字符串变成数组。
2,对数组反转。
3,将数组变成字符串。
*/
class ReverseTest
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s = " ab cd efg";
sop("("+s+")");
sop("("+reverseString(s)+")");
}
public static String reverseString(String s,int start,int end)
{
//字符串变数组。
char[] chs = s.toCharArray();
//反转数组。
reverse(chs,start,end);
//将数组变成字符串。
return new String(chs);
}
//反转整个字符串
public static String reverseString(String s)
{
return reverseString(s,0,s.length());
}
//反转指定字符数组位置
private static void reverse(char[] arr,int x,int y)
{
for(int start=x,end=y-1; start<end ; start++,end--)
{
swap(arr,start,end);
}
}
//交换相应数组元素
private static void swap(char[] arr,int x,int y)
{
char temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
结果:
练习四:
/*
获取两个字符串中最大相同子串。第一个动作:将短的那个串进行长度一次递减的子串打印。
"abcwerthelloyuiodef"
"cvhellobnm"
思路:
1、将短的那个子串按照长度递减的方式获取到。
2、将每获取到的子串去长串中判断是否包含,
如果包含,已经找到!。
*/
class MaxSubStringDemo
{
public static String getMaxSubString(String s1,String s2)
{
String max = "",min = "";
max = (s1.length()>s2.length())?s1: s2;//判断大字符串
min = (max==s1)?s2: s1;//判断小字符串
for(int x=0; x<min.length(); x++)//控制在最短子串长度内
{
for(int y=0,z=min.length()-x; z!=min.length()+1; y++,z++)//依次递减短字符串子串
{
String temp = min.substring(y,z);//获取短字符串子串
sop(temp);
if(max.contains(temp))//如果长串包含则表示找到 if(max.indexOf(temp)!=-1)
return temp;
}
}
return "";
}
public static void main(String[] args)
{
String s1 = "abcwerthelloyuiodef";
String s2 = "cvhellobnm";
sop(getMaxSubString(s2,s1));
}
public static void sop(String str)
{
System.out.println(str);
}
}
结果:
第二讲 StringBuffer
一、概述
StringBuffer是字符串缓冲区。是一个容器。StringBuffer可以对字符串内容进行增删。很多方法与String相同。
二、特点
1、长度是可变化的。
2、可以直接操作多个数据类型。
3、最终会通过toString方法变成字符串。
三、常见操作
1、存储
StringBuffer append():将指定数据作为参数添加到已有数据结尾处。
StringBuffer insert(index,数据):可以将数据插入到指定index位置。
2、删除
StringBuffer delete(start,end):删除缓冲区中的数据,包含start,不包含end。
StringBuffer deleteCharAt(index):删除指定位置的字符。
3、获取
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start, int end)
4、修改
StringBuffer replace(start,end,string);
void setCharAt(int index, char ch) ;
5、反转
StringBuffer reverse();
6、将缓冲区中指定数据存储到指定字符数组中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
JDK1.5 版本之后出现了StringBuilder.
StringBuffer和StringBuilder的区别:
StringBuffer是线程同步,安全的,效率低。
StringBuilder是线程不同步,不安全的,效率高。
开发建议使用:StringBuilder
升级的三个因素:
1、提高效率。
2、简化书写。
3、提高安全性。
第三讲 基本数据类型包装类
将基本数据类型封装成对象的好处在于可以在 对象中定义更多的功能方法操作该数据。常用的操作之一:用于基本数据类型与字符串 之间的转换。
一、基本数据类型包装类
byte
Byte
short
Short
int
Integer
long
Long
boolean
Boolean
float
Float
double
Double
char
Character
二、基本数据类型转成字符串
基本数据类型+""
基本数据类型.toString(基本数据类型值);
如:Integer.toString(34);//将34整数变成"34";
三、字符串转成基本数据类型
xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("123");
double b = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
Integer i = new Integer("123");
int num = i.intValue();
注意:在使用时,Integer x = null,上面的代码就会出现NullPointerException
四、十进制转成其他进制
toBinaryString();
toHexString();
toOctalString();
五、其他进制转成十进制
parseInt(string,radix);
如:int x = Integer.parseInt("3c",16);
JDK1.5版本以后出现的新特性
Integer x = new Integer(4);等效于Integer x = 4;//自动装箱
还可以直接进行运算:x = x/* x.intValue() */ + 2;//x+2:x 进行自动拆箱。变成了int类型。和2进行加法运算。再将和进行装箱赋给x。
六、示例
Integer m = 128;
Integer n = 128;
m==n ( false)
Integer n = 128;
m==n ( false)
Integer a = 127;
Integer b = 127;
a==b ( true)
原因:因为m和n指向了同一个Integer对象,当数值在byte范围内,对于新特性,如果该数组已经存在,则不会开辟新的空间。
七、练习
/*
"12 0 99 -7 30 4 100 13 -6"
要求对字符串中的数值进行排序。生成一个数值从小到大新字符串
"-7 -6 0 4 12 13 30 99 100"
思路:
1、将字符串切割为字符串数组
2、将字符串数组转换为整数类型数组
3、对整数类型数组进行冒泡排序
4、将排序后的整数类型数组转换为字符串
*/
class StringSort
{
public static void main(String[] args)
{
String s = "12 0 99 -7 30 4 100 13 -6";
sop(s);
sop(stringSort(s));
}
public static String stringSort(String s)
{
//将字符串切割成字符串数组
String[] str = s.split(" ");
//将字符串数组转换为整数类型数组
int[] arr =stringToInt(str);
//对整数类型数组进行冒泡排序
bubbleSort(arr);
//将排序后的整数类型数组转换为字符串
return intToString(arr).toString();
}
//将字符串数组转换为整数类型
private static int[] stringToInt(String[] str)
{
int[] arr = new int[str.length];
for(int x=0;x<str.length;x++)
{
arr[x] = Integer.parseInt(str[x]);
//sop(arr[x]);
}
//sop(arr);
return arr;
}
//对数组进行冒泡排序
private static void bubbleSort(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
for(int y=0;y<arr.length-x-1;y++)
{
if(arr[y]>arr[y+1])
swap(arr,y,y+1);
}
}
//sop(arr);
}
//交换数组中的两元素
private static void swap(int[] arr,int x,int y)
{
arr[x] = arr[x]^arr[y];
arr[y] = arr[x]^arr[y];
arr[x] = arr[x]^arr[y];
// int temp = arr[x];
// arr[x] = arr[y];
// arr[y] = temp;
}
//将整数类型数组存放到一个StringBuilder容器中
private static StringBuilder intToString(int[] arr)
{
StringBuilder sb = new StringBuilder();
for(int x=0;x<arr.length-1;x++)
{
sb.append(arr[x]+" ");
}
sb.append(arr[arr.length-1]+"");
return sb;
}
//打印字符串
private static void sop(Object obj)
{
System.out.println(obj);
}
//遍历数组
private static void sop(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
System.out.println(arr[x]+"\t");
}
System.out.println();
}
}
结果: