CompressedString (de.mpg.mpi-inf:javatools 1.1 API)

java.lang.Object
- javatools.datatypes.CompressedString

All Implemented Interfaces:

CharSequence, Comparable<CompressedString>
```
public class CompressedString
extends Object
implements CharSequence, Comparable<CompressedString>
```
Copyright 2016 Fabian M. Suchanek 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. This class represents an equivalence class of Strings. The equivalence class stores one prototype String, but compresses the String with 7, 6 or less bits per character (the String-class uses 16). This makes the CompressedString less memory consuming than a normal String, but possibly the original String cannot be reconstructed. The less bits you use, the less space you will consume, the less likely it will be that you can reconstruct the original String and the larger the equivalence class will be. Example:
```
 
    System.out.println(new CompressedString("How are you?",7));
    System.out.println(new CompressedString("How are you?",6));
    System.out.println(new CompressedString("How are you?",5));
    System.out.println(new CompressedString("How are you?",4));
    System.out.println(new CompressedString("How are you?",3)); 
    -->
        How are you?
        HOW ARE YOU?
        HOW ARE YOU?
        HOW@ARE@YOU
        HOG@ABE@IOEO
        @GG@ABE@AGEG
   
```
CompressedStrings are useful for large Collections of Strings where only membership checks are made. If the Strings are sufficiently different, then a TreeSet can contain CompressedStrings with a low bit number and membership checks will be handled correctly. A CompressedString is equal to all the (uncompressed) Strings in its equivalence class (violating the transitivity of equals on calls with non-CompressedStrings).

Field Summary

Fields
Modifier and Type	Field and Description
`protected byte`	`BITSPERCHAR` Number of bits per character
`protected byte[]`	`data` The string
`protected int`	`length` Number of characters in this CompressedString
`protected int`	`startBit` StartBit (for subsequence)

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`CompressedString(byte[] data, int startBit, int length)` Duplicates a CompressedString (for subSequence)
	`CompressedString(CharSequence s1)` Compresses a CharSequence with 6 bits
	`CompressedString(CharSequence s1, int bits)` Compresses a CharSequence

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`bits()` Returns the bits per character
`char`	`charAt(int index)` Returns the character at position index
`int`	`compareTo(CharSequence s0)` 1 if this CompressedString is lexically larger than the CompressedString of the argument, else -1 or 0
`int`	`compareTo(CompressedString s)` 1 if this CompressedString is lexically larger than the the argument, else -1 or 0
`boolean`	`equals(Object o)` Tells whether the argument (any CharSequence) is in the equivalence class of this CompressedString
`int`	`hashCode()` Returns a hash-code
`int`	`length()` Returns the number of characters in this CompressedString
`static void`	`main(String[] args)` Test routine
`CharSequence`	`normalize(CharSequence s)` Normalizes (see Char.java) and upcases a CharSequence if necessary
`int`	`size()` Returns the bytes used by this CompressedString
`CharSequence`	`subSequence(int start, int end)` Returns a subsequence of this CompressedString (without duplicating the data)
`String`	`toString()` Tries to reconstruct the original String

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.CharSequence
chars, codePoints

- Field Detail
  - BITSPERCHAR
```
protected byte BITSPERCHAR
```
    Number of bits per character
  - data
```
protected byte[] data
```
    The string
  - startBit
```
protected int startBit
```
    StartBit (for subsequence)
  - length
```
protected int length
```
    Number of characters in this CompressedString
- Constructor Detail
  - CompressedString
```
protected CompressedString(byte[] data,
                           int startBit,
                           int length)
```
    Duplicates a CompressedString (for subSequence)
  - CompressedString
```
public CompressedString(CharSequence s1,
                        int bits)
```
    Compresses a CharSequence
  - CompressedString
```
public CompressedString(CharSequence s1)
```
    Compresses a CharSequence with 6 bits
- Method Detail
  - hashCode
```
public int hashCode()
```
    Returns a hash-code
    
    Overrides:
    
    hashCode in class Object
  - length
```
public int length()
```
    Returns the number of characters in this CompressedString
    
    Specified by:
    
    length in interface CharSequence
  - size
```
public int size()
```
    Returns the bytes used by this CompressedString
  - bits
```
public int bits()
```
    Returns the bits per character
  - charAt
```
public char charAt(int index)
```
    Returns the character at position index
    
    Specified by:
    
    charAt in interface CharSequence
  - equals
```
public boolean equals(Object o)
```
    Tells whether the argument (any CharSequence) is in the equivalence class of this CompressedString
    
    Overrides:
    
    equals in class Object
  - normalize
```
public CharSequence normalize(CharSequence s)
```
    Normalizes (see Char.java) and upcases a CharSequence if necessary
  - compareTo
```
public int compareTo(CharSequence s0)
```
    1 if this CompressedString is lexically larger than the CompressedString of the argument, else -1 or 0
  - compareTo
```
public int compareTo(CompressedString s)
```
    1 if this CompressedString is lexically larger than the the argument, else -1 or 0
    
    Specified by:
    
    compareTo in interface Comparable<CompressedString>
  - subSequence
```
public CharSequence subSequence(int start,
                                int end)
```
    Returns a subsequence of this CompressedString (without duplicating the data)
    
    Specified by:
    
    subSequence in interface CharSequence
  - toString
```
public String toString()
```
    Tries to reconstruct the original String
    
    Specified by:
    
    toString in interface CharSequence
    
    Overrides:
    
    toString in class Object
  - main
```
public static void main(String[] args)
```
    Test routine

Class CompressedString

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

Field Detail

BITSPERCHAR

data

startBit

length

Constructor Detail

CompressedString

CompressedString

CompressedString

Method Detail

hashCode

length

size

bits

charAt

equals

normalize

compareTo

compareTo

subSequence

toString

main