String和StringBuffer打印

合集下载

【java】String类和StringBuffer类常用操作

【java】String类和StringBuffer类常用操作

【java】String类和StringBuffer类常⽤操作String类是字符串常量,是不可更改的常量。

⽽StringBuffer是字符串变量,它的对象是可以扩充和修改的。

StringBuffer在进⾏字符串处理时,不⽣成新的对象,在内存使⽤上要优于String类。

所以在实际使⽤时,如果经常需要对⼀个字符串进⾏修改,例如插⼊、删除等操作,使⽤StringBuffer要更加适合⼀些。

String类主要⽅法的使⽤⼀、创建并初始化字符串:String s = "hello!"; //使⽤字符串常量直接初始化String(); //使⽤构造⽅法创建并初始化,初始化⼀个对象,表⽰空字符序列String(value); //利⽤已存在的字符串常量创建⼀个新的对象String (char[] value); //利⽤⼀个字符数组创建⼀个字符串String(char[] value,int offset,int count);//截取字符数组offset到count的字符创建⼀个⾮空串String(StringBuffer buffer); //利⽤StringBuffer对象初始化String对象⼆、String类主要⽅法的使⽤:1、获取长度*.length(); //这与数组中的获取长度不同,*.length;2、⽐较字符串(1)equals() //判断内容是否相同(2)compareTo() //判断字符串的⼤⼩关系(3)compareToIgnoreCase(String int) //在⽐较时忽略字母⼤⼩写(4)== //判断内容与地址是否相同(5)equalsIgnoreCase() //忽略⼤⼩写的情况下判断内容是否相同//如果想对字符串中的部分内容是否相同进⾏⽐较,可以⽤(6)reagionMatches() //有两种 public boolean regionMatches(int toffset, String other,int ooffset,int len);表⽰如果String对象的⼀个⼦字符串与参数other的⼀个⼦字符串是相同的字符序列,则为true.要⽐较的String 对象的字符串从索引toffset开始,oth public boolean reagionMatches(boolean ignoreCase,int toffset,String other,int ooffset,int len);//⽤布尔类型的参数指明两个字符串的⽐较是否对⼤⼩写敏感。

JAVAAPI(一)String类和StringBuffer类

JAVAAPI(一)String类和StringBuffer类

⽅法声明 功能描述int indexOf(int ch)返回指定字符在此字符串中第⼀次出现处的索引int lastIndexOf(int ch)返回指定字符在此字符串中最后⼀次出现处的索引int indexOf(String str)返回指定⼦字符串在此字符串中第⼀次出现处的索引int lastIndexOf(String str)返回指定⼦字符串在此字符串中最后⼀次出现处的索引char charAt(int index)返回字符串中index 位置上的字符,其中,index 的取值范围是0-(字符串长度-1)boolean endsWith(String suffix)判断此字符串是否以指定的字符串结尾int length()返回此字符串的长度boolean equals(Object anObject)将此字符串与指定的字符串⽐较boolean isEmpty()当且仅当字符串长度为0时返回true boolean startsWith(String prefix)判断此字符串是否以指定的字符串开始boolean contains(CharSequence cs)判断此字符串中是否包含指定的字符序列String toLowerCase()使⽤默认语⾔环境的规则将String 中的所有字符都转换为⼩写String toUpperCase()使⽤默认语⾔环境的规则将String 中的所有字符都转换为⼤写static String valueOf(int i)返回int 参数的字符串表⽰形式char[] toCharArray()将此字符串转换为⼀个字符数组String replace(CharSequence oldstr,CharSequence newstr)返回⼀个新的字符串,它是通过⽤newstr 替换此字符串中出现的所有oldstr 得到的String[] split(String regex)根据参数regex 将原来的字符串分割为若⼲⼦字符串JAVAAPI (⼀)String 类和StringBuffer 类1.String 类和StringBuffer 类在程序中经常会⽤到字符串,所谓的字符串就是指⼀连串的字符,它是由多个单个字符连接⽽成的。

string字符串倒序输出的方法

string字符串倒序输出的方法

string字符串倒序输出的方法在Python中,对于字符串倒序输出,有以下几种常用方法:1.切片操作:pythonstring = "hello world"string_reverse = string[::-1]print(string_reverse)这段代码会输出:dlrow olleh2.使用reversed 函数配合join 方法(因为reversed 本身返回的是一个迭代器,需要转换为字符串):pythonstring = "hello world"string_reverse = ''.join(reversed(string))print(string_reverse)输出结果同样是:dlrow olleh3.循环遍历并手动拼接:pythonstring = "hello world"string_reverse = ''for char in string:string_reverse = char + string_reverseprint(string_reverse)这种方式虽然也能实现,但在实际应用中不如切片操作简洁高效。

4.如果是单词级别的逆序而非字符级别的逆序,可以先通过split 分割单词,再使用reverse 或者列表推导式逆序排列单词,最后用join 合并:pythonstring = "hello world this is a test"words = string.split(' ')words.reverse()string_reverse = ' '.join(words)print(string_reverse)输出结果将是:test a is this world hello在Java中处理字符串倒序输出,有以下几种方法:1.使用StringBuilder或StringBuffer类的reverse()方法:javaString original = "hello world";StringBuilder sb = new StringBuilder(original);String reversed = sb.reverse().toString();System.out.println(reversed); // 输出:dlrow olleh2.使用字符数组:javaString str = "hello world";char[] chars = str.toCharArray();int start = 0, end = chars.length - 1;while (start < end) {char temp = chars[start];chars[start] = chars[end];chars[end] = temp;start++;end--;}String reversedStr = new String(chars);System.out.println(reversedStr); // 输出:dlrow olleh 3.递归实现(适用于较小的字符串,因为递归深度过大会导致栈溢出):javapublic static String reverseString(String s) {if (s.isEmpty()) {return s;} else {return reverseString(s.substring(1)) + s.charAt(0);}}String input = "hello world";String reversed = reverseString(input);System.out.println(reversed); // 输出:dlrow olleh4.使用Java 8及以上版本的流(Stream)操作:javaString str = "hello world";String reversed = IntStream.range(0, str.length()).map(i -> str.length() - 1 - i) .mapToObj(str::charAt).collect(Collectors.joining());System.out.println(reversed); // 输出:dlrow olleh。

