string StringBuffer stringbuilder 详解

Eric Huang’s Creative Studio

实际编程中对字符串的处理是我们经常不得不面对的问题。而对于java开发人员来说，我们可以很方便的处理字符串操作。但是我们有时候使用时又有些迷惑，因为API中共提供了String，StringBuffer，StringBuilder三个类，让我们不知道怎么取舍。本文就是好好研究一下这几个类之间的区别，帮助我们开发时选用正确的方式处理字符串。言归正传，下面我就一一道来：

对于String类型，如果说它是否线程安全个人觉得不太合适，因为线程安全与否主要是针对可变类状态的改变可能存在的不一致性，而String本身是常量，根本无法改变其状态，所以用线程安全来说有失偏颇，代码层次上也每对String类型做同步上的处理。

下面给一个简单的例子说说String类型的内部处理机制：

String s1 = “eric”;

String s2 = “huang”;

s1 = s1+s2;

我们知道String类型是字符串常量，之所以可以对两个字符串采用+操作符，主要是Java内部对+进行了重载，虚拟机首先在常量内存区域创建了s1和s2两个字符串常量，然后分配再分配部分内存存储s1和s2相加的结果，最后将s1指向这块内存区域，故s1不会再指向”eric”代表的内存区域了。可以想象，当我们的字符串要被循环拼接若干段时，用String类直接操作会带来多少额外的系统开销。所以经常改变内容的字符串最好不要用String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后，JVM 的GC 就会开始工作，耗用了很多cpu时间，那速度是一定会相当慢的。

当我们在构造字符串的时候，我们应该用StringBuffer 来实现大部分的工作，当工作完成后将StringBuffer 对象再转换为需要的String 对象（toString方法）。比如：如果有一个字符串必须不断地在其后添加许多字符来完成构造，那么我们应该使用StringBuffer 对象和它的append() 方法。String 类将StringBuffer 类封装了起来，（以花费更多时间为代价）为开发人员提供了一个安全的接口。

Java SE 5.0提供https://www.wendangku.net/doc/583913805.html,ng.StringBuilder类，它是StringBuffer的一个单线程等价类，提供一个与之兼容的API。由于不执行同步，所以速度更快。使用这个类所产生的对象默认会有16个字符的长度，您也可以自行指定初始长度。如果附加的字符超出可容纳的长度，则StringBuilder对象会自动增加长度以容纳被附加的字符。如果有频繁作字符串附加的需求，使用StringBuilder会让程序的效率大大提高。

使用StringBuilder最后若要输出字符串结果，可以用toString()方法。可以使用length()方法得知目前对象中的字符长度，而capacity()可返回该对象目前可容纳的字符容量。其它具体方法参加API。

去绝对值常用方法

