Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  //
  //  ========================================================================
  //  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
  //  ------------------------------------------------------------------------
  //  All rights reserved. This program and the accompanying materials
  //  are made available under the terms of the Eclipse Public License v1.0
  //  and Apache License v2.0 which accompanies this distribution.
  //
  //      The Eclipse Public License is available at
 //      http://www.eclipse.org/legal/epl-v10.html
 //
 //      The Apache License v2.0 is available at
 //      http://www.opensource.org/licenses/apache2.0.php
 //
 //  You may elect to redistribute this code under either of these licenses.
 //  ========================================================================
 //
 
 package org.eclipse.jetty.util;
 
 
Fast String Utilities. These string utilities provide both conveniance methods and performance improvements over most standard library versions. The main aim of the optimizations is to avoid object creation unless absolutely required.
 
 public class StringUtil
 {
     private static final Logger LOG = Log.getLogger(StringUtil.class);
     
     public static final String ALL_INTERFACES="0.0.0.0";
     public static final String CRLF="\015\012";
     public static final String __LINE_SEPARATOR=
         System.getProperty("line.separator","\n");
        
     public static final String __ISO_8859_1="ISO-8859-1";
     public final static String __UTF8="UTF-8";
     public final static String __UTF8Alt="UTF8";
     public final static String __UTF16="UTF-16";
     
     public final static Charset __UTF8_CHARSET;
     public final static Charset __ISO_8859_1_CHARSET;
     
     static
     {
         =Charset.forName();
         =Charset.forName();
     }
     
     private static char[] lowercases = {
           '\000','\001','\002','\003','\004','\005','\006','\007',
           '\010','\011','\012','\013','\014','\015','\016','\017',
           '\020','\021','\022','\023','\024','\025','\026','\027',
           '\030','\031','\032','\033','\034','\035','\036','\037',
           '\040','\041','\042','\043','\044','\045','\046','\047',
           '\050','\051','\052','\053','\054','\055','\056','\057',
           '\060','\061','\062','\063','\064','\065','\066','\067',
           '\070','\071','\072','\073','\074','\075','\076','\077',
           '\100','\141','\142','\143','\144','\145','\146','\147',
           '\150','\151','\152','\153','\154','\155','\156','\157',
           '\160','\161','\162','\163','\164','\165','\166','\167',
           '\170','\171','\172','\133','\134','\135','\136','\137',
           '\140','\141','\142','\143','\144','\145','\146','\147',
           '\150','\151','\152','\153','\154','\155','\156','\157',
           '\160','\161','\162','\163','\164','\165','\166','\167',
           '\170','\171','\172','\173','\174','\175','\176','\177' };
 
     /* ------------------------------------------------------------ */
    
fast lower case conversion. Only works on ascii (not unicode)

Parameters:
s the string to convert
Returns:
a lower case version of s
 
     public static String asciiToLowerCase(String s)
     {
         char[] c = null;
         int i=s.length();
 
         // look for first conversion
         while (i-->0)
         {
             char c1=s.charAt(i);
             if (c1<=127)
             {
                 char c2=[c1];
                 if (c1!=c2)
                 {
                     c=s.toCharArray();
                     c[i]=c2;
                     break;
                }
            }
        }
        while (i-->0)
        {
            if(c[i]<=127)
                c[i] = [c[i]];
        }
        
        return c==null?s:new String(c);
    }
    /* ------------------------------------------------------------ */
    public static boolean startsWithIgnoreCase(String s,String w)
    {
        if (w==null)
            return true;
        
        if (s==null || s.length()<w.length())
            return false;
        
        for (int i=0;i<w.length();i++)
        {
            char c1=s.charAt(i);
            char c2=w.charAt(i);
            if (c1!=c2)
            {
                if (c1<=127)
                    c1=[c1];
                if (c2<=127)
                    c2=[c2];
                if (c1!=c2)
                    return false;
            }
        }
        return true;
    }
    
    /* ------------------------------------------------------------ */
    public static boolean endsWithIgnoreCase(String s,String w)
    {
        if (w==null)
            return true;
        if (s==null)
            return false;
            
        int sl=s.length();
        int wl=w.length();
        
        if (sl<wl)
            return false;
        
        for (int i=wl;i-->0;)
        {
            char c1=s.charAt(--sl);
            char c2=w.charAt(i);
            if (c1!=c2)
            {
                if (c1<=127)
                    c1=[c1];
                if (c2<=127)
                    c2=[c2];
                if (c1!=c2)
                    return false;
            }
        }
        return true;
    }
    
    /* ------------------------------------------------------------ */
    
returns the next index of a character from the chars string
    public static int indexFrom(String s,String chars)
    {
        for (int i=0;i<s.length();i++)
           if (chars.indexOf(s.charAt(i))>=0)
              return i;
        return -1;
    }
    
    /* ------------------------------------------------------------ */
    
replace substrings within string.
    public static String replace(String sString subString with)
    {
        int c=0;
        int i=s.indexOf(sub,c);
        if (i == -1)
            return s;
    
        StringBuilder buf = new StringBuilder(s.length()+with.length());
        do
        {
            buf.append(s.substring(c,i));
            buf.append(with);
            c=i+sub.length();
        } while ((i=s.indexOf(sub,c))!=-1);
        if (c<s.length())
            buf.append(s.substring(c,s.length()));
        return buf.toString();
        
    }
    /* ------------------------------------------------------------ */
    
Remove single or double quotes.
    public static String unquote(String s)
    {
        return QuotedStringTokenizer.unquote(s);
    }
    /* ------------------------------------------------------------ */
    
Append substring to StringBuilder

Parameters:
buf StringBuilder to append to
s String to append from
offset The offset of the substring
length The length of the substring
    public static void append(StringBuilder buf,
                              String s,
                              int offset,
                              int length)
    {
        synchronized(buf)
        {
            int end=offset+length;
            for (int i=offseti<end;i++)
            {
                if (i>=s.length())
                    break;
                buf.append(s.charAt(i));
            }
        }
    }
    
    /* ------------------------------------------------------------ */
    
append hex digit
    public static void append(StringBuilder buf,byte b,int base)
    {
        int bi=0xff&b;
        int c='0'+(bi/base)%base;
        if (c>'9')
            c'a'+(c-'0'-10);
        buf.append((char)c);
        c='0'+bi%base;
        if (c>'9')
            c'a'+(c-'0'-10);
        buf.append((char)c);
    }
    /* ------------------------------------------------------------ */
    public static void append2digits(StringBuffer buf,int i)
    {
        if (i<100)
        {
            buf.append((char)(i/10+'0'));
            buf.append((char)(i%10+'0'));
        }
    }
    
    /* ------------------------------------------------------------ */
    public static void append2digits(StringBuilder buf,int i)
    {
        if (i<100)
        {
            buf.append((char)(i/10+'0'));
            buf.append((char)(i%10+'0'));
        }
    }
    
    /* ------------------------------------------------------------ */
    
Return a non null string.

Parameters:
s String
Returns:
The string passed in or empty string if it is null.
    public static String nonNull(String s)
    {
        if (s==null)
            return "";
        return s;
    }
    
    /* ------------------------------------------------------------ */
    public static boolean equals(String s,char[] bufint offsetint length)
    {
        if (s.length()!=length)
            return false;
        for (int i=0;i<length;i++)
            if (buf[offset+i]!=s.charAt(i))
                return false;
        return true;
    }
    /* ------------------------------------------------------------ */
    public static String toUTF8String(byte[] b,int offset,int length)
    {
        try
        {
            return new String(b,offset,length,);
        }
        catch (UnsupportedEncodingException e)
        {
            throw new IllegalArgumentException(e);
        }
    }
    /* ------------------------------------------------------------ */
    public static String toString(byte[] b,int offset,int length,String charset)
    {
        try
        {
            return new String(b,offset,length,charset);
        }
        catch (UnsupportedEncodingException e)
        {
            throw new IllegalArgumentException(e);
        }
    }
    /* ------------------------------------------------------------ */
    public static boolean isUTF8(String charset)
    {
        return .equalsIgnoreCase(charset)||.equalsIgnoreCase(charset);
    }
    /* ------------------------------------------------------------ */
    public static String printable(String name)
    {
        if (name==null)
            return null;
        StringBuilder buf = new StringBuilder(name.length());
        for (int i=0;i<name.length();i++)
        {
            char c=name.charAt(i);
            if (!Character.isISOControl(c))
                buf.append(c);
        }
        return buf.toString();
    }
    
    /* ------------------------------------------------------------ */
    public static String printable(byte[] b)
    {
        StringBuilder buf = new StringBuilder();
        for (int i=0;i<b.length;i++)
        {
            char c=(char)b[i];
            if (Character.isWhitespace(c)|| c>' ' && c<0x7f)
                buf.append(c);
            else 
            {
                buf.append("0x");
                TypeUtil.toHex(b[i],buf);
            }
        }
        return buf.toString();
    }
    
    public static byte[] getBytes(String s)
    {
        try
        {
            return s.getBytes();
        }
        catch(Exception e)
        {
            .warn(e);
            return s.getBytes();
        }
    }
    
    public static byte[] getBytes(String s,String charset)
    {
        try
        {
            return s.getBytes(charset);
        }
        catch(Exception e)
        {
            .warn(e);
            return s.getBytes();
        }
    }
    
    
    
    
Converts a binary SID to a string SID http://en.wikipedia.org/wiki/Security_Identifier S-1-IdentifierAuthority-SubAuthority1-SubAuthority2-...-SubAuthorityn
    public static String sidBytesToString(byte[] sidBytes)
    {
        StringBuilder sidString = new StringBuilder();
        
        // Identify this as a SID
        sidString.append("S-");
        
        // Add SID revision level (expect 1 but may change someday)
        sidString.append(Byte.toString(sidBytes[0])).append('-');
        
        StringBuilder tmpBuilder = new StringBuilder();
        
        // crunch the six bytes of issuing authority value
        for (int i = 2; i <= 7; ++i)
        {
            tmpBuilder.append(Integer.toHexString(sidBytes[i] & 0xFF));
        }
        
        sidString.append(Long.parseLong(tmpBuilder.toString(), 16)); // '-' is in the subauth loop
   
        // the number of subAuthorities we need to attach
        int subAuthorityCount = sidBytes[1];
        // attach each of the subAuthorities
        for (int i = 0; i < subAuthorityCount; ++i)
        {
            int offset = i * 4;
            tmpBuilder.setLength(0);
            // these need to be zero padded hex and little endian
            tmpBuilder.append(String.format("%02X%02X%02X%02X"
                    (sidBytes[11 + offset] & 0xFF),
                    (sidBytes[10 + offset] & 0xFF),
                    (sidBytes[9 + offset] & 0xFF),
                    (sidBytes[8 + offset] & 0xFF)));  
            sidString.append('-').append(Long.parseLong(tmpBuilder.toString(), 16));
        }
        
        return sidString.toString();
    }
    
    
Converts a string SID to a binary SID http://en.wikipedia.org/wiki/Security_Identifier S-1-IdentifierAuthority-SubAuthority1-SubAuthority2-...-SubAuthorityn
    public static byte[] sidStringToBytesString sidString )
    {
        String[] sidTokens = sidString.split("-");
        
        int subAuthorityCount = sidTokens.length - 3; // S-Rev-IdAuth-
        
        int byteCount = 0;
        byte[] sidBytes = new byte[1 + 1 + 6 + (4 * subAuthorityCount)];
        
        // the revision byte
        sidBytes[byteCount++] = (byte)Integer.parseInt(sidTokens[1]);
        // the # of sub authorities byte
        sidBytes[byteCount++] = (byte)subAuthorityCount;
        // the certAuthority
        String hexStr = Long.toHexString(Long.parseLong(sidTokens[2]));
        
        whilehexStr.length() < 12) // pad to 12 characters
        {
            hexStr = "0" + hexStr;
        }
        // place the certAuthority 6 bytes
        for ( int i = 0 ; i < hexStr.length(); i = i + 2)
        {
            sidBytes[byteCount++] = (byte)Integer.parseInt(hexStr.substring(ii + 2),16);
        }
                
        
        for ( int i = 3; i < sidTokens.length ; ++i)
        {
            hexStr = Long.toHexString(Long.parseLong(sidTokens[i]));
            
            whilehexStr.length() < 8) // pad to 8 characters
            {
                hexStr = "0" + hexStr;
            }     
            
            // place the inverted sub authorities, 4 bytes each
            for ( int j = hexStr.length(); j > 0; j = j - 2)
            {          
                sidBytes[byteCount++] = (byte)Integer.parseInt(hexStr.substring(j-2, j),16);
            }
        }
      
        return sidBytes;
    }
New to GrepCode? Check out our FAQ X