[Java] API-Grundlagen

Persönliche Homepage: Hello Code.
Diese Artikelspalte: Java Zero Basic Guide
Für weitere verwandte Inhalte klicken Sie bitte, um zum Java Zero Basic Guide zu gehen, um es anzuzeigen
. Wenn Sie Fragen haben, korrigieren Sie mich bitte und lernen Sie gemeinsam ~~

---

---

Überblick

• API ( Application Programming Interface ) : Anwendungsprogrammierschnittstelle

Um ein Programm zur Steuerung des Fußballs zu schreiben, muss das Programm dem Roboter verschiedene Befehle erteilen, z. B. vorwärts laufen, rückwärts laufen, schießen und den Ball greifen. Roboterhersteller müssen einige Schnittstellenklassen zum Steuern von Robotern bereitstellen.Diese Klassen definieren die Methoden zum Manipulieren verschiedener Aktionen des Roboters. Tatsächlich sind diese Schnittstellenklassen die Schnittstellen, die von Roboterherstellern für die Anwendungsprogrammierung bereitgestellt werden, und diese Klassen werden APIs genannt.

• Tastatureingabezeichenfolge

Scanner sc = new Scanner();
System.out.print("请输入内容：");
String s = sc.nextLine(System.in);	//遇到回车、换行结束
//String s = sc.next(System.in);	//遇到空格、tab就停止
System.out.println(s);

Wenn beim Empfangen von Daten per Tastatureingabe die Zeichenfolge und die Ganzzahl zusammen empfangen werden, wird empfohlen, die nächste Methode zum Empfangen der Zeichenfolge zu verwenden

---

String-Klasse

• Überblick: Die String-Klasse befindet sich unter dem java.lang -Paket und muss bei der Verwendung nicht importiert werden.
  Die Klasse String repräsentiert Strings, und alle String-Literale (zB: "abc") in Java-Programmen sind als Methoden dieser Klasse implementiert

Strings sind Konstanten, ihr Wert kann nach der Erstellung nicht geändert werden

• Gängige Konstruktionsmethoden
  public String()Erzeuge ein leeres String-Objekt ohne Inhalt Erzeuge einen String gemäß
  public String(char[] chs)dem Inhalt des Zeichen-Arrays Erzeuge ein String-Objekt
  public String(String original)gemäß dem eingehenden String-Inhalt Erzeuge ein String-Objekt
  String s = "abc";durch direkte Zuweisung, der Inhalt ist abc

String stellt eine besondere Klasse dar. Beim Drucken seines Objektnamens erscheint nicht die Speicheradresse, sondern der tatsächliche Inhalt, der vom Objekt aufgezeichnet wird.

• Der Unterschied zwischen dem Erstellen eines Zeichenfolgenobjekts und dem Vergleichen
  der Zeichenfolge, die auf die Weise "" angegeben ist, solange die Zeichenfolge dieselbe ist (Reihenfolge und Groß-/Kleinschreibung), egal wie oft sie im Programmcode vorkommt, erstellt die JVM nur B. ein String-Objekt, und im String Maintained in Constant Pool

String-Konstantenpool: bei VerwendungWenn doppelte Anführungszeichen ein Zeichenfolgenobjekt erstellen, wird das SystemÜberprüfen Sie, ob die Zeichenfolge im Zeichenfolgenkonstantenpool vorhanden ist. Existiert sie nicht, wird sie angelegt, existiert sie, wird sie nicht neu angelegt und direkt verwendet
Hinweis: Der String-Konstanten-Pool wurde seit JDK7 aus dem Methodenbereich in den Heap-Speicher verschoben
Erweiterung: ==Werte vergleichen beim Vergleich von Basisdatentypen und beim Vergleich von Referenzdatentypen Vergleichen, wenn Adressen gleich sind

Ein von new erzeugtes String-Objekt belegt jedes Mal einen Speicherplatz new, obwohl der Inhalt derselbe ist, aber der Adresswert unterschiedlich ist

• Features:
  Alle doppelten Anführungszeichen in Java-Programmen sind Objekte der String-Klasse.
  Strings sind unveränderlich und ihre Werte können nach der Erstellung nicht geändert werden
  . Obwohl String-Werte unveränderlich sind, können sie geteilt werden

