JAVA------String

来源：互联网发布：apache怎么读编辑：程序博客网时间：2024/04/20 04:57

一，String中常见功能

1，获取

1.1 字符串中包含的字符数，也就是字符串的长度

int length():获取长度。

1.2 根据位置获取位置上某个字符

int charAt(int index)：当访问到字符串中不存在的角标时，会发生StringIndexOutOfBoundException异常，角标超出异常

1.3 根据字符获取该字符在字符串中位置

int indexOf(int ch):返回字符串中第一次出现ch的位置

int indexOf(int ch,in fromIndex):从指定位置开始获取ch在字符串中的位置

int indexOf(String str):返回字符串中第一次出现str的位置

int indexOf(String str,in fromIndex):从指定位置开始获取str在字符串中的位置

int lastIndexof():反向索引

2，判断

2.1 字符串中是否包含某一个子串

boolean contains(String str);判断一个字符串中是否包含str

indexOf(String str):可以索引str第一次出现位置，如果返回-1，表示该str不在字符串中存在，所以，也可以用于对指定字符串判断是否包含

如： if(str.indexOf("aa")!=-1) 而且，该方法既可以判断子串是否存在与字符串，也可以获取出现的位置

2.2 字符串中是否有内容

boolean isEmpty();判断字符串的长度为多少，如果为0就返回

2.3 字符串是否是以指定内容开头

boolean startWith(String str);

2.4 字符串是否是以指定内容结尾

boolean endWith(String str);

2.5 判断字符串内容是否相同，复写了Object类中的equals方法

boolean equals(String str);

2.6 判断内容是否相同，并忽略大小写

boolean equalsIgnoreCase();

3，转换

3.1 将字符数组转变成字符串

构造函数：String(char [])

String(char[],int offset,int count);

静态方法：static String copyValueOf(char [])

static String copyValueOf(char[],int offset,int count);

static String valueOf(char [])

3.2 将字符串转换成字符数组

static char[] toCharArray();

3.3 将字节数组转变成字符串

String(byte[])

String(byte[] bytes, Charset charset)

String(byte[],int offset,int count)

String(byte[] bytes, int offset, int length, Charset charset)

3.4 将字符串转变成字节数组

