|
|
| Line 1: |
Line 1: |
| {{about|the data type|other uses|String (disambiguation)}}
| | I'm Roosevelt (28) from Hollnich, Germany. <br>I'm learning Bengali literature at a local university and I'm just about to graduate.<br>I have a part time job in a college.<br><br>my web-site; [http://fioletowy.tubix.pl/zyczeniomania-info-62922.html zabawne życzenia noworoczne] |
| {{one source|date=January 2010}}
| |
| | |
| In [[computer programming]], a '''string''' is traditionally a [[sequence]] of [[Character (computing)|characters]], either as a [[literal (computer programming)|literal constant]] or as some kind of variable. The latter may allow its elements to be mutated and/or the length changed, or it may be fixed (after creation). A string is generally understood as a [[data type]] and is often implemented as an [[array data structure|array]] of [[byte]]s (or [[word (computer architecture)|word]]s) that stores a sequence of elements, typically characters, using some [[character encoding]]. A string may also denote more general [[array (data type)|array]]s or other sequence (or [[List (abstract data type)|list]]) data types and structures.
| |
| | |
| Depending on programming language and precise data type used, a [[variable (programming)|variable]] declared to be a string may either cause storage in memory to be statically allocated for a predetermined maximum length or employ dynamic allocation to allow it to hold variable number of elements.
| |
| | |
| When a string appears literally in [[source code]], it is known as a [[string literal]] and has a representation that denotes it as such.
| |
| | |
| In [[formal language]]s, which are used in [[mathematical logic]] and [[theoretical computer science]], a string is a finite sequence of [[symbol (formal)|symbol]]s that are chosen from a [[set (mathematics)|set]] called an [[alphabet (computer science)|alphabet]].
| |
| | |
| == Formal theory ==
| |
| {{See also|Tuple}}
| |
| | |
| Let Σ be a [[empty set|non-empty]] [[finite set]] of symbols (alternatively called characters), called the ''alphabet''. No assumption is made about the nature of the symbols. A '''string''' (or '''word''') over Σ is any finite [[sequence]] of symbols from Σ.<ref name="partee">{{cite book |author1=Barbara H. Partee |author2=Alice ter Meulen |author3=Robert E. Wall |title=Mathematical Methods in Linguistics |publisher=Kluwer |year=1990}}</ref> For example, if Σ = {0, 1}, then ''01011'' is a string over Σ.
| |
| | |
| The ''[[length]]'' of a string is the number of symbols in the string (the length of the sequence) and can be any [[non-negative integer]]. The ''[[empty string]]'' is the unique string over Σ of length 0, and is denoted ''ε'' or ''λ''.<ref name="partee"/>
| |
| | |
| The set of all strings over Σ of length ''n'' is denoted Σ<sup>''n''</sup>. For example, if Σ = {0, 1}, then Σ<sup>2</sup> = {00, 01, 10, 11}. Note that Σ<sup>0</sup> = {ε} for any alphabet Σ.
| |
| | |
| The set of all strings over Σ of any length is the [[Kleene star|Kleene closure]] of Σ and is denoted Σ*. In terms of Σ<sup>''n''</sup>,
| |
| :<math>\Sigma^{*} = \bigcup_{n \in \N} \Sigma^{n}</math>
| |
| For example, if Σ = {0, 1}, Σ* = {ε, 0, 1, 00, 01, 10, 11, 000, 001, 010, 011, ...}. Although Σ* itself is [[countably infinite]], all elements of Σ* have finite length.
| |
| | |
| A set of strings over Σ (i.e. any [[subset]] of Σ*) is called a ''formal language'' over Σ. For example, if Σ = {0, 1}, the set of strings with an even number of zeros ({ε, 1, 00, 11, 001, 010, 100, 111, 0000, 0011, 0101, 0110, 1001, 1010, 1100, 1111, ...}) is a formal language over Σ.
| |
| | |
| === Concatenation and substrings ===
| |
| ''[[Concatenation]]'' is an important [[binary operation]] on Σ*. For any two strings ''s'' and ''t'' in Σ*, their concatenation is defined as the sequence of symbols in ''s'' followed by the sequence of characters in ''t'', and is denoted ''st''. For example, if Σ = {a, b, ..., z}, ''s'' = <tt>bear</tt>, and ''t'' = <tt>hug</tt>, then ''st'' = <tt>bearhug</tt> and ''ts'' = <tt>hugbear</tt>.
| |
| | |
| String concatenation is an [[associative]], but non-[[commutative]] operation. The empty string serves as the [[identity element]]; for any string ''s'', ε''s'' = ''s''ε = ''s''. Therefore, the set Σ* and the concatenation operation form a [[monoid]], the [[free monoid]] generated by Σ. In addition, the length function defines a [[monoid homomorphism]] from Σ* to the non-negative integers (that is, a function <math>L: \Sigma^{*} \mapsto \mathbb{N}_0</math>, such that <math>L(st)=L(s)+L(t)\quad \forall s,t\in\Sigma^*</math>).
| |
| | |
| A string ''s'' is said to be a ''[[substring]]'' or ''factor'' of ''t'' if there exist (possibly empty) strings ''u'' and ''v'' such that ''t'' = ''usv''. The [[binary relation|relation]] "is a substring of" defines a [[partial order]] on Σ*, the [[least element]] of which is the empty string.
| |
| | |
| === Prefixes and suffixes ===
| |
| A string ''s'' is said to be a [[Substring#Prefix|prefix]] of ''t'' if there exists a string ''u'' such that ''t'' = ''su''. If ''u'' is nonempty, ''s'' is said to be a ''proper'' prefix of ''t''. Symmetrically, a string ''s'' is said to be a [[Substring#Suffix|suffix]] of ''t'' if there exists a string ''u'' such that ''t'' = ''us''. If ''u'' is nonempty, ''s'' is said to be a ''proper'' suffix of ''t''. Suffixes and prefixes are substrings of ''t''.
| |
| | |
| === Rotations ===
| |
| A string ''s'' = ''uv'' is said to be a rotation of ''t'' if ''t'' = ''vu''. For example, if Σ = {0, 1} the string 0011001 is a rotation of 0100110, where u = 00110 and v = 01.
| |
| | |
| === Reversal ===
| |
| The reverse of a string is a string with the same symbols but in reverse order. For example, if ''s'' = abc (where a, b, and c are symbols of the alphabet), then the reverse of ''s'' is cba. A string that is the reverse of itself (e.g., ''s'' = madam) is called a [[palindrome]], which also includes the empty string and all strings of length 1.
| |
| | |
| === Lexicographical ordering ===
| |
| It is often useful to define an [[order theory|ordering]] on a set of strings. If the alphabet Σ has a [[total order]] (cf. [[alphabetical order]]) one can define a total order on Σ* called [[lexicographical order]]. For example, if Σ = {0, 1} and 0 < 1, then the lexicographical order on Σ* includes the relationships ε < 0 < 00 < 000 < ... < 0001 < 001 < 01 < 010 < 011 < 0110 < 01111 < 1 < 10 < 100 < 101 < 111 < 1111 < 11111 ...
| |
| | |
| === String operations ===
| |
| A number of additional operations on strings commonly occur in the formal theory. These are given in the article on [[string operations]].
| |
| | |
| === Topology ===
| |
| Strings admit the following interpretation as nodes on a graph:
| |
| | |
| * Fixed-length strings can be viewed as nodes on a [[hypercube]]
| |
| * Variable-length strings (of finite length) can be viewed as nodes on the [[k-ary tree|''k''-ary tree]], where ''k'' is the number of symbols in Σ
| |
| * Infinite strings can be viewed as infinite paths on the ''[[K-ary tree|k]]''[[K-ary tree|-ary tree]].
| |
| | |
| The natural topology on the set of fixed-length strings or variable length strings is the discrete topology, but the natural topology on the set of infinite strings is the [[limit topology]], viewing the set of infinite strings as the [[inverse limit]] of the sets of finite strings. This is the construction used for the [[p-adic|''p''-adic numbers]] and some constructions of the [[Cantor set]], and yields the same topology.
| |
| | |
| [[Isomorphism]]s between string representations of topologies can be found by normalizing according to the [[lexicographically minimal string rotation]].
| |
| | |
| == String datatypes ==
| |
| {{See also|Comparison of programming languages (string functions)}}
| |
| | |
| A '''string datatype''' is a datatype modeled on the idea of a formal string. Strings are such an important and useful datatype that they are implemented in nearly every [[programming language]]. In some languages they are available as [[primitive type]]s and in others as [[composite type]]s. The [[syntax]] of most high-level programming languages allows for a string, usually quoted in some way, to represent an instance of a string datatype; such a meta-string is called a ''literal'' or ''string literal''.
| |
| | |
| === String length ===
| |
| Although formal strings can have an arbitrary (but finite) length, the length of strings in real languages is often constrained to an artificial maximum. In general, there are two types of string datatypes: ''fixed-length strings'', which have a fixed maximum length and which use the same amount of memory whether this maximum is reached or not, and ''variable-length strings'', whose length is not arbitrarily fixed and which use varying amounts of memory depending on their actual size. Most strings in modern [[programming languages]] are variable-length strings. Despite the name, even variable-length strings are limited in length, although, in general, the limit depends only on the amount of [[computer memory|memory]] available. The string length can be stored as a separate integer (which puts a theoretical limit on the length) or implicitly through a termination character, usually a character value with all bits zero. See also "Null-terminated" below.
| |
| | |
| === Character encoding ===
| |
| String datatypes have historically allocated one byte per character, and, although the exact character set varied by region, character encodings were similar enough that programmers could often get away with ignoring this, since characters a program treated specially (such as period and space and comma) were in the same place in all the encodings a program would encounter. These character sets were typically based on [[ASCII]] or [[EBCDIC]].
| |
| | |
| [[Logograph]]ic languages such as [[Chinese language|Chinese]], [[Japanese language|Japanese]], and [[Korean language|Korean]] (known collectively as [[CJK]]) need far more than 256 characters (the limit of a one 8-bit byte per-character encoding) for reasonable representation. The normal solutions involved keeping single-byte representations for ASCII and using two-byte representations for CJK [[ideographs]]. Use of these with existing code led to problems with matching and cutting of strings, the severity of which depended on how the character encoding was designed. Some encodings such as the [[Extended Unix Code|EUC]] family guarantee that a byte value in the ASCII range will represent only that ASCII character, making the encoding safe for systems that use those characters as field separators. Other encodings such as [[ISO-2022]] and [[Shift-JIS]] do not make such guarantees, making matching on byte codes unsafe. These encodings also were not "self-synchronizing", so that locating character boundaries required backing up to the start of a string, and pasting two strings together could result in corruption of the second string (these problems were much less with EUC as any ASCII character did synchronize the encoding).
| |
| | |
| [[Unicode]] has simplified the picture somewhat. Most programming languages now have a datatype for Unicode strings. Unicode's preferred byte stream format [[UTF-8]] is designed not to have the problems described above for older multibyte encodings. All UTF-8, UTF-16 and [[UTF-32]] require the programmer to know that the fixed-size code units are different than the "characters", the main difficulty currently is incorrectly designed API's that attempt to hide this difference.
| |
| | |
| === Implementations ===
| |
| Some languages like [[C++]] implement strings as [[generic programming|templates]] that can be used with any datatype, but this is the exception, not the rule.
| |
| | |
| Some languages, such as C++ and [[Ruby (programming language)|Ruby]], normally allow the contents of a string to be changed after it has been created; these are termed ''mutable'' strings. In other languages, such as [[Java (programming language)|Java]] and [[Python (programming language)|Python]], the value is fixed and a new string must be created if any alteration is to be made; these are termed ''immutable'' strings.
| |
| | |
| Strings are typically implemented as [[Array data type|arrays]] of bytes, characters, or code units, in order to allow fast access to individual units or substrings—including characters when they have a fixed length. A few languages such as [[Haskell (programming language)|Haskell]] implement them as [[linked list]]s instead.
| |
| | |
| Some languages, such as [[Prolog]] and [[Erlang (programming language)|Erlang]], avoid implementing a dedicated string datatype at all, instead adopting the convention of representing strings as lists of character codes.
| |
| | |
| === Representations ===
| |
| Representations of strings depend heavily on the choice of character repertoire and the method of character encoding. Older string implementations were designed to work with repertoire and encoding defined by ASCII, or more recent extensions like the [[ISO 8859]] series. Modern implementations often use the extensive repertoire defined by Unicode along with a variety of complex encodings such as UTF-8 and UTF-16.
| |
| | |
| The term ''bytestring'' usually indicates a general-purpose string of bytes, rather than strings of only (readable) characters, strings of bits, or such. Byte strings often imply that bytes can take any value and any data can be stored as-is, meaning that there should be no value interpreted as a termination value.
| |
| | |
| Most string implementations are very similar to variable-length [[Array data type|array]]s with the entries storing the [[character code]]s of corresponding characters. The principal difference is that, with certain encodings, a single logical character may take up more than one entry in the array. This happens for example with UTF-8, where single codes ([[Universal Character Set|UCS]] code points) can take anywhere from one to four bytes, and single characters can take an arbitrary number of codes. In these cases, the logical length of the string (number of characters) differs from the logical length of the array (number of bytes in use). [[UTF-32]] is the only Unicode encoding that avoids this problem.
| |
| | |
| ==== Null-terminated ====
| |
| {{main|Null-terminated string}}
| |
| | |
| The length of a string can be stored implicitly by using a special terminating character; often this is the [[null character]] (NUL), which has all bits zero, a convention used and perpetuated by the popular [[C (programming language)|C programming language]].<ref>
| |
| {{Citation
| |
| | last = Bryant
| |
| | first = Randal E.
| |
| | author-link = Randal Bryant
| |
| | last2 = David
| |
| | first2 = O'Hallaron
| |
| | title = Computer Systems: A Programmer's Perspective
| |
| | place = Upper Saddle River, NJ
| |
| | publisher = Pearson Education
| |
| | year = 2003
| |
| | edition = 2003
| |
| | url = http://csapp.cs.cmu.edu/
| |
| | isbn = 0-13-034074-X
| |
| | page = 40}}
| |
| </ref> Hence, this representation is commonly referred to as C string. | |
| | |
| In terminated strings, the terminating code is not an allowable character in any string. Strings with ''length'' field do not have this limitation and can also store arbitrary [[binary data]]. In C two things are needed to handle binary data, a character pointer and the length of the data.
| |
| | |
| An example of a ''null-terminated string'' stored in a 10-byte [[Buffer (computer science)|buffer]], along with its [[ASCII]] (or more modern [[UTF-8]]) representation as 8-bit [[hexadecimal number]]s is:
| |
| | |
| {| class="wikitable" style="margin-left: auto; margin-right:auto"
| |
| |-
| |
| | <code>F</code> || <code>R</code> || <code>A</code> || <code>N</code> || <code>K</code>
| |
| | <small>NUL</small>
| |
| | style="background: #DDD" | <code style="background: #DDD">k</code>
| |
| | style="background: #DDD" | <code style="background: #DDD">e</code>
| |
| | style="background: #DDD" | <code style="background: #DDD">f</code>
| |
| | style="background: #DDD" | <code style="background: #DDD">w</code>
| |
| |-
| |
| | 46<sub>16</sub> || 52<sub>16</sub> || 41<sub>16</sub> || 4E<sub>16</sub> || 4B<sub>16</sub>
| |
| | 00<sub>16</sub>
| |
| | style="background: #DDD" | 6B<sub>16</sub>
| |
| | style="background: #DDD" | 65<sub>16</sub>
| |
| | style="background: #DDD" | 66<sub>16</sub>
| |
| | style="background: #DDD" | 77<sub>16</sub>
| |
| |}
| |
| | |
| The length of the string in the above example, "<code>FRANK</code>", is 5 characters, but it occupies 6 bytes. Characters after the terminator do not form part of the representation; they may be either part of another string or just garbage. (Strings of this form are sometimes called ''ASCIZ strings'', after the original [[assembly language]] directive used to declare them.)
| |
| | |
| ==== Length-prefixed ====
| |
| The length of a string can also be stored explicitly, for example by prefixing the string with the length as a byte value (a convention used in many [[Pascal (programming language)|Pascal]] dialects): as a consequence, some people call it a P-string. Storing the string length as byte limits the maximum string length to 255. To avoid such limitations, improved implementations of P-strings use [[16-bit|16-]], [[32-bit|32-]], or [[64-bit]] [[Word (data type)|words]] to store the string length. When the ''length'' field covers the [[address space]], strings are limited only by the [[Dynamic memory allocation|available memory]].
| |
| | |
| Here is the equivalent '''Pascal string''' stored in a 10-byte buffer, along with its ASCII / UTF-8 representation:
| |
| | |
| {| class="wikitable" style="margin-left: auto; margin-right:auto"
| |
| |-
| |
| | <small>length</small>
| |
| | <code>F</code> || <code>R</code> || <code>A</code> || <code>N</code> || <code>K</code>
| |
| | style="background: #DDD" | <code style="background: #DDD">k</code>
| |
| | style="background: #DDD" | <code style="background: #DDD">e</code>
| |
| | style="background: #DDD" | <code style="background: #DDD">f</code>
| |
| | style="background: #DDD" | <code style="background: #DDD">w</code>
| |
| |-
| |
| | 5<sub>16</sub>
| |
| | 46<sub>16</sub> || 52<sub>16</sub> || 41<sub>16</sub> || 4E<sub>16</sub> || 4B<sub>16</sub>
| |
| | style="background: #DDD" | 6B<sub>16</sub>
| |
| | style="background: #DDD" | 65<sub>16</sub>
| |
| | style="background: #DDD" | 66<sub>16</sub>
| |
| | style="background: #DDD" | 77<sub>16</sub>
| |
| |}
| |
| | |
| ==== Strings as records ====
| |
| Many languages, including object-oriented ones, implement strings as [[record (computer science)|record]]s in a structure like:
| |
| | |
| <source lang="cpp">
| |
| | |
| class string {
| |
| int length;
| |
| char *text;
| |
| };
| |
| </source>
| |
| | |
| Although this implementation is hidden, and accessed through member functions. The "text" will be a dynamically allocated memory area, that might be expanded if needed. See also [[string (C++)]].
| |
| | |
| ==== Linked-list ====
| |
| Both character termination and length codes limit strings: For example, C character arrays that contain null (NUL) characters cannot be handled directly by C string library functions: Strings using a length code are limited to the maximum value of the length code.
| |
| | |
| Both of these limitations can be overcome by clever programming, of course, but such workarounds are by definition not standard.
| |
| | |
| Rough equivalents of the C termination method have historically appeared in both hardware and software. For example, "data processing" machines like the [[IBM 1401]] used a special word mark bit to delimit strings at the left, where the operation would start at the right. This meant that, while the IBM 1401 had a seven-bit word in "reality", almost no-one ever thought to use this as a feature, and override the assignment of the seventh bit to (for example) handle ASCII codes.
| |
| | |
| It is possible to create data structures and functions that manipulate them that do not have the problems associated with character termination and can in principle overcome length code bounds. It is also possible to optimize the string represented using techniques from [[Run-length encoding|run length encoding]] (replacing repeated characters by the character value and a length) and [[Hamming coding|Hamming encoding]].
| |
| | |
| While these representations are common, others are possible. Using [[rope (computer science)|rope]]s makes certain string operations, such as insertions, deletions, and concatenations more efficient.
| |
| | |
| === Security concerns ===
| |
| The differing memory layout and storage requirements of strings can affect the security of the program accessing the string data. String representations requiring a terminating character are commonly susceptible to [[buffer overflow]] problems if the terminating character is not present, caused by a coding error or an [[hacker (computer security)|attacker]] deliberately altering the data. String representations adopting a separate length field are also susceptible if the length can be manipulated. In such cases, program code accessing the string data requires [[bounds checking]] to ensure that it does not inadvertently access or change data outside of the string memory limits.
| |
| | |
| String data is frequently obtained from user-input to a program. As such, it is the responsibility of the program to validate the string to ensure that it represents the expected format. Performing limited or no validation of user-input can cause a program to be vulnerable to [[code injection]] attacks.
| |
| | |
| == Text file strings ==
| |
| In computer readable text files, for example programming language source files or configuration files, strings can be represented. The NUL byte is normally not used as terminator since that does not correspond to the ASCII text standard, and the length is usually not stored, since the file should be human editable without bugs.
| |
| | |
| Two common representations are:
| |
| | |
| * Surrounded by [[quotation mark]]s (ASCII 22<sub>16</sub>), used by most programming languages. To be able to include quotation marks, newline characters etc., [[Escape character|escape sequence]]s are often available, usually using the [[backslash]] character (ASCII 5C<sub>16</sub>).
| |
| * Terminated by a [[newline]] sequence, for example in Windows [[INI file]]s.
| |
| | |
| {{See also|String literal}}
| |
| | |
| == Non-text strings ==
| |
| While character strings are very common uses of strings, a string in computer science may refer generically to any sequence of homogeneously typed data. A string of [[bit]]s or bytes, for example, may be used to represent non-textual [[binary data]] retrieved from a communications medium. This data may or may not be represented by a string-specific datatype, depending on the needs of the application, the desire of the programmer, and the capabilities of the programming language being used. If the programming language's string implementation is not [[8-bit clean]], data corruption may ensue.
| |
| | |
| == String processing algorithms ==
| |
| There are many [[algorithm]]s for processing strings, each with various trade-offs. Some categories of algorithms include:
| |
| | |
| * [[String searching algorithm]]s for finding a given substring or pattern
| |
| * [[String manipulation algorithm]]s
| |
| * [[Sorting algorithm]]s
| |
| * [[Regular expression]] algorithms
| |
| * [[Parser|Parsing]] a string
| |
| * [[Sequence mining]]
| |
| | |
| Advanced string algorithms often employ complex mechanisms and data structures, among them [[suffix tree]]s and [[finite state machine]]s.
| |
| | |
| == Character string-oriented languages and utilities ==
| |
| Character strings are such a useful datatype that several languages have been designed in order to make string processing applications easy to write. Examples include the following languages:
| |
| * [[AWK (programming language)|awk]]
| |
| * [[Icon (programming language)|Icon]]
| |
| * [[MUMPS]]
| |
| * [[Perl]]
| |
| * [[Rexx]]
| |
| * [[Ruby (programming language)|Ruby]]
| |
| * [[sed]]
| |
| * [[SNOBOL]]
| |
| * [[Tcl]]
| |
| * [[TTM (programming language)|TTM]]
| |
| | |
| Many [[Unix]] utilities perform simple string manipulations and can be used to easily program some powerful string processing algorithms. Files and finite streams may be viewed as strings.
| |
| | |
| Some [[application programming interface|API]]s like [[Multimedia Control Interface]], [[embedded SQL]] or [[printf]] use strings to hold commands that will be interpreted.
| |
| | |
| Recent [[scripting programming language]]s, including Perl, [[Python (programming language)|Python]], Ruby, and Tcl employ [[regular expression]]s to facilitate text operations.
| |
| | |
| Some languages such as Perl and Ruby support [[string interpolation]], which permits arbitrary expressions to be evaluated and included in string literals.
| |
| | |
| == Character string functions ==
| |
| {{See also|Comparison of programming languages (string functions)}}
| |
| | |
| [[String function]]s are used to manipulate a string or change or edit the contents of a string. They also are used to query information about a string. They are usually used within the context of a [[programming language|computer programming language]].
| |
| | |
| The most basic example of a string function is the <code>length(string)</code> function, which returns the length of a string (not counting any terminator characters or any of the string's internal structural information) and does not modify the string. For example, <code>length("hello world")</code> returns 11.
| |
| | |
| There are many string functions that exist in other languages with similar or exactly the same syntax or parameters. For example, in many languages, the length function is usually represented as <code>len(string)</code>. Even though string functions are very useful to a computer programmer, a computer programmer using these functions should be mindful that a string function in one language could in another language behave differently or have a similar or completely different function name, parameters, syntax, and results.
| |
| | |
| ==String buffers==<!-- Anchor for redirect [String buffers]; please don't change. -->
| |
| In some [[programming language]]s, a ''String Buffer'' is an alternative to a String. It has the ability to be altered through adding or appending, whereas a String is normally fixed or [[Immutable object|immutable]].
| |
| | |
| === In Java ===
| |
| ==== Theory ====
| |
| [[Java (Sun)|Java]]'s standard way to handle text is to use its <code>{{Javadoc:SE|java/lang|String}}</code> [[Class (computer science)|class]]. Any given <code>String</code> in Java is an [[immutable object]], which means its [[State (computer science)|state]] cannot be changed. A <code>String</code> has an [[Array data type|array]] of [[Character (computing)|characters]]. Whenever a <code>String</code> must be manipulated, any changes require the creation of a new <code>String</code> (which, in turn, involves the creation of a new array of characters, and copying of the original array). This happens even if the original <code>String</code>'s value or intermediate <code>String</code>s used for the manipulation are not kept.
| |
| | |
| Java provides an alternate class for string manipulation, called a <code>'''[http://java.sun.com/j2se/1.5.0/docs/api/java/lang/StringBuffer.html StringBuffer]'''</code>. A <code>StringBuffer</code>, like a <code>String</code>, has an array to hold characters. It, however, is mutable (its state can be altered). Its array of characters is not necessarily completely filled (as oppose to a String, whose array is always the exact required length for its contents). Thus, it has the capability to add, remove, or change its state without creating a new object (and without the creation of a new array, and array copying). The exception to this is when its array is no longer of suitable length to hold its content. In this case, it is required to create a new array, and copy contents.
| |
| | |
| For these reasons, Java would handle an expression like
| |
| <source lang="java">
| |
| String newString = aString + anInt + aChar + aDouble;
| |
| </source>
| |
| like this:
| |
| <source lang="java">
| |
| String newString = (new StringBuffer(aString)).append(anInt).append(aChar).append(aDouble).toString();
| |
| </source>
| |
| | |
| ==== Implications ====
| |
| Generally, a <code>StringBuffer</code> is more [[analysis of algorithms|efficient]] than a String in string handling. However, this is not necessarily the case, since a StringBuffer will be required to recreate its character array when it runs out of space. Theoretically, this is possible to happen the same number of times as a new String would be required, although this is unlikely (and the programmer can provide length hints to prevent this). Either way, the effect is not noticeable in modern desktop computers.
| |
| | |
| As well, the shortcomings of arrays are inherent in a <code>StringBuffer</code>. In order to insert or remove characters at arbitrary positions, whole sections of arrays must be moved.
| |
| | |
| The method by which a <code>StringBuffer</code> is attractive in an environment with low processing power takes this ability by using too much memory, which is likely also at a premium in this environment. This point, however, is trivial, considering the space required for creating many instances of Strings in order to process them. As well, the StringBuffer can be optimized to "waste" as little memory as possible.
| |
| | |
| The '''{{Javadoc:SE|java/lang|StringBuilder}}''' class, introduced in [[Java Platform, Standard Edition|J2SE]] 5.0, differs from <code>StringBuffer</code> in that it is [[Synchronization (computer science)|unsynchronized]]. When only a single [[Thread (computer science)|thread]] at a time will access the object, using a <code>StringBuilder</code> processes more efficiently than using a <code>StringBuffer</code>.
| |
| | |
| <code>StringBuffer</code> and <code>StringBuilder</code> are included in the {{Javadoc:SE|package=java.lang|java/lang}} package.
| |
| | |
| === In .NET ===
| |
| Microsoft's [[.NET Framework]] has a <code>StringBuilder</code> class in its [[Base Class Library]].
| |
| | |
| === In other languages ===
| |
| * In [[C++]] and [[Ruby (programming language)|Ruby]], the standard string class is already mutable, with the ability to change the contents and append strings, etc., so a separate mutable string class is unnecessary.
| |
| * In [[Objective-C]] ([[Cocoa (API)|Cocoa]]/[[OpenStep]] frameworks), the <code>NSMutableString</code> class is the mutable version of the <code>NSString</code> class.
| |
| | |
| == See also ==
| |
| * [[Stringology]]
| |
| * [[Connection string]]
| |
| * [[Rope (computer science)|Rope]]
| |
| * [[Bitstring]]
| |
| * [[Binary-safe]]
| |
| * [[Improper input validation]]
| |
| * [[Incompressible string]]
| |
| * [[Empty string]]
| |
| * [[String metric]]
| |
| * [[string (C++)]]
| |
| * [[string.h]]
| |
| * [[Analysis of algorithms]]
| |
| | |
| == References ==
| |
| {{reflist}}
| |
| | |
| ==External links==
| |
| * The JavaDocs of <code>[http://java.sun.com/j2se/1.5.0/docs/api/java/lang/StringBuffer.html StringBuffer]</code>, <code>[http://java.sun.com/j2se/1.5.0/docs/api/java/lang/StringBuilder.html StringBuilder]</code> and <code>[http://java.sun.com/j2se/1.5.0/docs/api/java/lang/String.html String]</code>.
| |
| * [http://www-128.ibm.com/developerworks/java/library/j-jtp04223.html?ca=dgr-lnxw01JavaUrbanLegends Urban Performance Legends] - An article which involves a discussion of immutable objects with respect to [[object-oriented design]]
| |
| | |
| {{Data types}}
| |
| | |
| [[Category:Character encoding]]
| |
| [[Category:Data types]]
| |
| [[Category:Formal languages]]
| |
| [[Category:Combinatorics on words]]
| |
| [[Category:Primitive types]]
| |
| [[Category:Syntactic entities]]
| |
| [[Category:String (computer science)| ]]
| |