001         package com.croftsoft.core.lang;
002    
003         import java.io.*;
004         import java.util.*;
005    
006         /*********************************************************************
007         * A collection of static methods to manipulate java.lang.String.
008         * 
009         * @version
010         *   2001-08-15
011         * @since
012         *   1998-10-04
013         * @author
014         *   <a href="http://croftsoft.com/">David Wallace Croft</a>
015         *********************************************************************/
016    
017         public class  StringLib
018         //////////////////////////////////////////////////////////////////////
019         //////////////////////////////////////////////////////////////////////
020         {
021    
022         public static final String [ ]  ZERO_LENGTH_STRING_ARRAY
023           = new String [ ] { };
024    
025         //////////////////////////////////////////////////////////////////////
026         //////////////////////////////////////////////////////////////////////
027    
028         public static void  main ( String [ ]  args )
029         //////////////////////////////////////////////////////////////////////
030         {
031           System.out.println ( replace ( "0", "0", "12345" ) );
032           System.out.println ( replace ( "1abc5", "abc", "234" ) );
033           System.out.println ( replace ( "1a", "a", "2345" ) );
034           System.out.println ( replace ( "1235", "23", "234" ) );
035         }
036    
037         /*********************************************************************
038         * @see #padRight
039         *********************************************************************/
040         public static String  padLeft ( String  s, char  c, int  length )
041         //////////////////////////////////////////////////////////////////////
042         {
043           if ( s == null ) return null;
044           if ( s.length ( ) >= length ) return new String ( s );
045           while ( s.length ( ) < length ) s = c + s;
046           return s;
047         }
048    
049         /*********************************************************************
050         * @see #padLeft
051         *********************************************************************/
052         public static String  padRight ( String  s, char  c, int  length )
053         //////////////////////////////////////////////////////////////////////
054         {
055           if ( s == null ) return null;
056           if ( s.length ( ) >= length ) return new String ( s );
057           while ( s.length ( ) < length ) s = s + c;
058           return s;
059         }
060    
061         /*********************************************************************
062         * Returns a String with the characters between
063         * <I>fromIndex</I> and <I>toIndex</I> removed, inclusive.
064         *********************************************************************/
065         public static String  remove (
066           String  s, int  fromIndex, int  toIndex )
067         //////////////////////////////////////////////////////////////////////
068         {
069           return s.substring ( 0, fromIndex ) + s.substring ( toIndex + 1 );
070         }
071    
072         /*********************************************************************
073         * Replaces substrings in a String.
074         * Replaces every instance of <I>oldSub</I> in <I>s</I> with
075         *   <I>newSub</I>.
076         *********************************************************************/
077         public static String  replace (
078           String  s, String  oldSub, String  newSub )
079         //////////////////////////////////////////////////////////////////////
080         // When Java 1.2 comes out, use StringBuffer.replace().
081         //////////////////////////////////////////////////////////////////////
082         {
083           StringBuffer  sb = new StringBuffer ( );
084           int  index;
085           int  remnantIndex = 0;
086           while ( ( index = s.indexOf ( oldSub, remnantIndex ) ) > -1 )
087           {
088             if ( index > remnantIndex )
089             {
090               sb.append ( s.substring ( remnantIndex, index ) );
091             }
092             sb.append ( newSub );
093             remnantIndex = index + oldSub.length ( );
094           }
095           sb.append ( s.substring ( remnantIndex ) );
096           return sb.toString ( );
097         }
098    
099         /*********************************************************************
100         * Breaks a String at the ends of lines.
101         * The original text is broken into an array of String at the
102         * end-of-line delimiters such as carriage return, linefeed, or the
103         * carriage return/linefeed pair.
104         * This is returned as an array of String without the delimiters.
105         *********************************************************************/
106         public static String [ ]  toStringArray ( String  text )
107         //////////////////////////////////////////////////////////////////////
108         {
109           Vector  stringVector = new Vector ( );
110    
111           BufferedReader  bufferedReader
112             = new BufferedReader ( new StringReader ( text ) );
113    
114           String  line;
115    
116           try
117           {
118             while ( ( line = bufferedReader.readLine ( ) ) != null )
119             {
120               stringVector.addElement ( line );
121             }
122           }
123           catch ( IOException  ex )
124           {
125             // this should never happen
126           }
127    
128           String [ ]  stringArray = new String [ stringVector.size ( ) ];
129    
130           stringVector.copyInto ( stringArray );
131    
132           return stringArray;
133         }
134    
135         /*********************************************************************
136         * Returns null if the trimming operation results in the empty String.
137         *
138         * @param  s
139         *
140         *   May be null.
141         *
142         * @return
143         *
144         *   Returns the argument trimmed or null if the argument is null
145         *   or the argument trimmed is "".
146         *********************************************************************/
147         public static String  trimToNull ( String  s )
148         //////////////////////////////////////////////////////////////////////
149         {
150           if ( s == null )
151           {
152             return null;
153           }
154    
155           s = s.trim ( );
156    
157           return "".equals ( s ) ? null : s;
158         }
159    
160         //////////////////////////////////////////////////////////////////////
161         //////////////////////////////////////////////////////////////////////
162    
163         private  StringLib ( ) { }
164    
165         //////////////////////////////////////////////////////////////////////
166         //////////////////////////////////////////////////////////////////////
167         }