Java中String的理解

Java中String的理解

Java中String的理解Java中String的理解最近在读String的源码,看了些String的⽂章,⾃⼰对String作了下总结记录下来。

1.String为什么是不可变的?String是final类,不可继承,其⽅法也不可被覆盖,避免从⼦类操纵⽗类属性;String的值保存在private final char[]数组中,本质是⼀个字符数组,私有则外部不可访问和修改,final引⽤则引⽤(或说引⽤的值)不变。

引⽤可以简单地认为是堆上对象的⾸地址。

String内部的private int hash,缓存hash值,hashCode和equals⽤来⽐较对象相等,缓存hash可以减少运算时间提⾼效率。

但是,String的值char[]可以通过反射改变。

String不可变是出于安全和使⽤效率考虑的。

2.String的split,substring,replace,replaceAll等⽅法有哪些注意点?charAt,toLowerCase,toUpperCase,trim,toCharArray等常⽤⽅法并没有太多注意点。

split(String regex,int limit):regex,切⽚的正则;limit,切⽚数。

split(String regex):regex,切⽚的正则。

从这⾥可以看出切⽚是使⽤正则来切⽚的,⽽且要注意的是,尾部切⽚得到的空字符串""(注意没有空格)是不会出现的结果的字符串数组中的。

思考:String s=“,1,2,,3,,,”;String[] arr=s.split(",");arr的值是什么?结果是{"",“1”,“2”,“”,“3”}。

如果制定切⽚数limit则会按切⽚数切⽚。

substring(int beginIndex,int endInx):beginIndex是包含的,end不包含。

JAVA选择题

