A fast way to convert character arrays into Strings. : String char « Data Type « Java

Home
Java
1.2D Graphics GUI
2.3D
3.Advanced Graphics
4.Ant
5.Apache Common
6.Chart
7.Class
8.Collections Data Structure
9.Data Type
10.Database SQL JDBC
11.Design Pattern
12.Development Class
13.EJB3
14.Email
15.Event
16.File Input Output
17.Game
18.Generics
19.GWT
20.Hibernate
21.I18N
22.J2EE
23.J2ME
24.JDK 6
25.JNDI LDAP
26.JPA
27.JSP
28.JSTL
29.Language Basics
30.Network Protocol
31.PDF RTF
32.Reflection
33.Regular Expressions
34.Scripting
35.Security
36.Servlets
37.Spring
38.Swing Components
39.Swing JFC
40.SWT JFace Eclipse
41.Threads
42.Tiny Application
43.Velocity
44.Web Services SOA
45.XML
Java » Data Type » String charScreenshots 
A fast way to convert character arrays into Strings.
    
/*
 * $Id: CharStringConverter.java,v 1.3 2004/07/08 08:01:45 yuvalo Exp $
 *
 * (C) Copyright 2002-2004 by Yuval Oren. All rights reserved.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */


//package  com.bluecast.util;

import  java.io.*;
import  java.util.*;


/**
 * A fast way to convert character arrays into Strings. This class maintains
 * a hashtable of char[] -> String mappings. Returned Strings are guaranteed
 * to be internalized.
 *
 @author Yuval Oren, yuval@bluecast.com
 @version $Revision: 1.3 $
 */
final public class CharStringConverter {
    private static final float DEFAULT_LOAD = 0.70F;
    private float loadFactor;
    private int numEntries = 0;
    private int maxEntries;
    private int hashmask;
    private char[][] keys;
    private String[] values;

    public CharStringConverter (int initialCapacity, float loadFactor) {
        if (initialCapacity < 0) {
            throw  new IllegalArgumentException("Illegal initial capacity: "
                    + initialCapacity);
        }
        if (loadFactor < || loadFactor > 1) {
            throw  new IllegalArgumentException("Illegal load factor: " + loadFactor);
        }
        int desiredSize = (int)((float)initialCapacity/loadFactor);
        int size = 16;
        while (size < desiredSize) {
            size <<= 1;
        }
        hashmask = size - 1;
        maxEntries = (int)(size*loadFactor);
        keys = new char[size][];
        values = new String[size];
        this.loadFactor = loadFactor;
    }

    public CharStringConverter () {
        this(0, DEFAULT_LOAD);
    }

