Java >> Java tutorial >  >> Tag >> String

Sådan konverteres tegnarray til streng i Java

En streng er defineret som en samling af tegn. Et tegnarray adskiller sig fra en streng ved, at strengen afsluttes med specialtegnet "\0". En streng transformeres fra et tegnarray og omvendt. Vi vil overveje at konvertere et tegnarray til en streng i denne artikel.

Metoder:

  • Brug af metoden copyOf() i Arrays-klassen
  • Brug af StringBuilder-klassen
  • Bruger værdiOf()-metoden i String-klassen
  • Brug af metoden copyValueOf() i String-klassen
  • Brug af samlere i streams
  • Brug af String Class Constructor

Lad os undersøge hver af metoderne i detaljer og implementere dem ved hjælp af et rent Java-program.

Konvertering af tegnarray til streng i Java

Funktion 1:Brug af Array-klassens copyOf()-metode

String-konstruktøren accepterer det angivne tegn som et argument. Arrays bruges som standard til at kopiere indholdet af tegnarrayet. Arrays-klassen har en copyOf()-funktion.

Eksempel:Et program til at konvertere Character Array til String i Java

// Using copyOf() method ofArrays class

// Main class
class CodeunderscoredArrayClass {

	// Method 1
	// To convert a character
	// array to a string using the constructor
	public static String toString(char[] a)
	{
		// Creating object of String class
		String string = new String(a);

		return string;
	}

	// Main driver method
	public static void main(String args[])
	{

		// Character array
		char s[] = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };

		// Printing converted string from character array
		System.out.println(toString(s));
	}
}

Metode 2:Brug af StringBuilder-klassen

Hvad hvis vi ville lave en streng ud af en samling af char-arrays? Derefter kan vi oprette et StringBuilder-objekt og bruge dets append(char[])-funktion til at forbinde alle elementerne.

StringBuilder-klassen bruges også til at transformere et tegnarray til en streng. Ideen er at cykle gennem karakterarrayet og vedhæfte hvert tegn til slutningen af ​​strengen, fordi en StringBuilder er en foranderlig klasse. Endelig indeholder strengen tegnernes strengform. Senere vil vi bruge metoden toString() til at hente dens String-repræsentation.

StringBuilder-klassens append()-metode tilføjer char[]-arrayets strengrepræsentation.

Den analyserer parameteren str, der skal tilføjes. Dette objekt returneres som en reference. Denne funktion fungerer på samme måde som String.valueOf(char[]), bortset fra at tegnene i den streng er tilføjet til denne tegnsekvens.

Syntaksen er som følger:

public StringBuilder append(char[] str)

toString()-metoden

StringBuilder-klassens toString()-metode returnerer en streng, der repræsenterer sekvensens data. Den opretter et nyt String-objekt og sætter dens begyndelsesværdi til tegnsekvensen. Eventuelle ændringer, vi foretager i char[]-arrayet, påvirker ikke den nydannede streng.

Syntaksen er som følger:

public String toString()

For at konvertere char[]-arrayet til streng i det følgende eksempel brugte vi StringBuilder-klassens append()- og toString()-metoder.

Eksempel:Program til konvertering af tegnarray til streng i Java

// Using StringBuilder class

// importing required classes
import java.util.*;

// Main class
public class CodeunderscoredCharacterArray {

	// Method
 for con vert a character array to a string
	// using the StringBuilder class
	public static String toString(char[] theChar)
	{
		// Creating object of String class
		StringBuilder stringBuilder = new StringBuilder();

		// Creating a string using append() method
		for (int i = 0; i < theChar.length; i++) {
			stringBuilder.append(theChar[i]);
		}

		return stringBuilder.toString();
	}

	// The Main driver method
	public static void main(String args[])
	{

		// Custom input as character array
		char charArray[] = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };

		// Printing the string
		// corresponding to character array
		System.out.println(toString(charArray));
	}
}

Eksempel:String Builder

@Test
public void StringBuilderOK() {
    final char[][] arrayOfCharArray = { { 'c', 'o' }, { 'd', 'e', 'u', 'n' }, { 'd', 'e', 'r', 's', 'c', 'o', 'e', 'd' } };    
    StringBuilder stringBuilder = new StringBuilder();
    for (char[] subArray : arrayOfCharArray) {
        stringBuilder.append(subArray);
    }
    assertThat(sb.toString(), is("codeunderscored"));
}

Vi kan gøre følgende kode endnu mere effektiv ved at oprette en StringBuilder med den nødvendige længde.

Eksempel:Char Array til String ved hjælp af StringBuilder