Wenn + zwischen Strings gespleißt wird, erstellt die unterste Schicht des Systems automatisch ein StringBuilder-Objekt
und ruft dann seine Append-Methode auf, um das Spleißen abzuschließen
. Rufen Sie nach dem Spleißen die toString-Methode auf, um sie in den String-Typ zu konvertieren.

• String-Vergleich
  String ist ein Objekt. Es vergleicht, ob der Inhalt gleich ist oder nicht. Es wird durch eine Methode implementiert. Diese Methode heißt:equals()

public boolean equals(Object anObject) : Vergleicht diesen String mit dem angegebenen Objekt. Da wir String > String-Objekte vergleichen, wird ein String zwischen den Parametern übergeben

String s1 = "abc";
String s2 = "ABC";
s1.equals(s2);		//false
//equalsIgnoreCase()方法比较字符串不区分大小写
s1.equalsIgnoreCase(s2);		//true	

• Fall

// 需求：已知用户名和密码，请用程序实现模拟用户登录，总共给三次机会，登录之后，给出相应的提示
import java.util.Scanner;
public class Test{
    
    
	public static void main(String[] args){
    
    
		String userName = "abcde";
		String passWord = "abc666";
		int count = 0;
		Scanner sc = new Scanner(System.in);
		for(int i = 0; i < 3; i++){
    
    
			System.out.print("请输入用户名：");
			String user = sc.nextLine();
			System.out.print("请输入密码：");
			String pass = sc.nextLine();
			if(userName.equals(user) && passWord.equals(pass)){
    
    
				System.out.println("恭喜您，登录成功！");
				break;
			}else{
    
    
				System.out.println("账号或密码错误，请重试");
				count++;
				}
		}
		if(count >= 3) System.out.println("登录失败次数过多，请稍后重试");
	}
}

// 需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串，将字符串拆分为字符数组
// public char charAt(int index):返回指定索引处的char值，字符串的索引也是从0开始的
// public int length():返回此字符串的长度
// public char[] toCharArray():将当前字符串拆分为字符数组并返回
import java.util.Scanner;
public class Test{
    
    
	public static void main(String[] args){
    
    
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入字符串：");
		String s = sc.nextLine();
		/*
		for(int i = 0; i < s.length(); i++){
			System.out.print(s.charAt(i) + " ");
		}
		*/
		char[] chars = s.toCharArray();
		for(int i = 0; i < chars.length; i++){
    
    
			System.out.print(chars[i] + " ");
		}
	}
}

//需求： 键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数（不考虑其他字符）
import java.util.Scanner;
public class Test{
    
    
	public static void main(String[] args){
    
    
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入字符串：");
		String s = sc.nextLine();
		char[] chars = s.toCharArray();
		int num = 0;
		int english = 0;
		int English = 0;
		for(int i = 0; i < chars.length; i++){
    
    
			if(chars[i] >= '0' && chars[i] <= '9') num++;
			else if(chars[i] >= 'a' && chars[i] <= 'z') english++;
			else if(chars[i] >= 'A' && chars[i] <= 'Z') English++;
		}
		System.out.println("数字：" + num + " 小写字母：" + english + " 大写字母:" + English);
	}
}

// 需求：以字符串的形式从键盘接收一个手机号，将中间四位号码屏蔽
// 最终效果：183****4828
/*
截取字符串：
	String substring(int beginIndex):
		从传入的索引位置处，向后截取，一直截取到末尾，得到新的字符串并返回
	String substring(int beginIndex, int endIndex):
		从beginIndex索引位置开始截取，截取到endIndex索引位置，得到新的字符串并返回（含头不含尾）
  */
import java.util.Scanner;
public class Test{
    
    
	public static void main(String[] args){
    
    
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入手机号：");
		String s = sc.nextLine();
		String begin = s.substring(0, 3);
		String end = s.substring(7, 11);
		System.out.println("最终手机号为：" + begin + "****" + end);
	}
}

// 需求：键盘录入一个字符串，如果字符串中包含（TMD），则使用***替换
/*
String replace(CharSequence target, CharSequence replacement)
	将当前字符串中的target(被替换的旧值)内容，使用replacement(替换的新值)进行替换
	返回新的字符串
*/
import java.util.Scanner;
public class Test{
    
    
	public static void main(String[] args){
    
    
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入内容：");
		String s = sc.nextLine();
		String result = s.replace("TMD", "***");
		System.out.println("您输入的内容为：" + result);
	}
}

