Share
I den här handledningen kommer du att bli bekant med en av de viktigaste programmeringsdatastrukturerna (typerna) i Java-strängen. Stringvariabler kan användas för att lagra textdata (bokstäver, siffror, symboler) som är kopplade till ett program.
Android-applikationer skrivs i Java, ett programmeringsspråk. Java har ett antal primitiva datatyper för olika typer av tal (heltal, floats, etc.), booleska värden och enstaka tecken. Förutom att lagra textdata som arrays eller tecken, innehåller Java också en kraftfull objektklass som heter String (java.lang.String), som inkapslar textdata noggrant och kan användas för att manipulera innehåll. I den här handledningen lär du dig att skapa, använda och manipulera strängar på olika sätt, inklusive hur man lagrar dem som Android-projektresurser.
Tekniskt behöver du inga verktyg för att slutföra denna handledning, men du kommer säkert att behöva dem för att utveckla Android-applikationer.
För att utveckla Android-applikationer (eller Java-program, för den delen) behöver du en utvecklingsmiljö för att skriva och bygga applikationer. Eclipse är en mycket populär utvecklingsmiljö (IDE) för Java och den föredragna IDE för Android utveckling. Det är fritt tillgängligt för Windows, Mac och Linux operativsystem.
För fullständiga instruktioner om hur du installerar Eclipse (inklusive vilka versioner som stöds) och Android SDK, se webbplatsen för Android-utvecklaren.
På den mest grundläggande nivån bryts Java-programmen in i funktionalitet och data. Mycket mänskligt läsbar data kommer i form av ord, tecken, interpunktion, siffror och så vidare. I grund och botten kan allt användaren skriva på ett tangentbord. Programmerare kallar denna lagring av textinnehåll "strängdata", men själva data kan lagras med en mängd olika datastrukturer, beroende på dina krav:
Som du kan se finns det många sätt att lagra strängdata i Java. Exempelvis representerar följande Java-variabler en rad vokaltecken på olika sätt (som byte, tecken, Unicode-representationer eller delsträngar):
Accentsconagua
String strVowels = "aeiou"; char astrVowels [] = 'a', 'e', 'i', 'o', 'u'; byte abyteVowels [] = 'a', 'e', 'i', 'o', 'u'; byte abyteVowelsU [] = '\ u0061', '\ u0065', '\ u0069', '\ u006F', '\ u0075'; String uVowels = ny String ("\ u0061 \ u0069 \ u006F \ u0075"); CharSequence csVowels = (CharSequence) New String ("aeiou"); StringBuffer sbVowels = ny StringBuffer ("a" + "e" + "iou"); StringBuilder sVowelBuilder = ny StringBuilder (); sVowelBuilder.append ( 'a'); sVowelBuilder.append ( "EIO"); sVowelBuilder.append ( '\ u0075'); String klassen är bekvämligheten klassen används oftast, särskilt av nybörjare. Du kommer också att ha en godtagbar förståelse för CharSequence (java.lang.CharSequence) gränssnittet, eftersom det ofta används när du arbetar med Android-resurser.
String-klassen är tillgänglig som en del av paketet java.lang, som ingår i Android SDK för utvecklare att använda. Den fullständiga dokumentationen för String-klassen finns i Android SDK-dokumentationen.
String-klassen representerar en oföränderlig (oföränderlig) sekvens av Unicode (16-bitars kodning) tecken, lämplig för att lagra tecken på vilket språk som helst (engelska, tyska, japanska osv.).
Så vad har detta att göra med Android utveckling? Tja, strängar används för att lagra innehåll som visas på applikationsskärmar, eller för att lagra inmatning som tas in från en användare. Android-utvecklare laddar, skapar och manipulerar strängdata kontinuerligt. Så låt oss titta på några av de saker vi kan göra med String-klassen.
String-klassen har många konstruktörer, för att skapa och instansera strängvariabler. Strängvariabler kan ställas in för att tömma med hjälp av null-sökordet. Du kan också ställa in innehållet från byte, tecken eller andra strängdata. Det här är till exempel några sätt att skapa strängvariabler för användning inom dina applikationer (vissa initialiseras från variablerna, som uVowels och sVowelBuilder, definierad tidigare i denna handledning):
String strVowels1 = "aeiou"; String strVowels2 = New String ("aeiou"); String strVowels3 = Ny String (sVowelBuilder); String strVowels4 = New String (sbVowels); String strVowels5 = ny sträng (uVowels); String strVowels6 = new String (abyteVowels2); String strVowels7 = new String (abyteVowelsU); String strVowels8 = ny sträng ("a" + "e" + "iou"); String strVowels9 = ny String (ny char [] '\ u0061', '\ u0065', '\ u0069', '\ u006F', '\ u0075'); String strVowels10 = ny String (new byte [] '\ u0061', '\ u0065', '\ u0069', '\ u006F', '\ u0075'); Du kan också ladda strängar från Android-programresurser, förutsatt att du har lagrat dem korrekt. Till exempel kan du ladda strängresursen för programnamnet till en strängvariabel enligt följande:
String strAppName = getResources (). GetString (R.string.app_name);
Detta förutsätter att den aktuella Android-applikationen innehåller en strängresurs som heter app_name någonstans i hierarkin för / res / värden i projektkatalogen. Till exempel en fil som heter /res/values/strings.xml som innehåller följande XML-strängdefinition:
Mitt Android Appnamn!
Låt oss nu titta på några av de coola sakerna du kan göra för strängobjekt. Låt oss först fokusera på funktionerna inom String-klassen själv.
Det är bra att tänka på en sträng som en sekvens av tecken. Som sådan vill du ibland iterera genom innehållet, ett tecken åt gången. Det finns många sätt att göra detta, men ett enkelt sätt är att använda en för () loop. Du kan utnyttja metoden String längd () för att bestämma hur många tecken du har och metoden charAt () för att hämta ett visst tecken genom sitt index, precis som om du skulle ha ett arrayindex. Till exempel:
String strVowels = "AEIOU"; för (int i = 0; i < strVowels.length(); i++) char curChar = strVowels.charAt(i);
Som tidigare nämnts är strängvariabler oföränderliga eller oföränderliga. Det betyder inte att du inte kan manipulera textinnehållet i en strängvariabel, men varje metod som gör det returnerar en ny strängvariabel. Några vanliga exempel på strängklassmetoder som genererar nya strängvariabler inkluderar:
Tänk på att varje av dessa metoder allokerar en ny String objekt instans för att lagra resultatet. Den ursprungliga strängvariabeln förblir oförändrad.
Ibland vill du konvertera din sträng till stora eller små bokstäver. En anledning som du kanske vill ändra på en sträng är att normalisera strängen för att göra det otillräckligt att söka eller matcha det enklare att genomföra.
String strUpperCaseVersion = strVowels.toUpperCase (); String strLowerCaseVersion = strVowels.toLowerCase ();
Observera att här har du skapat två nya strängvariabler för användning. Den ursprungliga strängvariabeln, strVowels, förblir oförändrad.
Ibland vill du snabbt analysera en sträng i understrängar. Du kan göra det här för att extrahera de enskilda orden från en mening eller en avgränsad lista med taggar etc. Du kan använda enkla reguljära uttryck med funktionen split () för detta ändamål. Till exempel extraherar följande kod de enskilda orden (färger) från en sträng:
String someWords = "Röd Orange Gul Grön Blå Indigo"; String aColors [] = someWords.split (""); Om du skulle skriva ut innehållet i String-arrayen som heter aColors, så skulle du se det:
aColors [0] = Röd aColors [1] = Orange aColors [2] = Gula aColors [3] = Grön aColors [4] = Blå aColors [5] = Indigo
Observera att här har du skapat en ny uppsättning som innehåller 6 nya strängvariabler för användning.
Du kan kontrollera om två strängar matchar med String-klassens jämförTo () -metod. Denna metod returnerar 0 om, och endast om, de två strängarna är identiska:
String strVowels = "AEIOU"; om (strVowels.compareTo ("AEIOU") == 0) // Strängar matchar! (Denna kod kommer att utföras) else // Strängar matchar inte! Observera att metoden jämförTo () är skiftlägeskänslig. Överväg att konvertera båda sidor av din jämförelse till ett fall innan du jämför dem, om du inte letar efter ett fall. Om du inte bryr dig om fallet kan du också använda metoden comparToIgnoreCase () istället för metoden comparTo ():
String strVowels = "AEIOU"; om (strVowels.compareToIgnoreCase ("aeiou") == 0) // Strängar matchar! (Denna kod kommer att utföras) else // Strängar matchar inte! Ibland vill du söka efter en sträng för ett tecken eller en substring. Det finns många andra sätt att utföra strängmatchning och sökning, så att du kan bygga alla sökmetoder du önskar. Du kan också leta efter specifika tecken eller substrängar med hjälp av metoderna indexOf () och lastIndexOf (), kontrollera om en sträng börjar eller slutar med en substring med metoderna startsWith () och endsWith (). Slutligen stöder matchningen () -metoden regelbunden expressions matchning.
Här använder vi metoden () för att bestämma om ett specifikt substrat existerar:
om (strVowels.contains ("IOU") == true) // String innehåller IOU-understräng! Om du inte bryr dig om fall, använd metoden comparToIgnoreCase () istället:
String strVowels = "AEIOU"; om (strVowels. compareToIgnoreCase ("aeiou") == 0) // Strängar matcha! (Denna kod kommer att utföras) else // Strängar matchar inte! Tips: När du genomför matchnings- och sökfunktionalitet i dina program, glöm inte att göra någon förbehandlingssträngmanipulation som är nödvändig för att utesluta övre / lägre / blandade fallsträngproblem innan du söker. Normalisering av användardata kan göras som en del av inmatningsvalideringsprocessen, så att din kod är så enkel och underhållbar som möjligt.
Striktobjektet är så grundläggande för Java att varje klass, på grund av att den härrör från rotklassen heter Object (java.lang.Object), har en toString () -metod för att skapa en användbar strängrepresentation av deras värde. Klasser som inte har en rimlig strängrepresentation returnerar vanligtvis någon identifierare eller felsökningsinformation om typen av klass. De som har en rimlig strängrepresentation, till exempel en talsträng från ett Integer-objekt, returnerar textföreställningen av det inkapslade numret. När det sammanfogas med en sträng, såsom med plusoperatören (+) som beskrivits ovan, används toString () -metodresultaten som standard. Till exempel:
Heltal iNum = nytt heltal (123); String sText = "Nummeret en-två-tre ="; String sFullText = sText + iNum; String sFullText2 = sText + iNum.toString ();
Både strängarna (sFullText och sFullText2) har samma värde, "nummer ett-två-tre = 123". Många sådana föremål kan också fungera i omvänd. Det vill säga de kan analysera en strängrepresentation och konvertera den till den ursprungliga typen objektet representerar. För instace, igen med Integer-klassen, kan metoden parseInt () användas för att få ett nytt Integer-objekt baserat på strängrepresentationen.
Som du har sett kan strängar användas till stor effekt. Stringskapande och manipulering har emellertid vissa nackdelar. Oskälig strängmanipulation kan ha negativa resultatkonsekvenser för din ansökan. Det är en grundläggande designprincip för Java att inte skapa objekt du inte behöver. Du kan se att strängmanipulation och modifieringar kan resultera i många strängvariabler som flyter runt. Här är några tips för bra stränganvändning:
Strängar är en viktig datatyp som Android-utvecklare använder för att lagra textdata. Stringdata, oavsett om det är en sekvens av tecken, siffror, symboler eller en viss blandning av dem, kan lagras på olika sätt, men String-klassen är den primära verktygsklassen som används för detta ändamål. String-klassen, och det är hjälparklasser som StringBuilder, innehåller en robust uppsättning metoder för användning med strängar, tillåter innehållet att sökas eller modifieras.
Mobila utvecklare Lauren Darcey och Shane Conder har medverkat flera böcker om Android-utveckling: en fördjupad programmeringsbok med titeln Android Wireless Application Development och Sams TeachYourself Android Application Development inom 24 timmar. När de inte skriver, spenderar de sin tid på att utveckla mobil mjukvara hos sina företag och tillhandahålla konsulttjänster. De kan nås via e-post till [email protected], via deras blogg på androidbook.blogspot.com, och på Twitter @ androidwireless.
