# ByteBuffer -> String und String -> ByteBuffer



## Gelöschtes Mitglied 5909 (29. Aug 2008)

Hallo Zusammen,

in einem anderen Thread hab ich schon über die Probleme die ich mit nio habe geschrieben,
es ging da aber erstmal nur um die Connection.
Ich habe aber auch festgestellt dass ich immer wieder Probleme habe zwischen
einem String und den nio Buffer-type zu konvertieren.

Das äußert sich darin dass (byte)0x00 im buffer enthalten ist und wenn ich diesen
in einen String convertiere müll bei rauskommt.
Der Buffer enthalt aber nicht nur (byte)0x00 sondern auch richtigen Text.

Wie entferne convertiere ich richtig, dass der Müll nicht in meinen Strings landet?





Folgendermaßen convertiere ich zur Zeit:


```
package net.mas.irc.sys;

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;

public class NIOUtils {

	private static Charset			ascii	= Charset.forName("US-ASCII");

	private static CharsetEncoder	encoder	= ascii.newEncoder();

	private static CharsetDecoder	decoder	= ascii.newDecoder();

	private NIOUtils() {
	}

	public static ByteBuffer buffer( String string ) {
		byte[] bytes = string.getBytes();
		ByteBuffer buffer = ByteBuffer.allocate(bytes.length);
		return (ByteBuffer) buffer.put(bytes).compact().flip();
	}

	public static String string( ByteBuffer buffer ) {
		if ( buffer.hasArray() ) {
			return new String(buffer.array());
		}
		return "";
	}

	public static ByteBuffer asciiEncode( CharBuffer cbuf ) {
		try {
			ByteBuffer buffer = encoder.encode(cbuf);
			return (ByteBuffer) buffer.compact().flip();
		} catch ( CharacterCodingException e ) {
			return ByteBuffer.allocate(0);
		}
	}

	public static ByteBuffer asciiEncode( ByteBuffer buffer ) {
		return asciiEncode(buffer.asCharBuffer());
	}

	public static ByteBuffer asciiEncode( String string ) {
		return asciiEncode(CharBuffer.wrap(string));
	}

	public static String asciiDecode( ByteBuffer buffer ) {
		try {
			CharBuffer decoded = decoder.decode(buffer);
			return decoded.toString();
		} catch ( CharacterCodingException e ) {
			return "";
		}
	}

	public static String asciiDecode( String string ) {
		return asciiDecode(buffer(string));
	}

}
```

das ganze wird von einem SocketChannel gelesen:


```
int read = sc.read(buffer);
				if ( read == -1 ) {
					continue;
				}
				if ( read > 0 ) {
					String message = NIOUtils.string(buffer);
					String[] strings = message.split(IRCClient.CRLF);
					for ( String string : strings ) {
						if ( string.startsWith(Message.PING) ) {
							connection.incomingPing();
						}
						messanger.receive(string);						
					}
				}
```

//EDIT

folgendes hat ebenfals nichts gebracht


```
public static ByteBuffer remove0x00( ByteBuffer buffer ) {
		if ( buffer.hasArray() ) {
			byte[] array = buffer.array();
			int zerobytes = 0;
			for ( byte b : array ) {
				if ( b == (byte) 0x00 ) {
					zerobytes++;
				}
			}
			byte[] bytes = new byte[array.length - zerobytes];
			int i = 0;
			for ( byte b : array ) {
				if ( b != (byte) 0x00 ) {
					bytes[i] = b;
					i++;
				}
			}
			buffer.put(bytes);
		}
		return buffer;
	}
```


----------



## Murray (29. Aug 2008)

So ganz habe ich den Code nicht durchdrungen, aber mir fällt auf, dass Du hier

```
public static ByteBuffer buffer( String string ) {
      byte[] bytes = string.getBytes();
      ByteBuffer buffer = ByteBuffer.allocate(bytes.length);
      return (ByteBuffer) buffer.put(bytes).compact().flip();
   }

   public static String string( ByteBuffer buffer ) {
      if ( buffer.hasArray() ) {
         return new String(buffer.array());
      }
      return "";
   }
```
das Default-Encoding verwendest, während Du an anderer Stelle explizit mit dem Charset US-ASCII arbeitest. Vielleicht solltest Du das konsequent durchhalten und überall mit dem definierten Charset arbeiten?

Das wäre dann:

```
public static ByteBuffer buffer( String string ) {
      byte[] bytes = string.getBytes( ascii);
      ByteBuffer buffer = ByteBuffer.allocate(bytes.length);
      return (ByteBuffer) buffer.put(bytes).compact().flip();
   }

   public static String string( ByteBuffer buffer ) {
      if ( buffer.hasArray() ) {
         try {  
           return new String(buffer.array(), ascii);
         } catch ( Exception e) {
           e.printStackTrace(); //--- TODO exception-handling!!
         } 
      }
      return "";
   }
```


----------



## Gelöschtes Mitglied 5909 (29. Aug 2008)

danke erstmal, die ganze Charset geschichte ist auch schwer zu testen.

habe es eingebraut, trotzdem verändert das trotzdem die zero byte strings ausgegeben werden.

Habe das ganze jetzt mit nem Filter gelöst:


```
public static String zerobyteFilter( String string ) {
		byte[] bytes = string.getBytes(ascii);
		if ( bytes.length > 0 && bytes[0] == (byte) 0x00 ) {
			return null;
		}
		return string;
	}
```

funktioniert aber auch nur weil ich vorher den String den ich erhalte nach \r\n splitte.
Sonst würde ich wohl nichts mehr bekommen

das ganze müsste aber auch anders gehen...


----------