public class CodeCharArrayToString
{  
  public static void main(String[] args)  
  {  

    //character array      
    char[] charVals = {'C', 'o', 'd', 'e', ' ', 'U', 'n', 'd', 'e', 'r', 's', 'c', 'o',  'r', 'e', 'd'};  

    //creating an object of the StringBuilder class  
    StringBuilder stringBuilder = new StringBuilder();  
    //Java for-each loop  
    for(char ch: charVals)   
    {  
      // the method appends  the representation of the string as a char array   
      stringBuilder.append(ch);  
    }  
    //the toString() method is responsible for returning a string that represents data in the sequence  
    String stringVal = stringBuilder.toString();  

    //prints the string  
    System.out.println(stringVal);  
  }  
}  

Funktion 3:Brug af String-klassens valueOf()-metode

Funktionen valueOf() i String-klassen bruges også til at konvertere et tegnarray til en streng.

Denne metode ændrer automatisk tegnarrayet til et format, der viser hele værdien af ​​tegnene i arrayet. Denne funktion konverterer en streng fra en int, float, double, char, boolean eller endda et objekt. Vi vil nå vores mål ved at omdanne vores karakterarray til en streng.

I det følgende eksempel har vi genereret et char[]-array ved navn charArray. Derefter brugte vi String-klassens valueOf()-metode til at parse en char[] charArray ind i den. Sidstnævnte returnerer den tegnsekvens, vi har angivet i parameteren.

Eksempel:Et program til konvertering af et tegnarray til streng i Java

// Using valueOf() method of String class

// Main class
class CodeunderscoredCharacterArrayToString {

	// Method 1
// To convert a character array to string
// using the valueOf() method
	public static String toString(char[] theChar)
	{
		// Creating an object of String class
		String strVal = String.valueOf(theChar);

		return strVal;
	}

	// Method 2
	// Main driver method
	public static void main(String args[])
	{
	
		// Custom input character array
		char charArray[] = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };

		// Print the corresponding string to
		// character array
		System.out.println(toString(charArray));
	}
}

I det efterfølgende afsnit ser vi på et andet eksempel, hvor valueOf()-metoden konverterer et char-array til en streng.

Det første trin er at oprette et tegnarray som følger:

char[] arrVal = { 'c', 'o', 'd', 'e' };

Derefter vil valueOf()-metoden tage over for at konvertere hele arrayet til en streng, som vist nedenfor.

String strVal = String.valueOf(arr);

Vi sætter derefter alle disse sammen som en komplet funktion kaldet CodeunderscoredValueOf() som illustreret nedenfor.

public class CodeunderscoredValueOf {
   public static void main(String []args) {
      char[] arrVal = { 'c', 'o', 'd', 'e' };
      String strVal = String.valueOf(arrVal);
      System.out.println(strVal);
   }
}

Funktion 4:Brug af String-klassens copyValueOf()-metode

Det fungerer ligesom valueOf() metoden. String-klassens copyValueOf()-metode er også en statisk metode. Et char[]-array parses også. Derudover returnerer den tegnsekvensen (String), vi har angivet i parameteren.

Tegnarrayets indhold kopieres og redigeres derefter uden at påvirke den streng, der skal returneres. Denne fremgangsmåde giver os også mulighed for at konvertere tegnarrayet til streng, som det ses i følgende eksempel.

Eksempel:Program til konvertering af et tegnarray til streng i Java

// Using copyValueOf() method of String class

// Importing String class
import java.util.*;

// Main class
class CodeunderscoredCharacterArrayToString {

	// Main driver method
	public static void main(String[] args) {

		// Customly declaring an input character array
		char charArray[] = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };

		// Using copyValueOf() over string and
		// storing it in a string
		String strVal = String.copyValueOf(arr);

		// Printing the converted string corresponding
		// character array
		System.out.print(strVal);
	}
}

Lad os se på et andet eksempel, hvor metoden copyValueOf() bruges til at konvertere et char-array til en streng.

public class CodeunderscoredCopyValueOf {
   public static void main(String []args) {
      char[] arrVal = { 'c', 'o', 'd', 'e' };
      String strVal = String.copyValueOf(arrVal, 1, 2);
      System.out.println(strVal);
   }
}

String#copyValueOf er en metode, der semantisk svarer til valueOf()-metoden, men den var kun nyttig i de tidlige Java-udgivelser. CopyValueOf()-funktionen er forældet i dag, og vi anbefaler ikke at bruge den.

Funktion 5:Brug af samlere i streams i Java

Med fremkomsten af ​​streams i java8 bruger vi straks Collectors i streams til at ændre vores karakterinput-array-medlemmer og bruger derefter joining()-metoden til at returnere en enkelt streng, som vi derefter udskriver.

