string类方法（flash里String的常用方法有哪些）

本文目录

• flash里String的常用方法有哪些
• c#中，“String类的方法”和“字符串对象的方法”有什么区别
• 关于String类的split()方法
• String常使用的方法有哪些
• java中String 类的常用方法有哪些
• string类型中都有哪些方法

flash里String的常用方法有哪些

1、String 类的方法摘要
String.charAt() 返回字符串中特定位置处的字符。
String.charCodeAt() 返回指定索引处字符的值，此值为介于0到 65535 之间的一个 16 位整数。
String.concat() 合并两个字符串的文本，并返回一个新字符串。
String.fromCharCode() 返回由参数中指定的字符组成的字符串。
String.indexOf() 返回指定子字符串的第一个匹配项的位置。
String.lastIndexOf() 返回指定子字符串的最后一个匹配项的位置。
String.slice() 提取字符串的一部分，并返回一个新字符串。
String.split() 通过将字符串分隔为子字符串，从而将 String 对象拆分为字符串数组。
String.substr() 返回字符串内指定数量的字符，字符计数从指定的位置开始。
String.substring() 返回字符串内两个索引间的字符。
String.toLowerCase() 将字符串转换为小写然后返回结果；不更改原始对象的内容。
String.toUpperCase() 将字符串转换为大写然后返回结果；不更改原始对象的内容。
所有字符串索引都是从零开始的，任何字符串 x 的最后一个字符的索引都是其长度－1。
2、String 类的属性摘要
String.length 一个非从零开始的整数，表示指定 String 对象中的字符数。
3、String 类的构造函数
用法：new String(value)
参数：value 新 String 对象的初始值。
说明：构造函数；创建一个新 String 对象。
4、实例
gc=“ab含苞待放“
gccd=length(gc)//提取gc的长度，gccd的结果是6，一个字符、一个汉字都是一个长度。
wz=gc.indexOf(“放“,0)//从0起搜索第一b在字符串gc的位置，wz的结果是5。
tc=gccd=gc.slice(3,5)//从3起，取到5（不含5）的字串，tc的结果是：苞待。

c#中，“String类的方法”和“字符串对象的方法”有什么区别

1.
str1不是子类，是String的实例
2.
“String方法”是说在String类上的静态（static）方法；“字符串对象的方法”是说String上的非静态方法，这种方法必须在实例上使用，也就是str1上使用
例：
String.Equals(null, null); // 不需要具体的实例引用，两个均为null也可，这里是“String方法”
str1.Equals(null); // 这里Equals是实例方法，这里的str1不允许为null，也就是“字符串对象的方法”

关于String类的split()方法

split 方法：将一个字符串分割为子字符串，然后将结果作为字符串数组返回。 

split 方法参数为stringObj.split([separator，[limit]]) 

stringObj（必选项） ，指要被分解的 String 对象或文字。该对象不会被 split 方法修改。

separator（可选项），指字符串或正则表达式对象，它标识了分隔字符串时使用的是一个还是多个字符。如果忽略该选项，返回包含整个字符串的单一元素数组。 

limit（可选项）该值用来限制返回数组中的元素个数。

说明 ：

split 方法的结果是一个字符串数组，在 stingObj 中每个出现 separator 的位置都要进行分解。

例：String oldStr = “z,,,z“;  

String strs = oldStr.split(“,“);  

for(String str:strs) {  

System.out.println(str);  }

扩展资料

String类的split()方法的正确写法：

1、如果用“.”作为分隔的话，必须是如下写法：String.split(“\\.“),这样才能正确的分隔开，不能用String.split(“.“);。

2、如果用“|”作为分隔的话，必须是如下写法：String.split(“\\|“),这样才能正确的分隔开，不能用String.split(“|“);“.”和“|”都是转义字符，必须得加“\\“;（这里是利用了java中正则表达式的一个点）。

3、如果在一个字符串中有多个分隔符，可以用“|”作为连字符，比如：“a=1 and b =2 or c=3”,把三个都分隔出来，可以用String.split(“and|or“);。

参考资料来源：百度百科——split函数

String常使用的方法有哪些