    public CharStringConverter (int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD);
    }

    /**
     * Returns the number of cached conversion mappings.
     */
    public int getCacheSize () {
        return  numEntries;
    }

    /**
     * Converts a character array into an internalized String.
     */
    public String convert (char[] ch) {
        return  convert(ch, 0, ch.length);
    }

    /**
     * Converts a character array into an internalized String.
     *
     @param ch character array to convert
     @param start starting offset of ch[]
     @param length number of characters to read
     */
    public String convert (char[] ch, int start, int length) {
        if (numEntries >= maxEntries) {
            rehash();
        }
        // Look for the cached String for this char array
        int offset = hashKey(ch, start, length& hashmask;
        char[] k = null;
        while ((k = keys[offset]) != null && !keysAreEqual(k, 0, k.length,
                ch, start, length)) {
            offset = (offset - 1& hashmask;
        }
        if (k != null) {
            return  values[offset];
        }
        else {
            // Add the conversion to the cache
            k = new char[length];
            System.arraycopy(ch, start, k, 0, length);
            String v = new String(k).intern();
            keys[offset= k;
            values[offset= v;
            numEntries++;
            return  v;
        }
    }

    private void rehash () {
        int newlength = keys.length << 1;
        char[][] newkeys = new char[newlength][];
        String[] newvalues = new String[newlength];
        int newhashmask = newlength - 1;
        for (int i = 0; i < keys.length; i++) {
            char[] k = keys[i];
            String v = values[i];
            if (k != null) {
                int newoffset = hashKey(k, 0, k.length& newhashmask;
                char[] newk = null;
                while ((newk = newkeys[newoffset]) != null && !keysAreEqual(newk,
                        0, newk.length, k, 0, k.length)) {
                    newoffset = (newoffset - 1& newhashmask;
                }
                newkeys[newoffset= k;
                newvalues[newoffset= v;
            }
        }
        keys = newkeys;
        values = newvalues;
        maxEntries = (int)(newlength*loadFactor);
        hashmask = newhashmask;
    }

    public void clearCache () {
        for (int i = 0; i < keys.length; i++) {
            keys[inull;
            values[inull;
        }
        numEntries = 0;
    }

    private static final boolean keysAreEqual (char[] a, int astart, int alength,
            char[] b, int bstart, int blength) {
        if (alength != blength) {
            return  false;
        }
        else {
            for (int i = 0; i < alength; i++) {
                if (a[astart + i!= b[bstart + i]) {
                    return  false;
                }
            }
            return  true;
        }
    }

    private static final int hashKey (char ch[]int start, int length) {
        int hash = 0;
        for (int i = 0; i < length; i++) {
            hash = (hash << 5+ ch[start + i];
        }
        return  hash;
    }
}

   
    
    
    
  
Related examples in the same category
1.StrCharAt - show String.charAt()
2.Basic tab-character handling stuff
3.Convert Characters to Lower Case
4.Convert Characters to Upper Case
5.Replace Characters in a String
6.Character array to String conversion
7.Convert String to character array
8.Last occurrence of a character
9.Extract Ascii codes from a String
10.To remove a character
11.Removes specified chars from a string
12.Checks if a String is not empty (""), not null and not whitespace only.
13.Checks if a String is whitespace, empty ("") or null.
14.Checks if the String contains any character in the given set of characters.
15.Checks if the String contains only certain characters.
16.Checks if the String contains only whitespace.
17.Checks if the string contains only ASCII printable characters.
18.Checks that the String does not contain certain characters.
19.The character array based string
20.Checks whether the String contains only digit characters.
21.Remove char from a string
22.Remove whitespace from the ends as well as excessive whitespace within the inside of the string between non-whitespace characters.
23.Removes any hypens ( - ) from the given string
24.Returns a new string with all the whitespace removed
25.Is char a white space character
26.Simple scanner that allows to navigate over the characters of a string.
27.Returns a string with size of count and all characters initialized with ch.
28.Returns a string that contains all characters of the given string in reverse order.
29.Returns a string that is equivalent to the specified string with its first character converted to uppercase
30.Count the number of occurrences of character c in a string.
31.XML utilities that pertain to character handling (markup or character data), without use of any XML libraries.
32.Check whether the given String contains any whitespace characters.
33.Character utilities.
34.Provides a number of static methods which interact with java.nio.charset.Charset to analyze and transform the strings identifing character encodings.
35.Operations on char primitives and Character objects.
36.Cleans strings of illegal characters with respect to the XML specification.
37.Return the result of adding the specified character to the specified sorted character array.
38.Return a displayable version of the character sequence, followed by integer positions at various powers of 10.
39.Returns the string constructed from the specified character sequence by deaccenting each of its characters.
40.Returns a hash code for a character sequence that is equivalent to the hash code generated for a its string yield.
41.Return true if the two character sequences have the same length and the same characters.
42.Returns an array of substrings of the specified string, in order, with divisions before and after any instance of the specified character.
43.Returns true if specified character is a punctuation character.
44.Appends a whitespace-normalized form of the specified character sequence into the specified string buffer.
45.Determine whether characters may appear in certain roles in XML documents.
46.Advanced navigation over the underlying string.
47.Compare two char sequences
48.Contents As CharSequence
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.