Eksempel:Program til konvertering af et tegnarray til streng i Java

// Using Collectors in Streams in Java8

// Importing Collectos and Stream classes
// from java.util.stream package

import java.util.stream.Collectors;
import java.util.stream.Stream;

// Main class
class CodeunderscoredCharacterArrayToString {

	// Main driver method
	public static void main(String[] args)
	{

		// Custom input character array
		char[] charVal = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };

		// Using collectors array elements collection and
		// subsequently using the join method to return a single
		// string
		String strVal = Stream.of(charVal)
						.map(arr -> new String(arr))
						.collect(Collectors.joining());

		// Printing the stream received from Collectors
		System.out.println(strVal);
	}
}

Vi kan åbne en strøm på tværs af et array af typen T ved hjælp af Arrays.stream(T[]-objekt) metoden. Efterfølgende kan vi bruge Collectors.joining()-funktionen til at oprette en streng med et tegnarray.

@Test
public void StreamCollectors() {
    final Character[] charArray = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
    Stream<Character> charStream = Arrays.stream(charArray);
    String stringVal = charStream.map(String::valueOf).collect(Collectors.joining());
    assertThat(stringVal, is("codeunderscored"));
}

Ulempen ved denne teknik er, at vi udfører valueOf() på hvert tegnelement, hvilket vil være langsomt.

Eksempel:Brug af String-objekt og Using valueOf-metoden

Dette eksempel viser, hvordan man konverterer et char-array til en String ved at bruge både valueOf()-metoden i String-klassen og oprettelse af String-objekt ved at sende matrixnavnet til konstruktøren. Vi har et char-array ch, og vi har brugt char-arrayet til at konstruere to strenge, str og str1.

class CharArrayToString
{
   public static void main(String args[])
   {
      // Method 1: Using String object

      char[] charVal = {'g', 'o', 'o', 'd', ' ', 'm', 'o', 'r', 'n', 'i', 'n', 'g'};
      String strVal = new String(charVal);
      System.out.println(strVal);
 
      // Method 2: Using valueOf method

      String strTwoVal = String.valueOf(charVal);
      System.out.println(strTwoVal);
   }
}

Guava Joiner (fælles base)

Lad os lade som om, at den streng, vi forsøger at lave, er en afgrænset streng. Guava giver os en nyttig metode:

@Test
public void GuavaCommonBaseJoiners() {
    final Character[] charArray = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
    String stringJoiner = Joiner.on("|").join(charArray);
    assertThat(stringJoiner, is("c|o|d|e|u|d|e|r|s|c|o|r|e|d"));
}

Det er værd at bemærke, at join()-metoden kun accepterer en Character-array, ikke en raw char-array.

Konstruktion af en strengklassekonstruktør

En konstruktør i String-klassen tager et char[]-array som et argument og tildeler en ny String. Det angiver den rækkefølge, som tegnene vises i (streng). Den nydannede streng forbliver uændret, hvis vi ændrer char[]-arrayet.

Syntaksen er som følger:

public String (char[] value)

Hvor char[] er strengens startværdi, har vi efterfølgende konstrueret et tegnarray kaldet chVal i eksemplet nedenfor. Derefter udviklede vi en String-konstruktør, der tager char[]-arrayet chVal som en parameter og analyserede det. char[]-arrayet konverteres til en streng.

public class CharArrayToStringConstructor
{  
  public static void main(String args[])  
  {  
    //character array  
    char[] chVal = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
    //String class's constructor that parses char array as a parameter  
    String stringVal = new String(chVal);  
    //prints the string  
    System.out.println(stringVal);  
  }  
}  

Konklusion

Denne artikel udforskede konvertering af et tegnarray til dets String-repræsentation i Java. For at konvertere et char-array til en streng i Java skal du bruge funktionen valueOf(). valueOf()-metoden er en statisk metode i String-klassen, som du kan bruge til at konvertere et char[]-array til en streng. Metoden analyserer et char[]-array som et argument. Derefter returnerer den en nyligt allokeret streng med den samme sekvens af tegn som tegnarrayet. Den nydannede streng forbliver uændret, hvis vi ændrer char[]-arrayet.

Derudover kan metoden copyValueOf() også bruges til at repræsentere tegnsekvensen i det givne array. Det returnerer en streng, der indeholder tegnene fra det medfølgende tegnarray.

String-klassens konstruktør er overbelastet forskellige steder. String(char[]) er en konstruktør, der tager et tegnarray som et argument. Den opretter derefter en ny streng, der afspejler den tegnsekvens, der er angivet i parameteren for tegnarray.


Java tag