这些是最常用的:
char charAt (int index) 返回index所指定的字符
String concat(String str) 将两字符串连接
boolean endsWith(String str) 测试字符串是否以str结尾
boolean equals(Object obj) 比较两对象
char getBytes 将字符串转换成字符数组返回
char getBytes(String str) 将指定的字符串转成制服数组返回
boolean startsWith(String str) 测试字符串是否以str开始
int length() 返回字符串的长度
String replace(char old ,char new) 将old用new替代
char toCharArray 将字符串转换成字符数组
String toLowerCase() 将字符串内的字符改写成小写
String toUpperCase() 将字符串内的字符改写成大写
String valueOf(Boolean b) 将布尔方法b的内容用字符串表示
String valueOf(char ch) 将字符ch的内容用字符串表示
String valueOf(int index) 将数字index的内容用字符串表示
String valueOf(long l) 将长整数字l的内容用字符串表示
String substring(int1,int2) 取出字符串内第int1位置到int2的字符串

=============
以下解释的十分清楚了，还有例子
1、length() 字符串的长度
例：char chars={’a’,’b’.’c’};
String s=new String(chars);
int len=s.length();
2、charAt() 截取一个字符
例：char ch;
ch=“abc“.charAt(1); 返回’b’
3、 getChars() 截取多个字符
void getChars(int sourceStart,int sourceEnd,char target,int targetStart)
sourceStart指定了子串开始字符的下标，sourceEnd指定了子串结束后的下一个字符的下标。因此， 子串包含从sourceStart到sourceEnd-1的字符。接收字符的数组由target指定，target中开始复制子串的下标值是targetStart。
例：String s=“this is a demo of the getChars method.“;
char buf=new char;
s.getChars(10,14,buf,0);
4、getBytes()
替代getChars()的一种方法是将字符存储在字节数组中，该方法即getBytes()。

5、toCharArray()
6、equals()和equalsIgnoreCase() 比较两个字符串
7、regionMatches() 用于比较一个字符串中特定区域与另一特定区域，它有一个重载的形式允许在比较中忽略大小写。
boolean regionMatches(int startIndex,String str2,int str2StartIndex,int numChars)
boolean regionMatches(boolean ignoreCase,int startIndex,String str2,int str2StartIndex,int numChars)
8、startsWith()和endsWith()
startsWith()方法决定是否以特定字符串开始，endWith()方法决定是否以特定字符串结束
9、equals()和==
equals()方法比较字符串对象中的字符，==运算符比较两个对象是否引用同一实例。
例：String s1=“Hello“;
String s2=new String(s1);
s1.eauals(s2); //true
s1==s2;//false
10、compareTo()和compareToIgnoreCase() 比较字符串
11、indexOf()和lastIndexOf()
indexOf() 查找字符或者子串第一次出现的地方。
lastIndexOf() 查找字符或者子串是后一次出现的地方。
12、substring()
它有两种形式，第一种是：String substring(int startIndex)
第二种是：String substring(int startIndex,int endIndex)
13、concat() 连接两个字符串
14 、replace() 替换
它有两种形式，第一种形式用一个字符在调用字符串中所有出现某个字符的地方进行替换，形式如下：
String replace(char original,char replacement)
例如：String s=“Hello“.replace(’l’,’w’);
第二种形式是用一个字符序列替换另一个字符序列，形式如下：
String replace(CharSequence original,CharSequence replacement)
15、trim() 去掉起始和结尾的空格
16、valueOf() 转换为字符串
17、toLowerCase() 转换为小写
18、toUpperCase() 转换为大写
19、StringBuffer构造函数
StringBuffer定义了三个构造函数：
StringBuffer()
StringBuffer(int size)
StringBuffer(String str)
StringBuffer(CharSequence chars)
(1)、length()和capacity()
一个StringBuffer当前长度可通过length()方法得到,而整个可分配空间通过capacity()方法得到。
(2)、ensureCapacity() 设置缓冲区的大小
void ensureCapacity(int capacity)
(3)、setLength() 设置缓冲区的长度
void setLength(int len)
(4)、charAt()和setCharAt()
char charAt(int where)
void setCharAt(int where,char ch)
(5)、getChars()
void getChars(int sourceStart,int sourceEnd,char target,int targetStart)
(6)、append() 可把任何类型数据的字符串表示连接到调用的StringBuffer对象的末尾。
例：int a=42;
StringBuffer sb=new StringBuffer(40);
String s=sb.append(“a=“).append(a).append(“!“).toString();
(7)、insert() 插入字符串
StringBuffer insert(int index,String str)
StringBuffer insert(int index,char ch)
StringBuffer insert(int index,Object obj)
index指定将字符串插入到StringBuffer对象中的位置的下标。
(8)、reverse() 颠倒StringBuffer对象中的字符
StringBuffer reverse()
(9)、delete()和deleteCharAt() 删除字符
StringBuffer delete(int startIndex,int endIndex)
StringBuffer deleteCharAt(int loc)
(10)、replace() 替换
StringBuffer replace(int startIndex,int endIndex,String str)
(11)、substring() 截取子串
String substring(int startIndex)
String substring(int startIndex,int endIndex)

