js与java字符串对象的使用

最新推荐文章于 2023-07-25 17:18:54 发布

wespten

最新推荐文章于 2023-07-25 17:18:54 发布

阅读量623

点赞数 1

分类专栏：全栈前端开发文章标签： js与java字符串对象的使用

本文链接：https://blog.csdn.net/qq_35029061/article/details/84997660

版权

全栈前端开发专栏收录该内容

61 篇文章 3 订阅

订阅专栏

js字符串对象的使用

java.lang.String 源码解析

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {}

是一个用 final 声明的常量类，不能被任何类所继承,而且一旦一个String对象被创建, 包含在这个对象中的字符序列是不可改变的, 包括该类后续的所有方法都是不能修改该对象的，直至该对象被销毁，这是我们需要特别注意的（该类的一些方法看似改变了字符串，其实内部都是创建一个新的字符串)接着实现了 Serializable接口，这是一个序列化标志接口，还实现了 Comparable 接口，用于比较两个字符串的大小（按顺序比较单个字符的ASCII码）最后实现了 CharSequence 接口，表示是一个有序字符的集合

一个 String 字符串实际上是一个 char 数组。

String str3 = new String(new char[]{'a','b','c'})

charAt(int index) 方法。

我们知道一个字符串是由一个字符数组组成，这个方法是通过传入的索引（数组下标），返回指定索引的单个字符。

1     public char charAt(int index) {
2         //如果传入的索引大于字符串的长度或者小于0，直接抛出索引越界异常
3         if ((index < 0) || (index >= value.length)) {
4             throw new StringIndexOutOfBoundsException(index);
5         }
6         return value[index];//返回指定索引的单个字符
7     }

concat(String str) 方法

该方法是将指定的字符串连接到此字符串的末尾。

1     public String concat(String str) {
 2         int otherLen = str.length();
 3         if (otherLen == 0) {
 4             return this;
 5         }
 6         int len = value.length;
 7         char buf[] = Arrays.copyOf(value, len + otherLen);
 8         str.getChars(buf, len);
 9         return new String(buf, true);
10     }

首先判断要拼接的字符串长度是否为0，如果为0，则直接返回原字符串。如果不为0，则通过 Arrays 工具类的copyOf方法创建一个新的字符数组，长度为原字符串和要拼接的字符串之和，前面填充原字符串，后面为空。接着在通过 getChars 方法将要拼接的字符串放入新字符串后面为空的位置。

　　注意：返回值是 new String(buf, true)，也就是重新通过 new 关键字创建了一个新的字符串，原字符串是不变的。这也是前面我们说的一旦一个String对象被创建, 包含在这个对象中的字符序列是不可改变的。

indexOf(int ch) 和 indexOf(int ch, int fromIndex) 方法

indexOf(int ch)，参数 ch 其实是字符的 Unicode 值，这里也可以放单个字符（默认转成int），作用是返回指定字符第一次出现的此字符串中的索引。其内部是调用 indexOf(int ch, int fromIndex)，只不过这里的 fromIndex =0 ，因为是从 0 开始搜索；而 indexOf(int ch, int fromIndex) 作用也是返回首次出现的此字符串内的索引，但是从指定索引处开始搜索。

 public int indexOf(int ch) {
        return indexOf(ch, 0);//从第一个字符开始搜索
    }

 1 public int indexOf(int ch, int fromIndex) {
 2     final int max = value.length;//max等于字符的长度
 3     if (fromIndex < 0) {//指定索引的位置如果小于0，默认从 0 开始搜索
 4         fromIndex = 0;
 5     } else if (fromIndex >= max) {
 6         //如果指定索引值大于等于字符的长度（因为是数组，下标最多只能是max-1），直接返回-1
 7         return -1;
 8     }
 9 
10     if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {//一个char占用两个字节，如果ch小于2的16次方（65536），绝大多数字符都在此范围内
11         final char[] value = this.value;
12         for (int i = fromIndex; i < max; i++) {//for循环依次判断字符串每个字符是否和指定字符相等
13             if (value[i] == ch) {
14                 return i;//存在相等的字符，返回第一次出现该字符的索引位置，并终止循环
15             }
16         }
17         return -1;//不存在相等的字符，则返回 -1
18     } else {//当字符大于 65536时，处理的少数情况，该方法会首先判断是否是有效字符，然后依次进行比较
19         return indexOfSupplementary(ch, fromIndex);
20     }
21 }

	public static void main(String[] args) {
		String str="sasdwewuiundmxcss";
		System.out.println("d在字符串str中第一次出现的索引位置："+str.indexOf('d'));
		System.out.println("d在字符串str中第一次出现的索引位置,从索引5位置开始："+str.indexOf('d',4));
	}