byte[] getBytes(）;

byte[] getBytes(Charset charset);

特殊：字符串和字节数组在转换过程中，是可以指定编码表的

3.5 将基本数据类型转换成字符串

static String valueOf(int i);

static String valueOf(double d);

4，替换

String replace(char oldchar,char newchar);如果要替换的子串不存在，返回的还是原串

5，切割

String[] split(String regex);

6，子串，获取字符串中的一部分

String substring(int begin);从指定位置到末尾

String substring(int begin,int end);包含头，不包含尾

7，转换，去除空格，比较

7.1 将字符串转成大写或则小写

String toUpperCase();

String toLowerCase();

7.2 将字符串两端的多个空格去除

String tirm();

7.3 对两个字符串进行自然顺序的比较

int compareTo(String str);

二，String的特殊之处

1，创建对象的两种方式：构造函数和直接赋值（String s1="abc"）

class StringDemo
{
public static void main(String[] args) 
{
String s1="abv";//“abv”是一个对象
String s2=new String("abv");
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
}
}

分析：“s1==s2”输出的结果为false，“s1.equals(s2)”输出的结果是true，因为String类复写了Object类中的equals方法，该方法用来判断对象中的数据是否相同，前者是判断对象是否相同。

2，一旦初始化就不可以被改变

String s1="abv";//“abv”是一个对象
s1="abc";//相当于再创建一个“abc”的对象，“abv”对象没有被改变，任然还在

三，String的练习

1，模拟一个tirm方法，去除字符串两端的空格

/*
思路：
    1，判断字符串第一个位置是否是空格，如果是继续向下判断，知道不是空格为止，结尾处判断空格也是如此；
2，当开始和结尾都判断到不是空格时，就是要获取的字符串。
*/
public static void method_1(String str)
{
int start=0,end=str.length()-1;
char c[]=str.toCharArray();
while(str.charAt(start)==' '){
start++;
}
while(str.charAt(end)==' '){
end--;
}
System.out.println(str.substring(start,end+1));
}

2，将一个字符串进行反转，将字符串中指定部分进行反转，“abcdefg”--->“abfedcg”

/*
思路：
1，曾经学习过对数组的元素进行反转，将字符串变成数组，对数组反转；
2，将反转后的数组变成字符串；
3，只要将要反转的部分的开始和结束位置作为参数传递即可。
*/
public static void method_2(String str,int start,int end)
{
char[] chs=str.toCharArray();
reverse(chs,start,end);
System.out.println(new String(chs));
}
private static void reverse(char[] arr,int start,int end)//反转指定位置的字符串
{
int left=start,right=end;
while(left<right)
{
swap(arr,left,right);
left++;right--;
}
}
private static void swap(char c[],int left,int right)//交换值
{
char ch=c[left];
c[left]=c[right];
c[right]=ch;
}

3，获取一个字符串在另一个字符串中出现的次数

/*
思路：（如：abkkcdfkkadkjadkkskk）
1.定义一个计数器；
2,获取“kk”第一次出现的位置；
3,从第一次出现位置后剩余的字符串中继续获取“kk”出现的位置，没获取一次就计数一次；
4,当获取不到时，计数完成。
*/
public static int method_3(String str,String key)
{
int count=0,index=0;
while((index=str.indexOf(key,index))!=-1)
{
index=index+key.length();
count++;
}
return count;
}

4，获取两个字符串中最大相同子串

/*
思路：
1，将短的那个子串按照长度递减的方式获取到；
2，将每获取到的子串去长串中判断是否包含，如果包含，已找到。
*/
public static String method_4(String s1,String s2)
{
String max=s1.length()>s2.length()?s1:s2;
String min=s1.length()>s2.length()?s2:s1;
for(int i=0;i<min.length();i++)
{
for(int j=0,end=min.length()-i;end<=min.length();j++,end++)
{
String str=s1.substring(j,end);
if(s2.contains(str))
return str;
}
}
return null;
}

四，StringBuffer和StringBuilder

StringBuffer是字符串缓冲区，是一个容器。特点：长度是可以变化的；可以字节操作多个数据类型；最终会通过toString()方法变成字符串。

下面介绍StringBuffer的功能，包括： C create U update R read D delete

1，存储。

StringBuffer append():将制定数据作为参数添加到已有数据结尾处。

StringBuffer insert(int offset,Object obj):可以将数据插入到指定offset位置

2，删除。

StringBuffer delete(int start,int end):包含头不包含尾

StringBuffer deleteChartAt(int index):删除指定位置的字符

3，获取。

char charAt(int index);

int indexOf(String str);

int lastIndexOf(String str);

String substring(int start,int end);

int length();

4，修改。

StringBuffer replace(int start,int end,String str);

void setCharAt(int index);替换字符

5，反转

StringBuffer reverse();

6，将缓冲区中指定的数据存储到字符数组中

void getChars(int srcStart,int srcEnd,char[] dchar,int dStart)：将字符从此序列复制到目标字符数组 dchar。

JDK1.5版本之后出现了StringBuilder，StringBuffer是线程同步， StringBuilder是线程不同步的（开发建议使用StringBuilder）。将StringBuilder的实例用于多个线程是不安全的，如果需要这样的同步，则建议使用StringBuffer。

PS：JDK的升级三因素--->1，提高效率；2，简化书写；3，提高安全性。

五，基本数据类型对象包装类

1，常见基本数据类型的对象包装类(具备自动装箱功能)

byte--->Byte

short--->Short

int --->Integer

long ---> Long

boolean ---> Boolean

float ---> Float

double ---> Double

string --->String

char---> Character

特别的，有下面例子：

public class IntegerDemo_14 {
public static void main(String args[])
{
Integer i1=4;//自动装箱，相当远new Integer(4)
i1=i1+2;//i2+2:i2进行自定拆箱，变成int类型，和2进行加法运算
         //再进行装箱赋给i2
Integer m=128;
Integer n=128;
sop("m==n "+(m==n));
Integer a=127;
Integer b=127;
sop("a==b "+(b==a));//结果为true，因为a和b指向了同一个Integer对象
                    //因为当数值在byte范围内，对于新特性，如果该数值已经存在，则不会开辟新空间
Integer i=new Integer(123);
Integer j=new Integer("123");
sop("i==j "+(i==j));
sop("i.equals(j)"+i.equals(j));
}
private static void sop(Object obj) {
System.out.println(obj.toString());
}
}

分析：从输出结果分析，当Integer对象的数值在Byte范围内时，对于新版本的JDK，如果该数值已经存在，则不会开辟空间。

2，基本数据类型对象包装类的最常见作用

2.1基本数据类型转换成字符串

基本数据类型+""；

基本数据类型.toString(基本数据类型值)

String.valueOf(Object obj);

如：Integer.toString(34);

2.2字符串转成基本数据类型

int Integer.parseInt(String str);

xxx a=xxx.parsexxx(String);

如：int a=Integer.parseInt("123");

boolean b=Boolean.parseBoolean("true");

2.3进制转换

toBinaryString(int i);将十进制数转化成二进制

toHexString(int i);将十进制数转化成十六进制

toOctalString(int i);将十进制数转化成八进制数

parseInt(String str,int radix);将其他进制的数转化成十进制数

0 0