java中String 类的常用方法有哪些

用的比较多的：
1
替换字符串
replace();
2
分割字符串
split(“regex“);
3
equals
字符串比较
4
length()
获取长度、、、、好多好多
你看看api

string类型中都有哪些方法

java中String的操作api2007-04-19 16:25:59| 分类： Work &　Study | 标签： |字号大中小 订阅 .

创建一个字符串实例变量StringBuffer buf = new StringBuffer(“Java“); // Append buf.append(“ Almanac v1/“); // Java Almanac v1/ buf.append(3); // Java Almanac v1/3 // Set int index = 15; buf.setCharAt(index, ’.’); // Java Almanac v1.3 // Insert index = 5; buf.insert(index, “Developers “);// Java Developers Almanac v1.3 // Replace int start = 27; int end = 28; buf.replace(start, end, “4“); // Java Developers Almanac v1.4 // Delete start = 24; end = 25; buf.delete(start, end); // Java Developers Almanac 1.4 // Convert to string String s = buf.toString();比较字符串String s1 = “a“; String s2 = “A“; String s3 = “B“; // Check if identical 监测是否一致 boolean b = s1.equals(s2); // false // Check if identical ignoring case b = s1.equalsIgnoreCase(s2); // true // Check order of two strings 监测两个字符串的顺序 int i = s1.compareTo(s2); // 32; lowercase follows uppercase if (i 《 0) { // s1 precedes s2 } else if (i 》 0) { // s1 follows s2 } else { // s1 equals s2 } // Check order of two strings ignoring case i = s1.compareToIgnoreCase(s3); // -1 if (i 《 0) { // s1 precedes s3 } else if (i 》 0) { // s1 follows s3 } else { // s1 equals s3 } // A string can also be compared with a StringBuffer; StringBuffer sbuf = new StringBuffer(“a“); b = s1.contentEquals(sbuf); // true判断一个字符串中是否包含另外一个字符串String string = “Madam, I am Adam“; // Starts with boolean b = string.startsWith(“Mad“); // true // Ends with b = string.endsWith(“dam“); // true // Anywhere b = string.indexOf(“I am“) 》 0; // true // To ignore case, regular expressions must be used // Starts with b = string.matches(“(?i)mad.*“); // Ends with b = string.matches(“(?i).*adam“); // Anywhere b = string.matches(“(?i).*i am.*“);获取制定字符串中的子串int start = 1; int end = 4; String substr = “aString“.substring(start, end); // Str查询指定字符串中的子串以及字母的位置String string = “madam, i am Adam“; // Characters // First occurrence of a c int index = string.indexOf(’a’); // 1 // Last occurrence index = string.lastIndexOf(’a’); // 14 // Not found index = string.lastIndexOf(’z’); // -1 // Substrings // First occurrence index = string.indexOf(“dam“); // 1 // Last occurrence index = string.lastIndexOf(“dam“); // 13 // Not found index = string.lastIndexOf(“z“); // -1取代制定字符的函数操作// Replace all occurrences of ’a’ with ’o’ String newString = string.replace(’a’, ’o’);取代制定字符串的操作static String replace(String str, String pattern, String replace) { int s = 0; int e = 0; StringBuffer result = new StringBuffer(); while ((e = str.indexOf(pattern, s)) 》= 0) { result.append(str.substring(s, e)); result.append(replace); s = e+pattern.length(); } result.append(str.substring(s)); return result.toString(); }转变字符串的大小写// Convert to upper case String upper = string.toUpperCase(); // Convert to lower case String lower = string.toLowerCase();Converting a Primitive Type Value to a String
// Use String.valueOf() String s = String.valueOf(true); // true s = String.valueOf((byte)0x12); // 18 s = String.valueOf((byte)0xFF); // -1 s = String.valueOf(’a’); // a s = String.valueOf((short)123); // 123 s = String.valueOf(123); // 123 s = String.valueOf(123L); // 123 s = String.valueOf(1.23F); // 1.23 s = String.valueOf(1.23D); // 1.23 // Use + s = ““+true; // true s = ““+((byte)0x12); // 18 s = ““+((byte)0xFF); // -1 s = ““+’a’; // a s = ““+((short)123); // 123 s = ““+123; // 123 s = ““+123L; // 123 s = ““+1.23F; // 1.23 s = ““+1.23D; // 1.23Converting Between Unicode and UTF-8
try { // Convert from Unicode to UTF-8 String string = “abc\u5639\u563b“; byte utf8 = string.getBytes(“UTF-8“); // Convert from UTF-8 to Unicode string = new String(utf8, “UTF-8“); } catch (UnsupportedEncodingException e) { }Determining a Character’s Unicode Block
char ch = ’\u5639’; Character.UnicodeBlock block = Character.UnicodeBlock.of(ch);Determining If a String Is a Legal Java Identifier
// Returns true if s is a legal Java identifier. public static boolean isJavaIdentifier(String s) { if (s.length() == 0 || !Character.isJavaIdentifierStart(s.charAt(0))) { return false; } for (int i=1; i《s.length(); i++) { if (!Character.isJavaIdentifierPart(s.charAt(i))) { return false; } } return true; } // Some examples boolean b = isJavaIdentifier(“my_var“); // true b = isJavaIdentifier(“my_var.1“); // false b = isJavaIdentifier(“$my_var“); // true b = isJavaIdentifier(“\u0391var“); // true b = isJavaIdentifier(“_“); // true b = isJavaIdentifier(“___FCKpd___175quot;); // true b = isJavaIdentifier(“1$my_var“); // falseNumbers
精确计算类实例package hxj;

import java.math.BigDecimal;

/**

* 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精
* 确的浮点数运算，包括加减乘除和四舍五入。
*/

public class mymatch {

//默认除法运算精度
private static final int DEF_DIV_SCALE = 10;

//这个类不能实例化
private Arith() {}

/**

* 提供精确的加法运算。
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/

public static double add(double v1, double v2) {

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.add(b2).doubleValue();

}

/**

* 提供精确的减法运算。
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/

public static double sub(double v1, double v2) {

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.subtract(b2).doubleValue();

}

/**

* 提供精确的乘法运算。
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的
*/

public static double mul(double v1, double v2) {

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.multiply(b2).doubleValue();

}

/**

* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/

public static double div(double v1, double v2) {

return div(v1, v2, DEF_DIV_SCALE);

}

/**

* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/

public static double div(double v1, double v2, int scale) {

if (scale 《 0) {

throw new IllegalArgumentException(“The scale must be a positive integer or zero“);

}

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();

}

/**

* 提供精确的小数位四舍五入处理。
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/

public static double round(double v, int scale) {

if (scale 《 0) {

throw new IllegalArgumentException(“The scale must be a positive integer or zero“);

}

BigDecimal b = new BigDecimal(Double.toString(v));

BigDecimal one = new BigDecimal(“1“);

return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();

}

};

转变字符串为数字格式byte b = Byte.parseByte(“123“); short s = Short.parseShort(“123“); int i = Integer.parseInt(“123“); long l = Long.parseLong(“123“); float f = Float.parseFloat(“123.4“); double d = Double.parseDouble(“123.4e10“);Parsing and Formatting a Number into Binary, Octal, and Hexadecimal
int i = 1023; // Parse and format to binary i = Integer.parseInt(“1111111111“, 2); // 1023 String s = Integer.toString(i, 2); // 1111111111 // Parse and format to octal i = Integer.parseInt(“1777“, 8); // 1023 s = Integer.toString(i, 8); // 1777 // Parse and format to decimal i = Integer.parseInt(“1023“); // 1023 s = Integer.toString(i); // 1023 // Parse and format to hexadecimal i = Integer.parseInt(“3ff“, 16); // 1023 s = Integer.toString(i, 16); // 3ff // Parse and format to arbitrary radix 《= Character.MAX_RADIX int radix = 32; i = Integer.parseInt(“vv“, radix); // 1023 s = Integer.toString(i, radix); // vv