JAVA学习代码——字符串操作

注意：字节用的是单引号，字符用的是双引号

1.字符串比较

2.字符串截取

3.字符串的计算（空格，字符等个数）

4.字符串操作：截取，拆分，统计

5.字符串相关方法：搜索，修改等

6.String和StringBuffer，StringBuilder的区别比较

字符串比较

package 字符串;
/**
* 1.equals和==的区别
* 2.equals和equalsIgnoreCase( )
* 3.regionMatches( )   startsWith()  endsWith()
* 4.compareTo()比较
*
*/

public class Equalsbijiao {

//java中equals和==的区别    =========>>>>>>java中equals和==的区别.doc
//==比较的是2个对象的地址，而equals比较的是2个对象的内容
public  void bijiao() {
String s1 = "Monday";
String s2 = "Monday";
s2 = new String("Monday");// 将 s2 用 new 操作符创建
s2 = s2.intern();
/*（java.lang.String的intern()方法 "abc".intern()方法的返回值还是字符串"abc"表面上看起来好像
* 这个方法没什么用处。但实际上，它做了个小动作：   检查字符串池里是否存在"abc"这么一个字符串，如果存在，就
* 返回池里的字符串；如果不存在，该方法会把"abc"添加到字符串池中，然后再返回它的引用。更好的办法：把所有
* 的String都intern()到缓冲池去吧,最好在用到new的时候就进行这个操作
* String s2 = new String("Monday").intern();然后就可以用==比较两个字符串的值了*/
if (s1 == s2)
System.out.println("s1 == s2");/*输出：s1 == s2
说明：s1 与 s2 引用同一个 String 对象 -- "Monday"!*/
else
System.out.println("s1 != s2");
if (s1.equals(s2))
System.out.println("s1 equals s2");/*程序输出：s1 != s2 s1 equals s2
说明：s1 s2分别引用了两个"Monday"String对象*/
else
System.out.println("s1 not equals s2");
//	         字符串缓冲池 :当使用 s2 = "Monday" 这样的表达式创建字符串的时候，程序首先会在这个String缓冲池中寻找相同值的
//	         对象，在第一个程序中，s1先被放到了池中，所以在s2被创建的时候，程序找到了具有相同值的 s1，将 s2 引用 s1 所引用的对
//	         象"Monday"第二段程序中，使用了 new 操作符，他明白的告诉程序： "必须创建一个新的空间！"于是一个新
//	         的"Monday"Sting对象被创 建在内存中。
}

/*-----------equals( )------------
* 使用equals( )方法比较两个字符串是否相等。它具有如下的一般形式：boolean equals(Object str)这里str是一个用来
* 与调用字符串（ String）对象做比较的字符串（ String）对象。如果两个字符串具有相同的字符和长度， 它返回true， 否
* 则返回false。 这种比较是区分大小写的。*/
/*---------------------equalsIgnoreCase( )------------------
* 为了执行忽略大小写的比较，可以调用equalsIgnoreCase( )方法。当比较两个字符串时，它会认为A-Z和a-z是一样的。
* 其一般形式如下：boolean equalsIgnoreCase(String str)这里， str是一个用来与调用字符串（ String）对象做比较
* 的字符串（ String）对象。如果两个字符串具有相同的字符和长度，它也返回true，否则返回false。*/

public void equals() {//equals( )--equalsIgnoreCase( )
String s1 = "Hello";
String s2 = "Hello";
String s3 = "Good-bye";
String s4 = "HELLO";
System.out.println(s1 + " equals " + s2 + " -> " +
s1.equals(s2));
System.out.println(s1 + " equals " + s3 + " -> " +
s1.equals(s3));
System.out.println(s1 + " equals " + s4 + " -> " +
s1.equals(s4));
System.out.println(s1 + " equalsIgnoreCase " + s4 + " -> " +
s1.equalsIgnoreCase(s4));
}
//	regionMatches( )方法将一个字符串中指定的区间和另一字符串中指定的区间进行比
//	较。它的重载形式允许在比较时忽略大小写。

//	startsWith( )方法判断一个给定的字符串（ String）是否从一个指定的字符串开始。相反地，
//	endsWith( )方法判断所讨论的字符串（ String）是否是以一个指定的字符串结尾。

//	compareTo( )方法判断一个字符串是大于、等于还是小于另一个。一个字符串小于另一个指的是它在字典中先出现。
//	而一个字符串大于另一个指的是它在字典中后出现了这种功能。它的一般形式如下：int compareTo(String str)
//	这里str是与调用字符串（ String）比较的字符串（ String）。比较的结果返回并被解释：
//	小于： 调用字符串小于str        大于0： 调用字符串大于str        等于0 ：两个字符串相等
public void SortString() {
String arr[] = { "Now", "is", "the", "time", "for", "all", "good", "men", "to", "come", "to", "the", "aid",
"of", "their", "country" };
for (int j = 0; j < arr.length; j++) {
for (int i = j + 1; i < arr.length; i++) {
if (arr[i].compareTo(arr[j]) < 0) {
String t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
System.out.println(arr[j]);
}
}

public static void main(String args[]) {
Equalsbijiao eb = new Equalsbijiao();
eb.bijiao();
eb.equals();
eb.SortString();
}
}

字符串截取

package 字符串;
//字符串截取
public class JieQu {
//charAt()从一个字符串（ String）中截取一个字符,直接引用单个字符。其一般形式如下：char charAt(int where)
public void charAt(){
char ch ;
ch = "abc".charAt(1);//将“b”赋给ch
System.out.println(ch);
}

/*getChars():如果想一次截取多个字符，可以使用getChars( )方法。void getChars(int sourceStart, int sourceEnd, char target[ ], inttargetStart)
这里sourceStart指定了子字符串开始的下标， sourceEnd指定了子字符串结束的下一个字符的下标。因此子字符串包含了从sourceStart到sourceEnd–1的字符。
获得字符的数组由target所指定。将被复制子字符串于其中的target的下标由targetStart指定。注意必须确保的是数组target应该足够大以保证能容纳被指定子
字符串中的字符。*/
public void getChars(){
String s = "This is a demo of the getChars method.";
int start = 10;//d开始，空格也算一个位置
int end = 14;
char buf[] = new char[end - start];
s.getChars(start, end, buf, 0);
System.out.println(buf);
}

/*getBytes( )：实现将字符存放于字节数组中的getChars( )方法的替代，它使用平台提供的默认的字符到字节的转换。
下面是它的最简单形式：byte[ ] getBytes( )   也可使用getBytes( )方法的其他形式。在将字符串（ String）值
输出到一个不支持16位Unicode编码的环境时， getBytes( )是最有用的。例如，大多数Internet协议和文本文件格式
在文本交换时使用8位ASCII编码。*/

//	 toCharArray( )：将字符串（ String）对象中的字符转换为一个字符数组，最简单的方法就是调用toCharArray( )方法。
//	 对应整个字符串，它返回一个字符数组。其一般形式为：char[ ] toCharArray( )    也可以用getChars( )方法获得相同的结果。

public static void main(String[] args) {
JieQu a = new JieQu();
a.charAt();
a.getChars();
}
}

字符串的计算：

package 字符串;

//计算字符串中数字，空格，字符等的个数

import java.util.Scanner;
public class Zifuchuan {
public static void main(String[] args) {
System.out.print("输入一个字符串");
Scanner sc=new Scanner(System.in);
int flag1=0,flag2=0,flag3=0,flag4=0;
String str=sc.nextLine();
sc.close();//关闭sc
char s[]=str.toCharArray();
for(int i=0;i<s.length;i++){
if(s[i]>'0'&&s[i]<'9'){
flag1++;
}
else	if(s[i]==' '){
flag2++;
}
else	if(((s[i]-'z'<=0)&&(s[i]-'a'>=0))||((s[i]-'Z'<=0)&&(s[i]-'A'>=0))){
flag3++;
}
else
flag4++;

}
System.out.println("输入的字符串中有"+flag1+"个数字，"+flag2+"个空格,"+flag3+"个字母"+flag4+"个符号");

}

}

字符串相关操作：截取，拆分，统计

package 字符串;
//截取
public class Work_String {

public static void main(String[] args) {
System.out.println("=======String截取字符串======");
String s1 = new String("123abc,456efg");// 字符串的输入
String s2 = "abc123";
String ss = s2.substring(0, 3);// 截取s2字符串 0到3之间的字符（不包括3）
String sc = s2.substring(2);// 截取s2第二位开始包括第二位的字符
System.out.println("ss="+ss);
System.out.println("sc=" +sc);
System.out.println("=======String拆分字符串======");
String[] as = s1.split(",");// 拆分字符串,以逗号分开，分别赋值给数组as
for (int i = 0; i <as.length; i++)
{System.out.println(as[i]+"*");}
System.out.println("=======String等于的用法======");
if("123abc".equals(as[0]))
//"123abc".equals(as[0]):equals前面有点，等于as[0]数组需要用括号
{
System.out.println("123abc等于as[0]");
}else{
System.out.println("123abc不等于as[0]");
}
System.out.println("=======String统计数字个数======");
int n=0;
String bs="abc123";
char[] ch=bs.toCharArray();
for(int m=0;m<bs.length();m++){
System.out.print(ch[m]+" ");//打印每一个字符
if(ch[m]>='0'&ch[m]<='9')//字符型数字用单引号
{
n++;//如果字符0<x<9,n++,可以通过n最后的值判断0~9数字字符的个数
System.out.print("是第"+n+"个数字          ");
}
}
}

}

字符串相关方法：搜索，修改等

package 字符串;
/**
* 1.搜索字符串indexOf( )   lastIndexOf( )
*/
public class StringMethod {

//indexOf( ) 搜索字符或子字符串首次出现。    lastIndexOf( ) 搜索字符或子字符串的最后一次出现。
//	返回发现的位置的下标，当搜索失败时，返回-1。  格式：int indexOf/lastIndexOf (Char/String)
//	指定起始点：int indexOf(int ch, int startIndex)；int indexOf(String str, int startIndex)
public void Search() {
String s = "Now is the time for all good men " + "to come to the aid of their country.";
System.out.println(s);
System.out.println("indexOf(t) = " + s.indexOf('t'));
System.out.println("lastIndexOf(t) = " + s.lastIndexOf('t'));
System.out.println("indexOf(the) = " + s.indexOf("the"));
System.out.println("lastIndexOf(the) = " + s.lastIndexOf("the"));
System.out.println("indexOf(t, 10) = " + s.indexOf('t', 10));
System.out.println("lastIndexOf(t, 60) = " + s.lastIndexOf('t', 60));
System.out.println("indexOf(the, 10) = " + s.indexOf("the", 10));
System.out.println("lastIndexOf(the, 60) = " + s.lastIndexOf("the", 60));
}

/*修改字符串:
*1. substring( )方法可以截取子字符串:格式一：String substring(int startIndex);startIndex指定了子字符串开始的下标。
* 这种形式返回一个从startIndex开始到调用字符串结束的子字符串的拷贝。
* 	格式二：String substring(int startIndex, int endIndex)这里startIndex指定开始下标， endIndex指定结束下标。返回
* 的字符串包括从开始下标直到结束下标的所有字符，但不包括结束下标对应的字符。
* 2.使用concat( )可以连接两个字符串，一般形式如下：String concat(String str)
* 3.replace( )方法用另一个字符代替调用字符串中一个字符的所有具体值。它具有如下的一般形式：String replace(char original, char replacement
* 4.trim( )方法返回一个调用字符串的拷贝，该字符串是将位于调用字符串前面和后面的空白符删除后的剩余部分.形式如下：String trim( )
* 5.改变字符串内字符的大小写:String toLowerCase( ):改为小写          String toUpperCase( )：改为大写
* 6.valueOf( )方法实现数据转换static String valueOf(long num)；static String valueOf(Object ob)
* 		valueOf( )方法有一种特定形式允许指定字符（ char）数组的一个子集。它具有如下的一般形式：
* 		static String valueOf(char chars[ ], int startIndex, int numChars)
* 		这里chars是存放字符的数组， startIndex是字符数组中期望得到的子字符串的首字符下标， numChars指定子字符串的长度。
*
* */
public static void main(String[] args) {
StringMethod sm = new StringMethod();
sm.Search();
}

}

String和StringBuffer，StringBuilder的区别比较

package 字符串;

//=====>>>>http://blog.csdn.net/jackfrued/article/details/44921941
/*Java平台提供了两种类型的字符串：String和StringBuffer/StringBuilder，它们可以
储存和操作字符串。其中String是只读字符串，也就意味着String引用的字符串内容是不能被改
变的。而StringBuffer/StringBuilder类表示的字符串对象可以直接进行修改。
StringBuilder是Java 5中引入的，它和StringBuffer的方法完全相同，区别在于它是在
单线程环境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也比
StringBuffer要高。
String 类代表字符串,字符串是常量,它们的值在创建之后不能改变，String每次赋值都new一次，StringBuffer
只在开始时new一次，然后在后面追加字符串，StringBuilder效率最高，但不安全（因为是单线程）
*/

public class String_buffer_build {
public static void main(String[] args) {
//===============================
// String
String tempstr = "abcdefghijklmnopqrstuvwxzy";
int times = 5000;
long lstart2 = System.currentTimeMillis();// 获取系统当前时间
String str = new String("《》《》《》《》《》《》");
// 或String str="";

for (int i = 0; i < times; i++) {
str += tempstr;
// sb.append(tempstr);
}
//str并不会输出for循环中的str
System.out.println(str);
long lend2 = System.currentTimeMillis();
long time2 = (lend2 - lstart2);
System.out.println("26个字母相加" + times + "次用了" + time2 + " 毫秒");
// ==============================
// StringBuffer
/* String tempstr="abcdefghijklmnopqrstuvwxzy";
int times=5000;
long lstart2=System.currentTimeMillis();//获取系统当前时间
StringBuffer sb=new StringBuffer();
for(int i=0;i<times;i++){
sb.append(tempstr);
}
long lend2=System.currentTimeMillis();
long time2=(lend2-lstart2);
System.out.println("26个字母相加"+times+"次用了"+time2+" 毫秒");*/

// ==============================
// StringBuilder
/* String tempstr="abcdefghijklmnopqrstuvwxzy";
int times=5000;
long lstart2=System.currentTimeMillis();//获取系统当前时间
StringBuilder sb=new StringBuilder();
for(int i=0;i<times;i++){
sb.append(tempstr);
}
long lend2=System.currentTimeMillis();
long time2=(lend2-lstart2);
System.out.println("26个字母相加"+times+"次用了"+time2+" 毫秒");*/

}

}