split(String regex) 和 split(String regex, int limit) 方法

split(String regex) 将该字符串拆分为给定正则表达式的匹配。split(String regex , int limit) 也是一样，不过对于 limit 的取值有三种情况：

　　①、limit > 0 ，则pattern（模式）应用n - 1 次

1 String str = "a,b,c";
2 String[] c1 = str.split(",", 2);
3 System.out.println(c1.length);//2
4 System.out.println(Arrays.toString(c1));//{"a","b,c"}

　②、limit = 0 ，则pattern（模式）应用无限次并且省略末尾的空字串

1 String str2 = "a,b,c,,";
2 String[] c2 = str2.split(",", 0);
3 System.out.println(c2.length);//3
4 System.out.println(Arrays.toString(c2));//{"a","b","c"}

③、limit < 0 ，则pattern（模式）应用无限次

1 String str2 = "a,b,c,,";
2 String[] c2 = str2.split(",", -1);
3 System.out.println(c2.length);//5
4 System.out.println(Arrays.toString(c2));//{"a","b","c","",""}

底层的源码实现。对于 split(String regex) 没什么好说的，内部调用 split(regex, 0) 方法：

public String[] split(String regex) {
       return split(regex, 0);
    }

replace(char oldChar, char newChar) 和 String replaceAll(String regex, String replacement) 方法

①、replace(char oldChar, char newChar) ：将原字符串中所有的oldChar字符都替换成newChar字符，返回一个新的字符串。

②、String replaceAll(String regex, String replacement)：将匹配正则表达式regex的匹配项都替换成replacement字符串，返回一个新的字符串。

substring(int beginIndex) 和 substring(int beginIndex, int endIndex) 方法

①、substring(int beginIndex)：返回一个从索引 beginIndex 开始一直到结尾的子字符串。