. （初一）去绝对值常用“六招” （初一）六招”去绝对值常用“难度大，解绝对值问题要求高，绝对值是初中数学的一个重要概念，是后续学习的必备知识。不易把握，解题易陷入困境。下面就教同学们去绝对值的常用几招。一、根据定义去绝对值的值-│c│c = - 8时，求3│a│-2│b│例1、当a = -5，b = 2，负数的绝所以根据绝对值的意义即正数的绝对值是它本身，分析：这里给出的是确定的数，。代值后即可去掉绝对值。的绝对值是0对值是它的相反数，00 ＜ c = -8b =2＞0，解：因为：a = -5＜0，[ - ( - 8 ) ] = 7 2 ×2 --5）] –所以由绝对值的意义，原式= 3 [ -（”相关信息去绝对值二、从数轴上“读取c在数轴上的a、b、例2、有理数- │a│-a│+│c-b│+│a+b│位置如图所示，且│a│=│b│，化简│c的正负性，由数轴上点的位置特征，即可去绝对、a + bc - a、c-b分析：本题的关键是确定值。- a = b b 且＜c＜解：由已知及数轴上点的位置特征知：a＜0 b ) ] + 0 - ( - a ) = b –故原式= c - a + [ - ( c c - b＜0，a + b = 0 从而 c –a ＞0 ，三、由非负数性质去绝对值22的值。= 0，求-25│+ ( b –2 )ab：已知例3│a 。分析：因为绝对值、完全平方数为非负数，几个非负数的和为零，则这几个数均为“0”222 2 = 0 –由绝对值和非负数的性质：ab 解：因为│a-25 = 0 -25 │+ ( b – 2 )且= 0 ab = - 10 ab = 10或a = - 5 b = 2 故即a = 5 b = 2 或四、用分类讨论法去绝对值的值。abc≠0，求+ + 4例、若同为正号还是同为负号；两个同为正（负）号，另、c，所以只需 考虑a、b分析：因abc≠0一个为负（正）号，共八种情况。但因为两正（负）、一负（正）的 结果只有两种情况，所以其值只有四种情况。异号。b、、c、b、c有同为正号、同为负号和aa 解：由abc≠0可知，= 3 + + + = + 、c都为“+”时，b当a、= - 3 ---”时，+ + = c当a、b、都为“-+ + = 1 时，“-”、a、bc中两“+”一当+ + = - 1 “+”时，中两“-”一ca 当、b、五、用零点分段法去绝对值的最小值。2│+│x -3│-例5：求│x + 1│+│x 的值的符号也在变化。关键是把各式绝对值x -3–x 2、、在有理数范围变化，分析：xx + 1解 这类问题的基本步骤是：的取值进行分段讨论，为此要对符号去掉。x然后选取其最小值。. . 求零点、分区间、定性质、去符号。即令各绝对值代数式为零，得若干个绝对值为零的点，这些点把数轴分成几个区间，再在各区间化简求值即可。。由绝对值意义分别讨论如下：，3可确定零点为- 1，2，解：由x + 1 = 0x - 2 = 0，x - 3 = 03 + 4 = 7 ＞– 3 ) ] = -3 x + 4 -1时，原式= -( x + 1 ) + [ - ( x –2 ) ] + [ - ( x 当x＜-2 + 6 = 4 3 ) ] = - x + 6 ＞时，原式= ( x + 1 ) + [ -( x –2 ) ] + [ - ( x –当-1 ≤x ＜2 2 + 2 = 4 x + 2 ≥= –2 ) + [ - ( x –3 ) ] 当2 ≤x ＜3时，原式= ( x + 1 ) + ( x - 4 = 5 4 ≥3×3 –2 ) + ( x 3 ) = 3x –x ≥3时，原式= ( x + 1 ) + ( x –当4。故所求最小值是六、平方法去绝对值-3│、解方程│x-1│=│x例6所以对所分析：对含有绝对值的方程，用平方法是去绝对值的方法之一，但可能产生增根，求解必须进行检验，舍去增根。22 x=2是原不等式的根。x=2 x经检验，- 2x +1= x - 6x + 9 有4x =8，得解：两边平方： c在数轴上的位置、b、练习1、已知实数a │a│=│c│，化简：如图，且- b│+│a││a+c

String总结

String 方法总结： charAt(int index) 返回 char指定索引处的值。 equals(Object anObject) 将此字符串与指定对象进行比较。 endsWith(String suffix) 测试此字符串是否以指定的后缀结尾。 contains(CharSequence s) 当且仅当此字符串包含指定的char值序列时才返回true。 getBytes() 使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中。hashCode() 返回此字符串的哈希码。 indexOf(int ch) 返回指定字符第一次出现的字符串内的索引。 lastIndexOf(int ch) 返回指定字符的最后一次出现的字符串中的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回从替换所有出现的导致一个字符串 oldChar在此字符串newChar 。 split(String regex) 将此字符串分割为给定的 regular expression的匹配。 substring(int beginIndex, int endIndex) 返回一个字符串，该字符串是此字符串的子字符串。 trim() 返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。 StringBuffer类和String一样，也用来代表字符串。只是由于StringBuffer的内部实现方式和String不同，所以StringBuffer在进行字符串处理时，不生成新的对象，在内存使用上要优于String类。 所以在实际使用时，如果经常需要对一个字符串进行修改，例如插入、删除等操作，使用StringBuffer要 更加适合一些。 在StringBuffer类中存在很多和String类一样的方法，这些方法在功能上和String类中的功能是完全一 样的。但是，对StringBuffer对象的每次修改都会改变对象自身，这点是和String类最大的区别。 另外由于StringBuffer是线程安全的，所以在多线程程序中也可以很方便的进行使用，但是程序的执行效 率相对来说就要稍微慢一些。 1、StringBuffer对象的初始化 一般使用构造方法进行初始化。例如： StringBuffer s = new StringBuffer(); //这样初始化出的StringBuffer对象是一个空的对象。 StringBuffer s = new StringBuffer(“abc”); //这样初始化出的StringBuffer对象的内容就是字符 串”abc”。 需注意，StringBuffer和String属于不同的类型，也不能直接进行强制类型转换，下面的代码都是错误的： StringBuffer s = “abc”; //赋值类型不匹配 StringBuffer s = (StringBuffer)”abc”; //不存在继承关系，无法进行强转 StringBuffer对象和String对象之间的互转的代码如下： String s = “abc”; StringBuffer s2sb = new StringBuffer(s); //String转换为StringBuffer StringBu ffer sb = new StringBuffer(“123”); String sb2s = sb.toString(); //StringBuffer转换为String 2、StringBuffer的常用方法 StringBuffer类中的方法主要偏重于对于字符串的变化，例如追加、插入和删除等，这个也是StringBuffer和String类的主要区别。 a、append方法 public StringBuffer append(boolean b) 该方法的作用是追加内容到当前StringBuffer对象的末尾，类似于字符串的连接。调用该方法以后，StringBuffer对象的内容也发生改变， 例如： StringBuffer sb = new StringBuffer(“abc”); sb.append(true); //则对象sb的值将变成”abctrue”。

去绝对值符号的几种常用方法精编版

去绝对值符号的几种常用方法 解含绝对值不等式的基本思路是去掉绝对值符号，使不等式变为不含绝对值符号的一般不等式，而后，其解法与一般不等式的解法相同。因此掌握去掉绝对值符号的方法和途径是解题关键。 1．利用定义法去掉绝对值符号 根据实数含绝对值的意义，即|x |=(0)(0)x x x x ≥??-????≤?； |x |>c (0)0(0)(0)x c x c c x c x R c <->>???≠=??∈c (c >0)来解，如|ax b +|>c (c >0)可为ax b +>c 或ax b +<－c ；|ax b +|或||||x a x b m -+-<(m 为正常数)类型不等式。对||||ax b cx d m +++>(或

stringbuilder与stringbuffer的区别

相信大家看到过很多比较String和StringBuffer区别的文章，也明白这两者的区别，然而自从Java 5.0发布以后，我们的比较列表上将多出一个对象了，这就是StringBuilder类。String类是不可变类，任何对String的改变都会引发新的String对象的生成；而StringBuffer则是可变类，任何对它所指代的字符串的改变都不会产生新的对象，可变和不可变类这一对对象已经齐全了，那么为什么还要引入新的StringBuilder类干吗？相信大家都有此疑问，我也如此。下面，我们就来看看引入该类的原因。 为什么会出现那么多比较String和StringBuffer的文章？ 原因在于当改变字符串内容时，采用StringBuffer能获得更好的性能。既然是为了获得更好的性能，那么采用StringBuffer能够获得最好的性能吗？ 答案是NO！ 为什么？ 如果你读过《Think in Java》，而且对里面描述HashTable和HashMap区别的那部分章节比较熟悉的话，你一定也明白了原因所在。对，就是支持线程同步保证线程安全而导致性能下降的问题。HashTable是线程安全的，很多方法都是synchronized方法，而HashMap不是线程安全的，但其在单线程程序中的性能比HashTable要高。StringBuffer和StringBuilder类的区别也在于此，新引入的StringBuilder类不是线程安全的，但其在单线程中的性能比StringBuffer高。如果你对此不太相信，可以试试下面的例子： package com.hct.test; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /** * @author: chengtai.he * @created:2009-12-9 上午09:59:57 */ public class StringBuilderTester { private static final String base = " base string. "; private static final int count = 2000000; public static void stringTest() { long begin, end; begin = System.currentTimeMillis(); String test = new String(base); for (int i = 0; i < count/100; i++) { test = test + " add "; } end = System.currentTimeMillis(); System.out.println((end - begin) + " millis has elapsed when used String. "); } public static void stringBufferTest() { long begin, end;

StringBuffer的一些方法

StringBuffer的一些方法 注：对StringBuffer的一些了解，首先StringBuffer是一个类，所以在使用的时候要创建实例，当然在创建的同时，这个实例化会在缓冲区中产生。所以在被调用的时候会很方便，速度远远大于String。StringBuffer在每次输出或者进行其他操作的时候都会自动转化成String类型的。因为.toString()方法在https://www.wendangku.net/doc/583913805.html,ng中的方法,而我们建的包在这个包的下面 ●String和StringBuffer之间的比较 例如： //增强型字符串 StringBuffer buffer=new StringBuffer("hello"); System.out.println(buffer.toString()); //StringBuffer可以和String类型相互转换 String s=buffer.toString(); System.out.println(s); //StringBuffer和String比较永远为false System.out.println(buffer.equals(s)); 注：StringBuffer和String比较永远为false 那String和StringBuffer之间是如何比较的呢？ //将类型进行转换字符串转为StringBuffer String s=new String("hello"); StringBuffer buffer=new StringBuffer(s); StringBuffer转为String String str="hello"; StringBuffer buffer=new StringBuffer("hello"); String s=buffer.toString(); ● 1.append()方法 StringBuffer的append()和String中的concat()之间的区别 String str="hello"; StringBuffer buffer=new StringBuffer("hello"); str.concat(" niit"); //使用StringBuffer进行字符串添加 buffer.append(" niit");

去绝对值常用方法

去绝对值常用“六招”（初一） 去绝对值常用“六招” （初一） 绝对值是初中数学的一个重要概念，是后续学习的必备知识。解绝对值问题要求高，难度大，不易把握，解题易陷入困境。下面就教同学们去绝对值的常用几招。 一、根据定义去绝对值 例1、当a = -5，b = 2， c = - 8时，求3│a│-2│b│- │c│的值 分析：这里给出的是确定的数，所以根据绝对值的意义即正数的绝对值是它本身，负数的绝对值是它的相反数，0的绝对值是0。代值后即可去掉绝对值。 解：因为：a = -5＜0，b =2＞0，c = -8＜0 所以由绝对值的意义，原式= 3 [ -（-5）] – 2 ×2 - [ - ( - 8 ) ] = 7 二、从数轴上“读取”相关信息去绝对值 例2、有理数a、b、c在数轴上的 位置如图所示，且│a│=│b│，化简│c-a│+│c-b│+│a+b│-│a│ 分析：本题的关键是确定c - a、c-b、a + b的正负性，由数轴上点的位置特征，即可去绝对值。 解：由已知及数轴上点的位置特征知：a＜0＜c＜b 且- a = b 从而 c – a ＞0 ， c - b＜0， a + b = 0 故原式= c - a + [ - ( c – b ) ] + 0 - ( - a ) = b 三、由非负数性质去绝对值 例3：已知│a2-25│+ ( b – 2 )2 = 0，求ab的值。 分析：因为绝对值、完全平方数为非负数，几个非负数的和为零，则这几个数均为“0”。解：因为│a2-25│+ ( b – 2 )2 = 0 由绝对值和非负数的性质：a2-25 = 0 且b – 2 = 0 即a = 5 b = 2 或a = - 5 b = 2 故ab = 10或ab = - 10 四、用分类讨论法去绝对值 例4、若abc≠0，求+ + 的值。 分析：因abc≠0，所以只需考虑a、b、c同为正号还是同为负号；两个同为正（负）号，另一个为负（正）号，共八种情况。但因为两正（负）、一负（正）的结果只有两种情况，所以其值只有四种情况。 解：由abc≠0可知，a、b、c有同为正号、同为负号和a、b、c异号。 当a、b、c都为“+”时，+ + = + + = 3 当a、b、c都为“-”时，+ + = - - - = - 3 当a、b、c中两“+”一“-”时，+ + = 1 当a、b、c中两“-”一“+”时，+ + = - 1 五、用零点分段法去绝对值 例5：求│x + 1│+│x - 2│+│x -3│的最小值。

Java语言中String和StringBuffer的分析比较

［收稿日期］ 2012－02－01［作者简介］郑霞（1978－），女，讲师，主要从事统计自然语言处理。 Java 语言中字符串常量和变量的分析与比较 郑 霞，郭 磊 （安阳师范学院计算机与信息工程学院，河南安阳455000） ［摘要］字符串是所有编程语言中都经常需要处理的问题之一。通过对Java 语言中两类字符串，即字符串常量 String 和字符串变量StringBuffer 的分析和比较，分析了它们的特点和区别，便于程序员在以后的编程中更有效地使用它 们。 ［关键词］ String ；StringBuffer ；常量；变量［中图分类号］ TP312JA ［文献标识码］ A ［文章编号］ 1671－5330（2012）02－0046－030引言 字符串是由零个或多个字符组成的有限序 列。一般记为s =“a 1a 2…a n ” （n ＞=0）。它是编程语言中表示文本的数据类型，代表具有一定意 义的信息， 现实世界的大部分信息都以字符串的形式表示。对于一种编程语言来说，字符串处理 是许多需要进行的重要任务之一，如用户程序输入信息、 程序向用户显示信息等。所以几乎每一种编程语言都要有专门针对字符串的表示和操作。Java 语言是纯粹的面向对象的语言，所以它的字符串是用对象表示的， Java 语言的字符串分为字符串常量（用String 类的对象表示）和字符串变量（用StringBuffer 类的对象表示），它们都位于java．lang 包中，他们除了能够表示字符串外，还定义了很多专门进行字符串的处理方法。本文主要讨论定义两类字符串的特点和区别。 1 字符串常量String 类 1．1 字符串常量的创建 和创建其它的任一种对象的方式相同，创建String 对象也需要调用它的构造方法来完成，如：String s =new String （“abc ”）；也可用另一种直接赋值的方式来创建String 对象，如：String s =“abc ”； 虽然通过以上两种方式都可以创建String 对象，但是二者在创建对象时采用的内存分配方式 是不同的。如果是按照以下调用构造方法的形式来创建String 对象：String s1=new String （“abc ”）；String s2=new String （“abc ”）；s1和s2的内存分配如图1所示。s1和s2分别占有独立 的内存空间， 利用“==”相比较的话，则s1==s2的结果为false 。但是由于在程序中经常出现 大量String 对象的值相同的情况， 造成内存空间的冗余。为了有效地利用内存， Java 中预留了一块特殊的内存区域，称为String 常量池。当编译器遇到一个String 常量时，先检查常量池中是否存在值相同的String 常量，如果存在，则把该常量的引用指向常量池中的String 常量。下面是利用直接赋值的方式创建字符串的内存分配方式，如图2所示 ： 图1 字符串常量创建举例 String 对象被称为字符串常量，这表明一旦 为String 对象赋值，它的值就会保持不变。但是String 引用变量的值却可以改变。如String s =

去绝对值符号的几种常用方法

去绝对值符号的几种常用方法 解含绝对值不等式的基本思路是去掉绝对值符号，使不等式变为不含绝对值符号的一般不等式，而后，其解法与一般不等式的解法相同。因此掌握去掉绝对值符号的方法和途径是解题关键。 1．利用定义法去掉绝对值符号 根据实数含绝对值的意义，即|x |=(0)(0)x x x x ≥??-????≤? ；|x |>c (0)0(0)(0)x c x c c x c x R c <->>???≠=??∈c (c >0)来解，如|ax b +|>c (c >0)可为ax b +>c 或ax b +<－c ；|ax b +|或||||x a x b m -+-<(m 为正常数)类型不等式。对||||ax b cx d m +++>(或

String和StringBuffer

String StringBuffer区别用法 2009-09-26 09:25 String && StringBuffer的区别和用法 2007/02/24 11:02 String && StringBuffer的区别： 非可变对象一旦创建之后就不能再被改变，可变对象则可以在创建之后被改变。String对象是非可变对象；StringBuffer对象则是可变对象。为获得更佳的性能需要根据实际情况小心谨慎地选择到底使用这两者中的某一个。 String类用来表示那些创建后就不会再改变的字符串，它是不可变的(immutable)； StringBuffer类用来表示内容可变的字符串； 例： 1.String对象： String str = "Hello"; str += "World"; // JVM会创建一个临时的StringBuffer类对象，并调用其append()方法完成字符串的拼接，这是因为 String类是不可变的，拼接操作不得不使用StringBuffer类（并且－－JVM会将"Hello"和"World"创建为两个新的 String 对象）。之后，再将这个临时StringBuffer对象转型为一个String，代价不菲！可见，在这一个简单的一次拼接过程中，我们让程序创建了四个对象：两个待拼接的String，一个临时StringBuffer，和最后将StringBuffer转型成为的String－－它不是最初的str，而是最初的str的引用指向了新生成的String对象"HelloWorld"。 2.StringBuffer对象： StringBuffer strBuf = new StringBuffer("Hello"); strBuf.append("World"); // 程序将只产生两个对象：最初的strBuf ："Hello"和拼接时的String （"World"），不再需要创建临时的StringBuffer类对象而后还得将其转换回String对象。节省额外的系统开销。 如何选择是使用String还是StringBuffer： 取决于两种情况，第一种情况是需要连接的字符串是在编译期决定的还是在运行期决定的，第二种情况是你使用的是StringBuffer还是String。 1) 第一种情况：编译期决定相对于运行期决定；如： String str = "This " + "is " + "a " + "Java " + "program"; StringBuffer strBuf = new StringBuffer(); strBuf.append("This "); strBuf.append("is "); strBuf.append("a "); strBuf.append("Java "); strBuf.append("program"); 此时，+操作符比StringBuffer.append()方法要快，WHY？这里编译器的优化起了关键作用，编译器简单地在编译期连接多个字符串。它使用编译期决定取代运行期决定，在你使用new关键字来创建String对象的时候也是如此。这里

String字符串拼接对性能地影响

String、StringBuffer & StringBuilder字符串拼接对性能的影响 Author：苏康福date：2013-3-11 1.String String字符串是常量；它们的值在创建之后不能更改。 String类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写。 Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。字符串串联是通过StringBuilder（或StringBuffer）类及其append方法实现的。字符串转换是通过toString方法实现的，该方法由Object类定义，并可被Java 中的所有类继承。《JDK6》 String 类中每一个看起来会修改字符串值的方法，实际上都是创建一个全新的String 对象，以包含修改后的字符串内容。《Java Thinking》 String对象是不可变的，具有只读特性，指向它的任何引用都不可能改变它的值。String a = “Kangfu”; String b = a ; b += “Su”; String c = a.toUpperCase(); a、b、c各指向不同的对象。 String的重载操作符“+”和“+=”，可以用来链接字符串。见实验方法一。 2.StringBuffer StringBuffer，线程安全的可变字符序列。可将字符串缓冲区安全地用于多个线程。可

以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。 从JDK 5 开始，为该类补充了一个单个线程使用的等价类，即StringBuilder。与该类相比，通常应该优先使用StringBuilder类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。《JDK6》 3.StringBuilder StringBuilder，一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但不保证同步。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快。 StringBuilder 允许预先指定大小。如果知道最终字符串大概长度，那预先指定StingBuilder的大小可以避免多次重新分配缓冲。《JDK6》 4.实例分析 定义Java类（见string/test/StringConcatenation.java） 1)方法一 源码： Jvm字节码：

绝对值问题的求解方法

绝对值问题的求解方法 一、定义法 例1 若方程只有负数解，则实数a的取值范围是：_________。 分析与解因为方程只有负数解，故，原方程可化为： ， ∴， 即 说明绝对值的意义有两点。其一，一个正数的绝对值是它本身，一个负数的绝对值是它的相反数，零的绝对值是零；其二，在数轴上表示一个点到原点的距离。利用绝对值的定义常可达到去掉绝对值符号的目的。 二、利用非负性 例2 方程的图象是（） （A）三条直线： （B）两条直线： （C）一点和一条直线：（0，0）， （D）两个点：（0，1），（－1，0）

分析与解由已知，根据非负数的性质，得 即或 解之得：或 故原方程的图象为两个点（0，1），（－1，0）。 说明利用非负数的性质，可以将绝对值符号去掉，从而将问题转化为其它的问题来解决。 三、公式法 例3 已知，求的值。 分析与解， ∴原式 说明本题根据公式，将原式化为含有的式子，再根据绝对值的定义求值。 四、分类讨论法 例4 实数a满足且，那么

分析与解由可得 且。 当时， ； 当时， 说明有的题目中，含绝对值的代数式不能直接确定其符号，这就要求分情况对字母涉及的可能取值进行讨论。 五、平方法 例5 设实数a、b满足不等式，则 （A）且 （B）且 （C）且 （D）且 分析与解由于a、b满足题设的不等式，则有 ，

整理得 ， 由此可知，从而 上式仅当时成立， ∴，即且， 选B。 说明运用此法是先对不等式进行平方去掉绝对值，然后求解。 六、图示法 例6 在式子中，由不同的x值代入，得到对应的值。在这些对应值中，最小的值是（） （A）1 （B）2 （C）3 （D）4 分析与解问题可变化为：在数轴上有四点A、B、C、D，其对应的值分别是－1、－2，－3、－4，求一点P，使最小（如图）。 由于是当P点在线段AD上取得最小值3，是当P在线段BC上取得最小值1，故的最小值是4。选D。 说明由于借助图形，巧妙地把问题在图形中表示出来，形象直观，便于思考，从而达到快捷解题之目的。

String、StringBuilder和StringBuffer的区别

2009-10-14 String、StringBuilder和S tringBuffer的区别 关键字: java String 字符串常量 StringBuffer 字符串变量（线程安全） StringBuilder 字符串变量（非线程安全） 简要的说，String 类型和StringBuffer 类型的主要性能区别其实在于String 是不可变的对象, 因此在每次对String 类型进行改变的时候其实都等同于生成了一个新的String 对象，然后将指针指向新的String 对象，所以经常改变内容的字符串最好不要用String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后，JVM 的GC 就会开始工作，那速度是一定会相当慢的。 而如果是使用StringBuffer 类则结果就不一样了，每次结果都会对StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下，String 对象的字符串拼接其实是被JVM 解释成了StringBuffer 对象的拼接，所以这些时候String 对象的速度并不会比StringBuffer 对象慢，而特别是以下的字符串对象生成中，String 效率是远要比StringBuffer 快的： String S1 = “This is only a” + “ simple” + “ test”; StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”); 你会很惊讶的发现，生成String S1 对象的速度简直太快了，而这个时候StringBuffer 居然速度上根本一点都不占优势。其实这是JVM 的一个把戏，在JVM 眼里，这个 String S1 = “This is only a” + “ simple” + “test”; 其实就是： String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String 对象的话，速度就没那么快了，譬如： String S2 = “This is only a”; String S3 = “ simple”; String S4 = “ test”; String S1 = S2 +S3 + S4; 这时候JVM 会规规矩矩的按照原来的方式去做 在大部分情况下StringBuffer > String StringBuffer https://www.wendangku.net/doc/583913805.html,ng.StringBuffer线程安全的可变字符序列。一个类似于String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。 可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。 StringBuffer 上的主要操作是append 和insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而insert 方法则在指定的点添加字符。 例如，如果z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用z.append("le") 会使字符串缓冲区包含“startle”，而z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。在大部分情况下StringBuilder > StringBuffer

StringBuffer之append方法

StringBuffer之append方法（转载）语言学习append 关于StringBuffer对象的append方法介绍，在Ivor Horton所著的《Java 2 入门经典（JDK 5)》（英文名：Beginning Java 2,JDK 5 Edition)中第4章数组和字符串讲解中，第4.4小节（向StringBuffer对象增加其他内容）介绍了用append()方法追加子串的功能。原文提供例子如下： StringBuffer buf=new StringBuffer("Hard "); String aString = "Waxworks"; buf.append(aString,3,4); 原文说明：这个操作将aString的从索引位置3开始的由四个字符组成的子串追加到StringBuffer对象buf中。然后buf对象就会包含字符串"Hard work"。 请注意，这个代码的实际运行结果是：buf对象包含的字符串为"Hard w"。 根据运行结果分析，StringBuffer对象的append（）方法的参数，如果是String类型，那么，后面取子串的操作实际是从索引3开始，取值到索引4之前的串。如果append的语句改成buf.append(aString,3,3); ,那么没有添加aString的子串，即buf包含的字符实际还是"Hard "。如果此语句再改成buf.append(aString3,2); ，那么系统会抛出"IndexOutOfBoundsException"的异常！ 但是，如果append()的参数是字符数组（char[])，那么结果就如原文所述，buf将包含串"Hard work". 代码如下： StringBuffer buf=new StringBuffer("Hard "); char[] text ={'W','a','x','w','o','r','k','s'}; buf.append(text ,3,4); // buf包含串"Hard work" ================================================================== ====================================================================== ====================================================================== = String一旦赋值或实例化后就不可更改，如果赋予新值将会重新开辟内存地址进行存储。 而StringBuffer类使用append和insert等方法改变字符串值时只是在原有对象存储的内存地址上进行连续操作，减少了资源的开销。 因此我们得出结论：当需要进行频繁修改字符串的操作时先建立StringBuffer类对象进行操作，将最后结果转化成String类对象返回，这样效率会高很多。

String和StringBuffer的一些用法

String和StringBuffer的一些用法 先看一个例子~~~~ public class Untitled1 { public Untitled1() { } public static void main(String[] args) { Untitled1 untitled11 = new Untitled1(); String s1="STRING类的值是不是会变的->"; String s2=s1; System.out.println(s2); s1+="加个试试"; //String 赋值实际上这个是NEW了一个新的对象了，S1变了 System.out.println(s2); //S2没有变，这是因为S2指向的地址还是最早的s1所在的地址 StringBuffer b1=new StringBuffer("StringBuffer类的值是会变的->"); StringBuffer b2=b1; b2.append("加个试试");//StringBuffer赋值,操作b2还是那个对象， System.out.println(b1);//所以加一个字符进去b1指向的对象的值已经变了哦 } } 结果： STRING类的值是不是会变的-> STRING类的值是不是会变的-> StringBuffer类的值是会变的->加个试试 摘录： CSDN: 这里的"可变"和"不可变",和是不是final没有关系 举个例子: String str1 = "hello"; String str2 = "world"; String str1 = str1 + str2;//这里所做的内部操作,其实不是把str1的内容改变为原str1+str2的内容这么简单, 而把创建一个新的String, 内容为str1 + str2的内容,然后再把str1这个引用重新指向新创建的String, 这就是上面说的String不可变.

绝对值大全(零点分段法、化简、最值)..

绝对值大全（零点分段法、化简、最值） 一、去绝对值符号的几种常用方法 解含绝对值不等式的基本思路是去掉绝对值符号，使不等式变为不含绝对值符号的一般不等式，而后，其解法与一般不等式的解法相同。因此掌握去掉绝对值符号的方法和途径是解题关键。 1利用定义法去掉绝对值符号 根据实数含绝对值的意义，即|x |=(0)(0)x x x x ≥?? -????≤?； |x |>c (0) 0(0)(0)x c x c c x c x R c <->>?? ?≠=??∈c (c >0)来解，如|ax b +|>c (c >0)可为ax b +>c 或 ax b +<－c ；|ax b +|