JAVA选择题
4. 在 JAVA 中,使用类的步骤包括以下三步,它们的先后顺序是()。(选择一项)B 1. 定义类 2. 创建类的对象 3. 访问对象的属性和方法 a) 213 b) 123 c) 321 d) 231
5. 在 JAVA 中,Scanner 类提供从控制台获取键盘输入的功能,下列语句()能够正确实例 化 Scanner 类的对象,用于获得键盘输入的数据。(选择一项)B a) Scanner input = new Scanner(System.out); b) Scanner input = new Scanner(System.in); c) Scanner input = new Scanner(System); d) Scanner input = new Scanner();
25. a) b) c) d)
下面()段 Java 语句在编译时不会出现异常和错误。(选择二项)B D char c = “a”; int i = -1; boolean b = null; double d = 10.0;
26. 在 Java 中,如果要在字符串类型对象 s=”java”中,得到字母’v’出现的位置, 可使用以下()语句。(选择一项)C a) s.matches(‘v’); b) s.charAt(‘v’); c) s.indexOf(‘v’); d) s.substring(‘v’);
27. 在 Java 语言的控制结构中,break 语句是经常用到的语句,下面一段代码中 break 语 句起到()的作用。C
int pointer = 0; while(pointer<=10){
switch(pointer%3){ case 1: pointer += 1; break; case 2: pointer += 2; break; default: pointer += 3; break;

string数组打印方法

string数组打印方法

string数组打印方法如何在程序中打印出string数组的元素。

在程序开发中,经常会使用到字符串数组(string array),即用于存储多个字符串的数据结构。

而在某些场景下,我们需要打印(输出)这些字符串数组的元素。

本文将详细介绍如何在程序中打印出string数组的所有元素。

一、理解字符串数组在介绍打印字符串数组的方法之前,我们需要先了解字符串数组。

字符串数组(string array)是一种数据结构,用于存储多个字符串。

一个字符串数组可以包含任意个字符串,每个字符串可以包含任意多的字符。

字符串数组中的每个字符串元素都有相应的下标(从0开始),通过下标可以访问数组中的元素。

举个例子,下面的代码示例创建了一个包含三个字符串元素的字符串数组,并依次给数组中的元素赋值:string[] myStrings = new string[3];myStrings[0] = "Hello";myStrings[1] = "World";myStrings[2] = "!";在上面的代码中,我们首先使用new关键字创建了一个长度为3的字符串数组,然后依次给数组中的元素赋值。

第一个元素为“Hello”,第二个元素为“World”,第三个元素为“!”。

二、打印字符串数组有多种方法可以打印字符串数组中的元素,下面分别介绍。

1.使用foreach循环使用foreach循环是最简单的打印字符串数组的方法之一。

foreach循环可以自动遍历字符串数组中的所有元素,不需要显式地使用下标来访问元素。

下面的代码示例演示了如何使用foreach循环打印上面示例中的字符串数组:foreach (string s in myStrings){Console.WriteLine(s);}上面的代码中,我们使用foreach循环遍历了myStrings数组中的所有元素,并在循环体中使用Console.WriteLine方法将每个元素打印到控制台上。

stringbuffer用法

stringbuffer用法

stringbuffer用法StringBufferJava中的一个重要的工具类,它的功能是用来处理字符串的。

它是在 Java 1.0本中就开始被使用,目前最新的版本是 Java 8,目前仍在有效使用中。

StringBuffer以被视作是一个字符串容器,它可以处理大量字符串进行复杂的操作,更加方便快捷。

与 String不同,StringBuffer 不仅可以用来处理字符串,还可以处理基本类型的数据。

StringBuffer几种常用的用法,下面将详细介绍。

首先,StringBuffer构造函数:StringBuffer两种构造函数,一种是不带参数的构造函数,另一种是带参数的构造函数。

如果不带参数,则会创建一个容量为 16节的字符串缓冲区;如果带参数,则可以指定字符串缓冲区的容量,如:StringBuffer sb = new StringBuffer(1024);其次,StringBuffer append法:append法可以向字符串缓冲区中添加任意类型的参数,它将把参数转换为字符串,然后拼接到字符串缓冲区的末尾,如:StringBuffer sb = newStringBuffer();sb.append(Hello第三,StringBuffer insert法:insert法与 append法类似,都可以向字符串缓冲区添加参数,但是 insert法可以指定参数插入到字符串缓冲区的任意位置,如:StringBuffer sb = new StringBuffer(hello worldsb.insert(5,, );第四,StringBuffer delete法:delete法可以删除字符串缓冲区中的指定部分字符,可以指定删除开始位置和结束位置,如:StringBuffer sb = new StringBuffer(hello, worldsb.delete(5, 11);最后,StringBuffer reverse法:reverse法可以将字符串缓冲区中的字符串反转,如:StringBuffer sb = newStringBuffer(hello world!);sb.reverse();以上就是 StringBuffer常用用法,可以看出 StringBuffer一个功能强大的工具类,在处理字符串时能够帮助我们完成大量复杂的操作,极大地提高了我们处理字符串的效率。

传智播客-----笔记整理(java基础-----String,StringBuffer,StringBuilde)

传智播客-----笔记整理(java基础-----String,StringBuffer,StringBuilde)

这两天一直比较犯迷糊,每天都不知道在忙啥,所以有些断更了,真的是,咳咳,明天就要接手新班了,对我来说是喜忧参半吧,喜的是可以锻炼一下自己的能力,忧的是怕自己做不好,不过还是尽力吧。

大纲:String:1.1String方法1.2String特点1.3 StringBuffer1.4 StringBuilder1.5 Jdk升级的目的1.6 基本数据类型对象包装类1.7基本类型======>字符串1.8 字符串=====>基本类型1.9 整数具备不同的进制体现。

2.0自动拆装箱面试题挨个走一遍吧,Let's go.String:String对象的初始化由于String对象特别常用,所以在对String对象进行初始化时,Java提供了一种简化的特殊语法,格式如下:String s = “abc”;s = “Java语言”;其实按照面向对象的标准语法,其格式应该为:String s = new String(“abc”);s = new String(“Java语言”);只是按照面向对象的标准语法,在内存使用上存在比较大的浪费。

例如String s = new String(“abc”);实际上创建了两个String对象,一个是”abc”对象,存储在常量空间中,一个是使用new关键字为对象s申请的空间。

其它的构造方法的参数,可以参看String类的API文档。

1.1String方法获取获取字符串中字符的个数(长度)int length();根据位置获取字符char charAt(int index);根据字符获取在字符串中的第一次出现的位置int indexOf(int ch);【因为char类型可以转换成int(对应的是0---2^16),依据ASCII,返回-1时,表示这个字符不存在,此方法也可以判断字符是否存在。

】从指定位置进行ch的查找第一次出现位置int indexOf(int ch,int fromIndex);根据字符串获取在字符串中的第一次出现的位置int indexOf(String str);从指定位置进行ch的查找第一次出现位置int indexOf(String str,int fromIndex)根据字符获取在字符串中的最后一次出现的位置int lastIndexOf(int ch);从指定位置进行ch的查找最后一次出现位置int lastIndexOf(int ch,int fromIndex);根据字符串获取在字符串中的最后一次出现的位置int latindexOf(String str);从指定位置进行ch的查找最后一次出现位置int lastindexOf(String str,int fromIndex);获取字符串中一部分字符串,也叫子串String subString(int beginIndex,int endIndex);【包含begin,但不包含end】String substring(int beginIndex);从beginIndex到最后转换将字符串变成字符串数组(字符串的切割)String [] split(String regex):【里面的条件是一个正则表达式】将字符串变成字符数组char [] toCharArray();将字符串变成字节数组byte [] getBytes();将字符串中的字母转成大小写String toUpperCase();【大写】String toLowerCase();【小写】将字符串中的内容进行替换String replace(char oldch,char newch);String replace(String s1,String s2);将字符串两端的空格去除String trim();将字符串进行连接String concat(String str);判断两个字符串内容是否相同boolean equals(Object obj);【复写Object的方法,所以传递的是Object对象】boolean equalsIgnoreCase(String str);忽略大写比较字符串内容。

String、StringBuffer和StringBuilder区别

String、StringBuffer和StringBuilder区别

String、StringBuffer和StringBuilder区别String、StringBuffer和StringBuilder区别1、长度是否可变String 是被 final 修饰的,他的长度是不可变的,就算调⽤ String 的concat ⽅法,那也是把字符串拼接起来并重新创建⼀个对象,把拼接后的 String 的值赋给新创建的对象StringBuffer 和 StringBuilder 类的对象能够被多次的修改,并且不产⽣新的未使⽤对象,StringBuffer 与 StringBuilder 中的⽅法和功能完全是等价的。

调⽤StringBuffer 的 append ⽅法,来改变 StringBuffer 的长度,并且,相⽐较于 StringBuffer,String ⼀旦发⽣长度变化,是⾮常耗费内存的!2、执⾏效率三者在执⾏速度⽅⾯的⽐较:StringBuilder > StringBuffer > String3、应⽤场景如果要操作少量的数据⽤ = String单线程操作字符串缓冲区下操作⼤量数据 = StringBuilder多线程操作字符串缓冲区下操作⼤量数据 = StringBufferStringBuffer和StringBuilder区别1、是否线程安全StringBuilder 类在 Java 5 中被提出,它和 StringBuffer 之间的最⼤不同在于 StringBuilder 的⽅法不是线程安全的(不能同步访问),StringBuffer是线程安全的。

只是StringBuffer 中的⽅法⼤都采⽤了 synchronized 关键字进⾏修饰,因此是线程安全的,⽽StringBuilder 没有这个修饰,可以被认为是线程不安全的。

2、应⽤场景由于 StringBuilder 相较于 StringBuffer 有速度优势,所以多数情况下建议使⽤ StringBuilder 类。

3P测试题

3P测试题

事件机制
事件监听器接口,定义了事件的处理方法。
事件源:产生事件的组件
事件源对自己感兴趣的事件进行注册(注册监听器),然后事件源一旦产生事件,就会调用相应的事件处理方法,执行相应的代码。
JAVA中的多形与继承,可出编程,选择题。
抽象类与接口,接口的好处是将实现与表现分离。
String有有length()这个方法。
Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写(Overriding)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。
Collection是个java.util下的接口,它是各种集合结构的父接口。
GC是什么? 为什么要有GC?
Garbage Collection
GC是垃圾收集器。Java 程序员不用担心内存管理,因为垃圾收集器会自动进行管理。
Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
}
public static void main(String[] args)
{
OuterClass oc = new OuterClass();
}
}
输出结果:
C:\>java test/OuterClass
InterClass Create
OuterClass Create

JAVA中String与StringBuffer的区别

JAVA中String与StringBuffer的区别

JAVA中String与StringBuffer的区别在java中有3个类来负责字符的操作。

1.Character 是进行单个字符操作的,2.String 对一串字符进行操作。

不可变类。

3.StringBuffer 也是对一串字符进行操作,但是可变类。

String:是对象不是原始类型.为不可变对象,一旦被创建,就不能修改它的值.对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去. String 是final类,即不能被继承.StringBuffer:是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象它只能通过构造函数来建立,StringBuffer sb = new StringBuffer();note:不能通过付值符号对他进行付值.sb = "welcome to here!";//error对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer中付值的时候可以通过它的append方法.sb.append("hello");字符串连接操作中StringBuffer的效率要比String高:String str = new String("welcome to ");str += "here";的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最后再将StringBuffer toSting();这样的话String的连接操作就比StringBuffer多出了一些附加操作,当然效率上要打折扣.并且由于String 对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的值. 这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.看看以下代码:将26个英文字母重复加了5000次,1. String tempstr = "abcdefghijklmnopqrstuvwxyz";2. int times = 5000;3. long lstart1 = System.currentTimeMillis();4. String str = "";5. for (int i = 0; i < times; i++) {6. str += tempstr;7. }8. long lend1 = System.currentTimeMillis();9. long time = (lend1 - lstart1);10. System.out.println(time);可惜我的计算机不是超级计算机,得到的结果每次不一定一样一般为46687左右。

stringbuffer的delete方法

stringbuffer的delete方法

stringbuffer的delete方法string与stringbuffer的区别简单地说,就是一个变量和常量的关系。

stringbuffer对象的内容可以修改;而string对象一旦产生后就不可以被修改,重新赋值其实是两个对象。

1.stringbuffer:stringbuffer的内部实现方式和string不同,stringbuffer在进行字符串处理时,不生成新的对象,在内存使用上要优于string类。

所以在实际使用时,如果经常须要对一个字符串展开修正,比如填入、删掉等操作方式,采用stringbuffer必须更加适宜一些。

2.string:在string类中没有用来改变已有字符串中的某个字符的方法,由于不能改变一个java字符串中的某个单独字符,所以在jdk文档中称string类的对象是不可改变的。

然而,不可改变的字符串具有一个很大的优点:编译器可以把字符串设为共享的。

二、stringbuffer的常用方法stringbuffer类中的方法要偏重于对字符串的变化例如追加、插入和删除等,这个也是stringbuffer和string类的主要区别。

1.append方法public stringbuffer append(boolean b)该方法的促进作用就是新增内容至当前stringbuffer对象的末尾,类似字符串的相连接。

调用该方法以后,stringbuffer对象的内容也出现发生改变,比如:stringbuffer sb = new stringbuffer(“abc”);sb.append(true);则对象sb的值将变成”abctrue”。

则对象sb的值将变为”abctrue”。

使用该方法进行字符串的连接,将比string更加节约内容,例如应用于数据库sql 语句的连接,例如:string user = “test”;string pwd = “”;sb.append(“select * from userinfo where username=“).append(user).append(“ and pwd=”).append(pwd);这样对象sb的值就是字符串“select * from userinfo where username=test and pwd=”。

Java之字符串String,StringBuffer,StringBuilder

Java之字符串String,StringBuffer,StringBuilder

Java之字符串String,StringBuffer,StringBuilder String类:String类即字符串类型,并不是Java的基本数据类型,但可以像基本数据类型⼀样使⽤,⽤双引号括起来进⾏声明。

在Java中⽤String类的构造⽅法来创建字符串变量。

声明字符串:声明⼀个字符串就是创建⼀个字符串对象。

//可以声明单个也可以同时声明多个字符串对象,声明不赋值,这个对象就是空,也就是 String a= null;String a;String b,c;创建字符串:给字符串赋值就是创建字符串的过程。

1.给字符串赋值的四种⽅法:(1).引⽤字符串常量String a="hi";String b="hello",c="world";String d;d="hello world";(2).利⽤构造⽅法直接实例化// 1.String a=new String("hello ");// 2.String b=new String(a);(3).利⽤字符数组实例化char[] charArr={'t','i','m','e'};String a=new String(charArr);String b=new String(charArr,0,2);//从数组第0个索引开始,取2个数(4).利⽤字节数组实例化2.把任何类型转换为字符串:valueOf() ⽅法System.out.println(String.valueOf(6)); //将6转换为字符串3.连接字符串+//使⽤ + 号拼接String a="123"+456;String b=a+"hello";//使⽤ += 拼接b+="您好";System.out.println(b);4.获取字符串的长度:length() ⽅法String a="123 456 789";//获取a的长度(包括空格)赋值给sint s=a.length();System.out.println(s);5.获取指定索引位置的字符:char() ⽅法String str = " a new world a new start ";System.out.println(str.charAt(3));// 取出字符串中制定索引位置的字符6.判断⼀个字符串是否包含另⼀个字符:contains() ⽅法String str = " a new world a new start ";System.out.println(str.contains("abc"));// 判断⼀个字符串是否包含另⼀个字符串7.获取指定位置的字符返回索引:indexOf() 获取指定位置的字符四种⽅法:String str="we are the world";System.out.println(str.indexOf("e"));System.out.println(str.indexOf("e",2));//索引2之后e出现的索引System.out.println(stIndexOf("e"));System.out.println(stIndexOf("e",8));//索引8之前出现的e8.截取字符串:String id="123456************";//获取第⼗五位索引到最后的数字String e4=id.substring(15);//获取第六位到⼗四位索引,即⽣⽇String bir=id.substring(6,14);System.out.println("您的⽣⽇是:"+bir);9.判断字符串是否相等:需要特别注意的是,如果定义两个字符串再⽤ == 去判断它们是否相等,那么他们的结果⼀定是false。

stringbuffer常用方法

stringbuffer常用方法

stringbuffer常用方法StringBuffer是Java中一个重要的字符串处理类,它提供了多种方法,可以实现不同的字符串操作。

StringBuffer提供的方法大致可以分为四类:构造();、附加(append)和插入(insert)、替换(replace)以及删除(delete)和反转(reverse)等。

一、构造方法StringBuffer():创建一个具有默认初始容量的空字符串缓冲区 StringBuffer(int capacity):创建一个具有指定capacity容量的空字符串缓冲区。

StringBuffer(String str):创建一个具有指定字符串内容的字符串缓冲区,StringBuffer(CharSequence seq):创建一个具有指定序列的字符串缓冲区二、append()append()方法可以把指定的内容追加到字符串缓冲区的尾部,它可以接受任意类型的数据,可以追加单个字符,字符串,基本数据类型的数据,数组,对象等。

三、insert()insert()方法可以把指定的内容插入到字符串缓冲区的指定位置上,它可以接受任意类型的数据,可以插入单个字符,字符串,基本数据类型的数据,数组,对象等。

四、replace()replace()方法可以把字符串缓冲区的指定位置的内容替换成指定的字符串,它接受两个参数,第一个参数是指定的起始位置,第二个参数是指定的替换字符串。

五、 delete()delete()方法可以删除字符串缓冲区的指定位置的内容,它接受两个参数,第一个参数是起始位置,第二个参数是结束位置。

六、reverse()reverse()方法可以把字符串缓冲区中的内容反转过来,即把字符串缓冲区中的第一个字符变成最后一个字符,把最后一个字符变成第一个字符,依次类推,这可以用来实现字符串的倒序输出。

总之,StringBuffer拥有多种用途,可以实现简单的插入和替换以及字符串复制,而且它还可以实现字符串反转,比较简单,十分方便。

Java程序设计基础习题答案

Java程序设计基础习题答案

Java程序设计基础课后习题参考答案第2章1. 关于Java Application 的入口方法main()的检验:main()方法的参数名是否可以改变?main()方法的参数个数是否可以改变?该方法名是否可以改变?参考答案:(1)main()方法的参数名可以改变。

(2)main()方法的参数个数不可以改变。

(3)该方法名不可以改变。

2. 当一个程序没有main()方法时,能编译吗?如果能编译,能运行吗?参考答案:当一个程序没有main()方法是,是可以编译通过的,但是不能给运行,因为找不到一个主函数入口。

3. 下列语句能否编译通过?byte i = 127;byte j = 128;long l1 = 999999;long l2 = 9999999999;参考答案:byte i 和long l1可以编译通过。

而byte j 和long l2 超出自身数据类型范围,所以编译失败。

4. 下列语句能否编译通过?float f1 = 3.5;float f2 = 3.5f;参考答案:java中浮点型的数据在不声明的情况下都是double型的,如果要表示一个数据是float型的,必须在数据后面加上“F”或“f”;因此,float f1 无法编译通过。

5. 验证int 和char,int和double等类型是否可以相互转换。

参考答案:(1)char类型可以转换为int 类型的,但是int类型无法转换为char类型的;(2)int 可以转换为double类型的,但是double类型无法转换为int 类型的。

6. 计算下列表达式,注意观察运算符优先级规则。

若有表达式是非法表达式,则指出不合法之处且进行解释。

(1) 4+5 == 6*2 (2) (4=5)/6(3) 9%2*7/3>17 (4) (4+5)<=6/3(5) 4+5%3!=7-2 (6) 4+5/6>=10%2参考答案:表达式(2)为不合法表达式,只能将值赋值给一个变量,因此其中(4=5)将5赋值给4是不合法的。

java关于StringBuffer和StringBuilder写入文件的效率问题

java关于StringBuffer和StringBuilder写入文件的效率问题

java关于StringBuffer和StringBuilder写⼊⽂件的效率问题 StringBuffer在存储字符的时候,是有上限的,⼀旦达到上线就会出错,⾃⼰在项⽬中遇到⼀个从数据库中查询数据,然后写⼊到本地⽂件中,数据量⼤概有30万条,此时的效率⼗分的低。

下⾯是⼤致的模拟该程序的代码,项⽬代码由于是银⾏的项⽬,就不贴出来了。

看下⼤致的模拟代码1public class lis {23public static void main(String[] args) throws IOException {4 File file1 = new File("D:\\io\\out.txt");5 BufferedWriter bw = new BufferedWriter(new FileWriter(file1));6 StringBuffer buffer = new StringBuffer("S|1|S0180||||");78 buffer.append("\r\n");910 List subList = new ArrayList();11 List listid = new ArrayList();12long s= System.currentTimeMillis();13//防⽌⼤于1万条时出错,循环处理14for (int i = 0; i < 60; i++) {15for(int k=0; k<5000; k++){16 buffer.append("KKKKKKKKKKKKKKKKKKKKKKKKKK"+k);17 buffer.append("\r\n");18 }19 bw.write(buffer.toString());20 bw.flush();21 buffer = new StringBuffer();22 }23long e= System.currentTimeMillis();24 System.out.println(e-s);25 bw.close();26 }27 }⽤时第24⾏输出结果为230~236之间。

Java基础篇--字符串处理(StringBuffer)

Java基础篇--字符串处理(StringBuffer)

Java基础篇--字符串处理(StringBuffer)字符串处理在Java中最常将字符串作为String类型对象来处理。

同时String中也提供了很多操作字符串的函数(可⾃⾏查阅资料),⽽本篇将介绍StringBuffer如何操作字符串。

StringBuffer是使⽤缓冲区的,本⾝也是操作字符串的,但与String类不同,String类中的内容⼀旦声明之后不可改变,改变的只是其内存地址的指向,⽽StringBuffer中的内容是可以改变的,对于StringBuffer⽽⾔,本⾝是⼀个具体的操作类,所以不能像String那样采⽤直接赋值的⽅式进⾏对象实例化,必须通过构造⽅法完成。

StringBuffer连接字符操作当⼀个字符串的内容需要被经常改变时就要使⽤StringBuffer在StringBuffer中使⽤append()⽅法,完成字符串的连接操作实例操作⼀:字符串连接操作(append)代码:package字符串处理;public class StringBufferDemo01{public static void main(String args[]){StringBuffer buf = new StringBuffer() ; // 声明StringBuffer对象buf.append("Hello ") ; // 向StringBuffer中添加内容buf.append("World").append("!!!") ; // 可以连续调⽤append()⽅法buf.append("\n") ; // 添加⼀个转义字符buf.append("数字 = ").append(1).append("\n") ; // 添加数字buf.append("字符 = ").append('C').append("\n"); // 添加字符buf.append("布尔 = ").append(true) ; // 添加布尔值System.out.println(buf) ; // 直接输出对象,调⽤toString()}};打印结果:Hello World!!!数字 = 1字符 = C布尔 = true实例操作⼆:字符串添加内容(insert)public class StringBufferDemo03{public static void main(String args[]){StringBuffer buf = new StringBuffer() ; // 声明StringBuffer对象buf.append("World!!") ; // 添加内容buf.insert(0,"Hello ") ; // 在第⼀个内容之前添加内容System.out.println(buf) ;buf.insert(buf.length(),"偶my耶~") ; // 在最后添加内容System.out.println(buf) ;}};打印内容Hello World!!Hello World!!偶my耶~实例操作三:字符串反转(reverse)package字符串处理;public class StringBufferDemo04{public static void main(String args[]){StringBuffer buf = new StringBuffer() ; // 声明StringBuffer对象buf.append("World!!") ; // 添加内容buf.insert(0,"Hello ") ; // 在第⼀个内容之前添加内容String str = buf.reverse().toString() ; // 将内容反转后变为String类型System.out.println(str) ; // 将内容输出}};打印内容:!!dlroW olleH实例操作四:替换字符串指定内容(replace)public class StringBufferDemo05{public static void main(String args[]){StringBuffer buf = new StringBuffer() ; // 声明StringBuffer对象buf.append("Hello ").append("World!!") ; // 向StringBuffer添加内容buf.replace(6,11,"偶my耶") ; // 将world的内容替换System.out.println("内容替换之后的结果:" + buf) ; // 输出内容}};打印内容:内容替换之后的结果:Hello 偶my耶!!实例操作五:字符串截取(substring,delete)package字符串处理;public class StringBufferDemo06{public static void main(String args[]){StringBuffer buf = new StringBuffer() ; // 声明StringBuffer对象buf.append("Hello ").append("World!!") ; // 向StringBuffer添加内容buf.replace(6,11,"偶my耶") ; // 将world的内容替换String str = buf.substring(6,11) ; // 截取指定范围的内容// String str = buf.delete(6,11).toString() ;// 删除指定范围中的内容System.out.println(buf);System.out.println("内容替换之后的结果:" + str) ; // 输出内容}};打印结果Hello 偶my耶!!内容替换之后的结果:偶my耶!实例操作六:查找指定内容(indexOf)package字符串处理;public class StringBufferDemo08{public static void main(String args[]){StringBuffer buf = new StringBuffer() ; // 声明StringBuffer对象buf.append("Hello ").append("World!!") ; // 向StringBuffer添加内容if(buf.indexOf("Hello")==-1){System.out.println("没有查找到指定的内容") ;}else{ // 不为01表⽰查找到内容System.out.println("可以查找到指定的内容") ;}}};打印内容可以查找到指定的内容在StringBuffer中还有许多的函数就不⼀⼀介绍了!想要更深去了解可查阅相关资料,下⾯介绍⼀个使⽤String和StringBuffer来操作字符串的案列案列之⼩写⾦额变⼤写⾦额package com.lh.bean;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class StringUtil {private String money; //转换之前的数字⾦额private String submoneyCN[]={"","拾","佰","仟"}; //表⽰数字位数的数组private String numberCNN[]={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"}; //⼤写数字的数组private String je="零壹贰叁肆伍陆柒捌玖"; //⼤写的数字(0-9)private String cdw="万仟佰拾亿仟佰拾万仟佰拾元⾓分"; //⾦额单位public StringUtil(){} //默认的构造⽅法public void setMoney(String money){this.money=money;}public String getMoney(){return convert(this.money);}/*** 转换数字⾦额为⼤写⾦额* @return返回转换后的⼤写⾦额*/public String convert(String money){String formatCN="";int point=money.indexOf("."); //判断字符串是否包含⼩数点if(point!=-1){String money1=money.substring(0,point); //⼩数点之前的部分String money1_1=(new StringBuffer(money1).reverse()).toString();//字符串倒序String money2=money.substring(point+1); //⼩数点之后的部分if(money2.length()<2){ //如果⼩数点后的部分少于两位,⽤"0"补齐if(money2.length()==0)money2="00";elsemoney2+="0";}else//如果⼩数点后的位数⼤于2位,则只前2位money2=money.substring(point+1,point+3);int len = money1_1.length(); //字符串反转之后,⼩数点之前的字符位数int pos=len-1;String sigle="";boolean allhavenum=false;boolean havenum=false;boolean mark=false; //设置⼀个开关变量,若当前数为"0",将该值设为true;不为"0"时设为false/**以下代码为读出⼩数点左⾯的部分*/while(pos>=0){sigle=money1_1.substring(pos,pos+1);//截取1位数字,⽐如数字1234.56,将左侧的字符串反转,值为4321,则截取的值为1 /**读取“亿单元”的代码。

关于String和StringBuffer判断是否为空的情况

关于String和StringBuffer判断是否为空的情况

判断StringBuffer是否为空的方法,先利用toString()方法转为字符串,然后在利用equals()方法。
1 if(!errors.toString().equals( if (name != null && !name.equals("")) { 2 //do something 3}
2 比较字符串长度, 效率高
1 if(s == null || s.length() <= 0);
3 效率和方法二几乎相等, 但出于兼容性考虑, 推荐使用此方法
1 if(s == null || s.isEmpty());
博客园 用户登录 代码改变世界 密码登录 短信登录 忘记登录用户名 忘记密码 记住我 登录 第三方登录/注册 没有账户, 立即注册
关于 String和 StringBuffer判断是否为空的情况
判断String的方式
1 直接判断 (一定要先判断是否为null,在判断是否为"",也就是先判断起是否为一个对象,然后在判断其值是否为"",判断其值可以用其他 的方式。)

strings命令的用法

strings命令的用法

strings命令的用法打印文件中的可打印字符串(print the strings of printable characters in files)。

常用来在二进制文件中查找字符串,与grep配合使用。

strings命令输出的字符串长度为4个或4个以上的,长度小于4的字符串将不予打印,我们可以通过-n参数调整,strings -n 2strings命令是在对象文件或者二进制文件中查找可打印的字符串,有很多的用途,例如一个用法就是在编译的so中定义字符串常量作为动态库的版本号,然后就可以使用strings+grep 组合命令查看当前编译的so的版本号了。

输入strings -h查看strings命令的用法:用法:strings [选项] [文件]打印 [文件] (默认为标准输入) 中可打印的字符串选项为:-a - --all Scan the entire file, not just the data section [default]-d --data Only scan the data sections in the file-f --print- Print the name of the each string -n --bytes=[number] Locate & print any NUL-terminated sequence of at-<number> least [number] characters (default4).-t --radix={o,d,x} Print the location of the stringinbase8, 10 or 16-w --include-all-whitespace Include all whitespace as valid string characters-o An alias for --radix=o-T --target=<BFDNAME> Specify the binary-e --encoding={s,S,b,l,B,L} Select character sizeand endianness:s = 7-bit, S = 8-bit, {b,l} = 16-bit, {B,L} = 32-bit-s --output-separator=<string> String used to separate strings in output.@<; Read options from <;-h --help Display this information-v -V --version Print the program'sversion numberstrings:支持的目标: elf64-x86-64 elf32-i386 elf32-iamcu elf32-x86-64 a.out-i386-linux pei-i386 pei-x86-64 elf64-l1om elf64-k1om elf64-little elf64-big elf32-little elf32-big pe-x86-64 pe-bigobj-x86-64 pe-i386 plugin srec symbolsrec verilog tekhex binary ihex将 bug 报告到 <http://;在libc.so.6是c标准库,而这个标准库的制为了让库的使用者知道该库兼容哪些版本的标准库,就在这个库中定义了一些字符串常量,比如我的系统是centos6.8-x64,我的c标准库在/lib64/libc.so.6,可以直接运行该标准库文件,或者使用ldd --version查看当前版本,以下显示当前版本为2.12而使用strings /lib64/libc.so.6 | grep GLIBC,可查看向下兼容的版本:[root@localhost ~]# strings /lib64/libc.so.6 | grep GLIBCGLIBC_2.2.5GLIBC_2.2.6GLIBC_2.3GLIBC_2.3.2 GLIBC_2.3.3 GLIBC_2.3.4 GLIBC_2.4 GLIBC_2.5 GLIBC_2.6 GLIBC_2.7 GLIBC_2.8 GLIBC_2.9 GLIBC_2.10 GLIBC_2.11 GLIBC_2.12 GLIBC_PRIVATE。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

import java.util.StringTokenizer;
public class SSDemo {
public static void main(String[] args) {
String str="Hello world!";
StringBuffer buffer=new StringBuffer("Hello world!");
System.out.println("str内容:"+str);
StringBuffer b=new StringBuffer("");
System.out.println("长度:"+str.length());
System.out.println("逐个输出字符串:");
for(int i=0;i<str.length();i++){
System.out.print("第"+i+"位:"+str.charAt(i)+" ");
}
System.out.println();
System.out.println("出现字符o的第一个位置:
"+str.indexOf("o"));
System.out.println("出现字符o的最后一个位置:
"+stIndexOf("o"));
System.out.println("从位置6到位置10之间(不包括第11位置的字符串)的字符串为:"+str.substring(6,10));
System.out.println("字符串大写:"+str.toUpperCase());
System.out.println("字符串小写:"+str.toLowerCase());
System.out.println("将H替换为h:"+str.replace('l','L'));
System.out.println("str与字符串Beijing相连:
"+str.concat("Hello Beijing!"));
System.out.println("-----------------------------------");
System.out.println("buffer内容:"+buffer);
System.out.println("空StringBuffer的长度:"+b.length());
System.out.println("空StringBuffer的capacity:
"+b.capacity());
System.out.println("buffer长度:"+buffer.length());
System.out.println("buffer长度+capacity(缓冲区的长度):
"+buffer.capacity());
System.out.println("逐个输出字符串:");
for(int i=0;i<buffer.length();i++){
System.out.print("第"+i+"位:"+buffer.charAt(i)+" ");
}
System.out.println();
buffer.append("Hello Beijing");//连接
System.out.println("连接Hello Beijing为:"+buffer);
buffer.insert(0,"lilin ");
System.out.println("在0位插入lilin为:"+buffer);
System.out.println("StringTokenizer字符串分析:");
StringTokenizer st=new StringTokenizer("I am a
student!");//默认以空白字符串,制表符,换行符,回车符,换页符作为分隔符while(st.hasMoreTokens()){
System.out.print(st.nextToken()+" ");}
System.out.println();
StringTokenizer st1=new
StringTokenizer("001012106","0");//以0作为分隔符
while(st1.hasMoreTokens()){
System.out.print(st1.nextToken()+" ");}
//字符串的比较
String s1="Hello";
String s2="Hello";
String s3=new String(s1);
String s4=new String("Hello");
System.out.println(pareTo("hello"));//H和h的ASSCII码值相差32
System.out.println(pareToIgnoreCase("hello"));
System.out.println(s1.equals("hello"));
System.out.println(s1.equalsIgnoreCase("hello"));
System.out.println("s1.equals(s2):"+s1.equals(s2));//equals 比较的是字符串的内容
System.out.println("s1==s2:"+(s1==s2));//==比较的是内存地址
System.out.println("s1.equals(s3):"+s1.equals(s2));
System.out.println("s1==s3:"+(s1==s3));
System.out.println("s3.equals(s4):"+s1.equals(s2));
System.out.println("s3==s4:"+(s3==s4));
}
}
运行结果:
str内容:Hello world!
长度:12
逐个输出字符串:
第0位:H 第1位:e 第2位:l 第3位:l 第4位:o 第5位:第6位:w 第7位:o 第8位:r 第9位:l 第10位:d 第11位:!
出现字符o的第一个位置:4
出现字符o的最后一个位置:7
从位置6到位置10之间(不包括第11位置的字符串)的字符串为:worl
字符串大写:HELLO WORLD!
字符串小写:hello world!
将H替换为h:HeLLo worLd!
str与字符串Beijing相连:Hello world!Hello Beijing!
-----------------------------------
buffer内容:Hello world!
空StringBuffer的长度:0
空StringBuffer的capacity:16
buffer长度:12
buffer长度+capacity(缓冲区的长度):28
逐个输出字符串:
第0位:H 第1位:e 第2位:l 第3位:l 第4位:o 第5位:第6位:w 第7位:o 第8位:r 第9位:l 第10位:d 第11位:!
连接Hello Beijing为:Hello world!Hello Beijing
在0位插入lilin为:lilin Hello world!Hello Beijing
-------------------------------------------------
StringTokenizer字符串分析:
I am a student!
1 121 6 -32
false
true
s1.equals(s2):true
s1==s2:true
s1.equals(s3):true
s1==s3:false
s3.equals(s4):true
s3==s4:false。

相关文档
最新文档