public String substring(int beginIndex) {
    if (beginIndex < 0) {//如果索引小于0，直接抛出异常
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    int subLen = value.length - beginIndex;//subLen等于字符串长度减去索引
    if (subLen < 0) {//如果subLen小于0，也是直接抛出异常
        throw new StringIndexOutOfBoundsException(subLen);
    }
    //1、如果索引值beginIdex == 0，直接返回原字符串
    //2、如果不等于0，则返回从beginIndex开始，一直到结尾
    return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

②、 substring(int beginIndex, int endIndex)：返回一个从索引 beginIndex 开始，到 endIndex 结尾的子字符串。

    public static void main(String[] args) {
        // substring方式读取
        String str="不开心每一天";
        String str2="不开心每一天，不可能";
        String newStr=str.substring(1);
        System.out.println(newStr);
        String newStr2=str2.substring(1, 6);
        System.out.println(newStr2);
    }

一、属性

1.length计算字符串的长度(不区分中英文)

2.constructor对象的构造函数

所有对象都是由constructor继承而来的

var str="构造";
alert(str.constructor)
//
Function String(){
[native code]
}

二、方法

1.concat连接字符串,或用+=进行连接

var a = "hello";
var b = ",world";
var c = a.concat(b);
alert(c);
//c = "hello,world"

2.indexof()查找索引字符串，返回第一个出现的位置(从0开始计算)

var a = "hello";
var b = ",world";
var index1 = a.indexOf("l");
//index1 = 2
var index2 = a.indexOf("l",3);
//index2 = 3

lastindexof(searchstring[,startindex])最后一次出现的位置

var a = "hello";
var b = ",world";
var index1 = lastIndexOf('l');
//index1 = 3
var index2 = lastIndexOf('l',2)
//index2 = 2

3.charAt返回指定位置的字符

var a = "hello";
var b = ",world";
var get_char = a.charAt(0);
//get_char = "h"
”abc”.charcodeat(第几个),返回第几个字符的ascii码值

myString.charCodeAt(num)返回指定位置的字符的Unicode编码

var str="ABC";
alert(str.charCodeAt(0))
alert(str.charCodeAt(1))
alert(str.charCodeAt(2))

var str="Hello world!"
document.write(str.charCodeAt(1))
101

String.fromCharCode()接受一个或多个指定的Unicode值，然后返回一个或多个字符串。

String.fromCharCode()
alert(String.fromCharCode(65,66,67))

4.substring返回字符串的一个子串取从第几位到指定长度的字符串.传入参数是起始位置和结束位置。其内容是从 start 处到 stop-1 处的所有字符，其长度为 stop 减start。从指定的开始位置，到结束位置(不包括)的所有字符串。如果不指定结束位置，则从指定的开始位置，取到结尾

var a = "hello";
var b = ",world";
var sub_string1 = a.substring(1);
//sub_string1 = "ello"
var sub_string2 = a.substring(1,4);
//sub_string2 = "ell"
alert(str.substring(-1))

5.substr返回字符串的一个子串，传入参数是起始位置和长度。返回值：抽取从 start 下标开始的指定数目的字符。从指定的位置开始取指定长度的字符串。如果没有指定长度，从指定开始的位置取到结尾。

var a = "hello";
var b = ",world";
var sub_string1 = a.substr(1);
//sub_string1 = "ello"
var sub_string2 = a.substr(1,4);
//sub_string2 = "ello"

6.match()判断字符是否匹配，检查一个字符串匹配一个正则表达式内容，如果没有匹配返回 null。返回值：返回匹配的字符串

        var str="Hello world!"
	document.write(str.match("world") + "<br />")
	document.write(str.match("World") + "<br />")
	document.write(str.match("worlld") + "<br />")
	document.write(str.match("world!"))

world
null
null
world!

var re = new RegExp(/^\w+$/);
var a = "hello";
var b = ",world";
var is_alpha1 = a.match(re);
//is_alpha1 = "hello"
var is_alpha2 = b.match(re);
//is_alpha2 = null

7.replace 返回值：返回替换后字符串，用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。。

var str="Hello world!"
document.write(str.replace(/world/, "World"))
Hello World!

8.slice返回值：提取字符串的某个部分，并以新的字符串返回被提取的部分。从指定的开始位置，到结束位置(不包括)的所有字符串。如果不指定结束位置，则从指定的开始位置，取到结尾

var a="Hello";
var sub_string1 = a.slice(1);
//sub_string1 = "ello"
var str="Hello happy world!"
document.write(str.slice(6,11))
happy

9.split返回值：用于把一个字符串分割成字符串数组，返回分割后数组。

var str="How are you doing today?"
document.write(str.split(" ") + "<br />")
document.write(str.split("") + "<br />")
document.write(str.split(" ",3))

How,are,you,doing,today?
H,o,w, ,a,r,e, ,y,o,u, ,d,o,i,n,g, ,t,o,d,a,y,?
How,are,you

10.length返回字符串的长度，所谓字符串的长度是指其包含的字符的个数。

var len = a.length();
//len = 5

11.toLowerCase将整个字符串转成小写字母。

var a="Hello";
var lower_string = a.toLowerCase();
//lower_string = "hello"

12.toUpperCase将整个字符串转成大写字母。

var a="Hello";
var upper_string = a.toUpperCase();
//upper_string = "HELLO"

13.isnan(变量):测试是否为数值型.

14.fontcolor() 给字符串指定颜色，十六进制表示、red、rgb(255,0,0)

var str="颜色";
 //document.write(str.fontcolor("red"))
 //document.write(str.fontcolor("#aaaaaa"))

15.fontsize() 指定字符串的大小 (1-7)

var str="字体大小";
 document.write(str.fontsize(1))
 document.write(str.fontsize(3))
 document.write(str.fontsize(7))

java字符串对象函数

首先说String，我们说String是不可改变的字符串，原因我们会说他是final修饰，所以不可变。

在Java中，String是一个引用类型，但是在作为参数传递的时候表现出来的却是基本类型的特性，即在方法中改变了String类型的变量的值后，不会影响方法外的String变量的值。

每次对String进行改变的时候进行都要创建一个新的对象，然后将指引指向该新的对象，而原来的对象在堆区中不会被销毁，原来对象中的内容会存放在堆中的常量池中。

StringBuffer和StringBuilder在修改字符串的时候,是在栈区中完成的，不会创建对象。

二者的区别主要是在运行速度和线程安全这两方面。

1、StringBuffer 与 StringBuilder 中的方法和功能完全是等价的

2、只是StringBuffer 中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，而 StringBuilder 没有这个修饰，可以被认为是线程不安全的。

3、在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全而StringBuffer则每次都需要判断锁，效率相对更低。

4、在执行速度方面的比较：StringBuilder > StringBuffer

总结 :

1.如果要操作少量的数据用 String
2.单线程操作字符串缓冲区下操作大量数据 StringBuilder
3.多线程操作字符串缓冲区下操作大量数据 StringBuffer

StringBuild 通过append拼接字符串

StringBuilder bankval=new StringBuilder();
bankval.append(",").append("'"+bankId+"'");
bankval.append(",").append("'"+bankQueId+"'");
bankval.append(",").append("'"+mgtId+"'");
String bakval = bankval.toString();
String bakvalue = bakval.substring(1, bakval.length());

拼接的字符串有时候根据数据类型引号要自己手动加入

String pointIdNum = "'"+IDNumber+"'";
upRoleSql = "UPDATE CT_USER SET ROLE_ID="+"'5afd389c10174e21af1680dd9f79f049'"+ "where ID_NUMBER="+pointIdNum;

StringBuffer拼接字符串

	DateFormat dataFormat = new SimpleDateFormat("YYYY-MM-dd");
		StringBuffer sql = new StringBuffer("SELECT * FROM Data AS pcd WHERE pcd.type=2");
		sql.append(" and pcd.ID=?");
		sql.append(" and (pcd.SJ  BETWEEN ? AND ?)");
		sql.append(" and pcd.X!=0 AND pcd.Y!=0");
		List<Object> dataList = new ArrayList<Object>();
		dataList.add(userId);
		dataList.add(dataFormat.format(new Date())+" 00:00:00");
		dataList.add(dataFormat.format(new Date())+" 23:59:59");
		return this.querySqlObjects(sql.toString(),dataList);

拼接字符串

	@RequestMapping (value="/user/showUserList")
	public String showUserList(Model model,String ids){
		String[] idsArray = ids.split(",");
		if(ids!="") {
			StringBuffer str = new StringBuffer();
			for(int i=0;i<idsArray.length;i++) {
				User user = userService.getUser(idsArray[i]);
				if(null != user)
				{
					String name = user.getUserName();
					str.append(name+',');
				}
			}
			model.addAttribute("membersName", str);
		}
		if(ids=="") {
			model.addAttribute("membersName", "");
		}
		
		model.addAttribute("members", ids);
		return "select/user/showUserList";
	}

StringBuffer转String

StringBuffer sb=new StringBuffer("123");
		sb.append("abc");
		System.out.println(sb.toString());

java字符串函数

1、replace()字符串替换

 String Str = new String("hello");

 System.out.print("返回值 :" );
 System.out.println(Str.replace('o', 'T'));

 System.out.print("返回值 :" );
 System.out.println(Str.replace('l', 'D'));
返回值 :hellT
返回值 :heDDo

字符串替换？

String sql = "delete from  user_log where  id in (?)";

使用：sql.replace("[?]", "")

2.contain()函数判断是否包含，返回值true与false

	if(str.contains(",")){
    
             }


 String a = "l love feng ye";
 String b = "love";
 boolean c = a.contains(b);

3.compareTo()字符串比较，字符串函数 compareTo (string) ，compareToIgnoreCase(String) 及 compareTo(object string) 来比较两个字符串，并返回字符串中第一个字母ASCII的差值。

 String str = "Hello World";
      String anotherString = "hello world";
      Object objStr = str;
 
      System.out.println( str.compareTo(anotherString) );
      System.out.println( str.compareToIgnoreCase(anotherString) );  //忽略大小写
      System.out.println( str.compareTo(objStr.toString()));

4.indexOf()字符串查找索引出现的位置。String 类的 indexOf() 方法在字符串中查找子字符串出现的位置，如过存在返回字符串出现的位置（第一位为0），如果不存在返回 -1。

 String strOrig = "Google Java Taobao";
      int intIndex = strOrig.indexOf("Java");
      if(intIndex == - 1){
         System.out.println("没有找到字符串 Java");
      }else{
         System.out.println("Java 字符串位置 " + intIndex);
      }

paramPrimarykey.indexOf(",")==0

5.lastIndexOf()查找字符串最后一次出现的位置

 String strOrig = "Hello world ,Hello Runoob";
      int lastIndex = strOrig.lastIndexOf("Hello");
      if(lastIndex == - 1){
         System.out.println("没有找到字符串");
      }else{
         System.out.println("字符串最后出现的位置： "+ lastIndex);
      }

String path = "f:/assa/a.xlsx";
int index = path.lastIndexOf("/");
String name = path.substring(index);

获得文件后缀

	public static String getExtensionName(String fileName) {
		String extension = "";
		if(StringUtils.isNotBlank(fileName)){
			int lastIndex = fileName.lastIndexOf('.');
			lastIndex = lastIndex > 0 ? lastIndex + 1 : 0;
			extension = fileName.substring(lastIndex);
		}
		return extension;
	}

6.substring()截取字符串

StringBuilder paramSubval=new StringBuilder();
paramPrimarykey.substring(1)

String Str = new String("www.taobao.com");
 
        System.out.print("返回值 :" );
        System.out.println(Str.substring(4) );
 
        System.out.print("返回值 :" );
        System.out.println(Str.substring(4, 10) );

返回值 :taobao.com
返回值 :taobao

字符串截取获取除最后一位之前的字符串

if(ids.indexOf(",") > -1)
ids = ids.substring(0, ids.length() - 1);
}
condictionSql = "UPDATE "+templateTable+" SET "+updateSqlValue.substring(0, updateSqlValue.length()-1)+ updateCondition +"";

7.reverse() 字符串反转

Java 的反转函数 reverse() 可字符串反转。

String str="Hello Java.";
            String reverse = new StringBuffer(str).reverse().toString();
            System.out.println("字符串反转前:"+str);
            System.out.println("字符串反转后:"+reverse);

8.split()字符串分割

split(string) 方法通过指定分隔符将字符串分割为数组。

String str="www-baidu-com";
            String[] temp;
            String delimeter = "-";  //指定分隔符
            temp = str.split(delimeter);  //分割字符串
            //普通for循环
            for(int i =0; i < temp.length; i++){
                System.out.println(temp[i]);
                System.out.println("");
            }
            
            System.out.println("----java for each循环输出的方法-----");
            String str1 = "www.baidu.com";
            String[] temp1;
            String delimeter1 = "\\.";   //指定分隔符，.号需要转义
            temp1 = str1.split(delimeter1);
            for (String x : temp1){
                System.out.println(x);
                System.out.println("");
            }

9.toUpperCase() 字符串小写转大写

String toUpperCase() 方法将字符串从小写转为大写。

String str = "string runoob";
String strUpper = str.toUpperCase();

10.regionMatches()测试两个字符串区域是否相等

 String first_str = "Welcome to Microsoft";
      String second_str = "I work with microsoft";
      boolean match1 = first_str.
      regionMatches(11, second_str, 12, 9);
      boolean match2 = first_str.
      regionMatches(true, 11, second_str, 12, 9); //第一个参数 true 表示忽略大小写区别
      System.out.println("区分大小写返回值：" + match1);
      System.out.println("不区分大小写返回值：" + match2);

first_str.regionMatches(11, second_str, 12, 9) 表示将 first_str 字符串从第11个字符"M"开始和 second_str 字符串的第12个字符"M"开始逐个比较，共比较 9 对字符，由于字符串区分大小写，所以结果为false。

如果设置第一个参数为 true ，则表示忽略大小写区别，所以返回 true。

11.append()连接字符串

通过 "+" 操作符和StringBuffer.append() 方法来连接字符串。

  long startTime = System.currentTimeMillis();
        for(int i=0;i<5000;i++){
            String result = "This is"
            + "testing the"
            + "difference"+ "between"
            + "String"+ "and"+ "StringBuffer";
        }
        long endTime = System.currentTimeMillis();
        System.out.println("字符串连接" 
        + " - 使用 + 操作符 : " 
        + (endTime - startTime)+ " ms");
        long startTime1 = System.currentTimeMillis();
        for(int i=0;i<5000;i++){
            StringBuffer result = new StringBuffer();
            result.append("This is");
            result.append("testing the");
            result.append("difference");
            result.append("between");
            result.append("String");
            result.append("and");
            result.append("StringBuffer");
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println("字符串连接" 
        + " - 使用 StringBuffer : "
        + (endTime1 - startTime1)+ " ms");

字符串连接 - 使用 + 操作符 : 0 ms 
字符串连接 - 使用 StringBuffer : 42 ms

12.equalsIgnoreCase()比较字符串是否相等

    /**
     * 匹配前缀字符是否相同
     * @param str 源字符串
     * @param prefix 目标字符串
     * @return 前缀字符相同与否
     */
    public static boolean startWithIgnoreCase(String str, String prefix) {
        if (prefix.length() > str.length()) {
            return false;
        }
        return str.substring(0, prefix.length()).equalsIgnoreCase(prefix);
    }

wespten

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
js与java字符串对象的使用

js字符串对象的使用java.lang.String 源码解析public final class String implements java.io.Serializable, Comparable&lt;String&gt;, CharSequence {}是一个用 final 声明的常量类，不能被任何类所继承,而且一旦一个String对象被创建, 包含在这个对象中的字符...
复制链接

扫一扫