// 需求：以字符串的形式从键盘录入学生信息，例如："张三,23"从该字符串中切割出有效数据，封装为Student学生对象
// String[] split(String regex):根据传入的字符作为规则进行切割，将切割后的内容存入字符串数组中，并将字符串返回(数组)

// 新建一个Student类
public class Student{
    
    
	private String name;
	private String age;
	public Student(){
    
    }
	public Student(String name, String age){
    
    
		this.name = name;
		this.age = age;
	}
	public String getName(){
    
    
		return name;
	}
	public void setName(String name){
    
    
		this.name = name;
	}
	public String getAge(){
    
    
		return age;
	}
	public void setAge(String age){
    
    
		this.age = age;
	}
}
  
  //---------------------------下面为一个新的class文件----------------------------------------------
  
import java.util.Scanner;
public class Test{
    
    
	public static void main(String[] args){
    
    
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入您的信息：");
		String stuInfo = sc.nextLine();
		String[] sArr = stuInfo.split(",");
		Student stu = new Student(sArr[0], sArr[1]);
		System.out.println("姓名：" + stu.getName() + " 年龄：" + stu.get)
	}
}

---

StringBuilder

• Übersicht: StringBuilder ist eine veränderliche String-Klasse, wir können sie uns als Container vorstellen
• Rolle: Verbesserung der Effizienz von String-Operationen
• Konstruktor:
  public StringBuilder()Erstellen Sie ein leeres änderbares Zeichenfolgenobjekt, das keinen Inhalt enthält. Erstellen Sie ein änderbares Zeichenfolgenobjekt
  public StringBuilder(String str)basierend auf dem Inhalt der Zeichenfolge
• Gängige Methode:

  Methodenname	veranschaulichen
  öffentliches StringBuilder-Anhängen (beliebiger Typ)	Daten hinzufügen und das Objekt selbst zurückgeben
  öffentlicher StringBuilder reverse()	Gibt die umgekehrte Zeichenfolge zurück
  öffentliche Ganzzahllänge()	Gibt die Länge zurück (Anzahl der Vorkommen von Zeichen)
  öffentlicher String toString()	Konvertieren Sie StringBuilder in String durch toString()

StringBuilder sb = new StringBuilder();
//链式编程：如果一个方法返回的是对象类型，对象就可以继续向下调用方法
sb.append("red").append("blue").append("green");

• StringBuilder verbessert das Effizienzprinzip:

wannSchnurWenn der Typ-String mit + gespleißt wird, erstellt das System standardmäßig einen neuen im Heap-Speicher.StringBuilderGeben Sie object ein, schließen Sie das Spleißen mit der Methode append() ab und übergeben Sie danntoString()Konvertieren Sie den StringBuilder-Typ in den String-Typ.
Die Verwendung von StringBuilder spart unnötige Schritte

• Fall

// 需求：键盘接收一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是
// 对称字符串：123321、111			非对称字符串：123123
import java.util.Scanner;
	public class Test{
    
    
		public static void main(String[] args){
    
    
			Scanner sc = new Scanner(System.in);
			System.out.print("请输入内容：");
			String s = sc.nextLine();
			StringBuilder ss = new StringBuilder(s);
			String sss = ss.reverse().toString();
			if(s.equals(sss)){
    
    
				System.out.println("是");
			}else{
    
    
				System.out.println("不是");
			}
		}
	}

// 需求：定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。
// 例如：数组为：int[] arr = {1, 2, 3};	执行方法后的输出结果为：[1,2,3]
public static void main(String[] args){
    
    
	int[] arr = {
    
    1, 2, 3};
	String s = arrayToString(arr);
	System.out.println(s);
}
// 定义一个方法，返回值类型 String ，参数列表int[] arr
public static String arrayToString(int[] arr){
    
    
	StringBuilder sb = new StringBuilder("【");
	for(int i = 0; i < arr.length; i++){
    
    
		if(i == arr.length - 1){
    
    
			sb.append(arr[i]).append("】");
		}else{
    
    
			sb.append(arr[i]).append(",");
		}
	}
	return sb.toString();
}

---

Empfohlene Lektüre: Java Collections Fundamentals