Detaillierte Einführung in die Java API (mit Beispielen)

Dieser Artikel bietet Ihnen eine detaillierte Einführung in die Java-API (mit Beispielen). Freunde in Not können darauf verweisen.

Einführung:

Die sogenannte API sind einige Klassenbibliotheken, die geschrieben wurden und direkt aufgerufen werden können. Java API mit leistungsstarken Funktionen und befindet sich noch in der Entwicklung.

Rufen Sie zuerst das Java-Hilfedokument online auf, entpacken Sie es dann und suchen Sie die entsprechende API.

Einführung in das allgemeine Java-Paket:

• java.lang bietet grundlegende Klassen für die Programmierung mit der Programmiersprache Java.

• Java bis Enthält das Sammlungsframework, Legacy-Sammlungsklassen, Ereignismodell, Datums- und Zeitfunktionen, Internationalisierung und verschiedene Dienstprogrammklassen.

• Java io bietet Systemeingabe und -ausgabe über Datenströme, Serialisierung und Dateisysteme.

• Java-Applet stellt die Klassen bereit, die zum Erstellen eines Applets erforderlich sind, und die Klassen, die das Applet zur Kommunikation mit anderen Applet-Kontexten verwendet,

• java awt enthält alle Klassen, die zum Erstellen von Benutzeroberflächen und zum Zeichnen von Grafiken verwendet werden.

• Java Beans enthält Klassen im Zusammenhang mit der Entwicklung von Beans, also Komponenten, die auf der JavaBeans-Architektur basieren.

• Java Math bietet Klassen für die Durchführung von Ganzzahlarithmetik mit beliebiger Genauigkeit (BigInteger) und Dezimalarithmetik mit beliebiger Genauigkeit (BigDecimal).
  

• Java Net bietet Klassen zur Implementierung von Netzwerkanwendungen.

• Java SQL bietet eine API, um mithilfe der Java-Programmiersprache auf Daten zuzugreifen und diese zu verarbeiten, die in einer Datenquelle (normalerweise einer relationalen Datenbank) gespeichert sind.

String-Klasse:

String-Klasse-Initialisierungsvorgang: Java bietet zwei Möglichkeiten, die String-Klasse zu initialisieren:

1 String-Konstanten direkt verwenden Initialisieren Sie ein String-Objekt, z. B. String name = "Zhang San"; 2 Verwenden Sie die String-Konstruktionsmethode, um das String-Objekt zu initialisieren, z. B.

Zum Beispiel:

public static void main(String[] args){
    String s1 =new String();//创建空字符串
    String s2 = new String("张三")//创建一个内容为张三的字符串
    char[] charArray = new char[]{'A','B','C'};
    String s3 = new String(charArray);
    System.out.println(s1);
    System.out.println(s2);
    System.out.println(s3);

}

Gemeinsame Methoden der Sring-Klasse:

Grundlegende String-Operation:

public static void main(String[] args) {
String s ="abcdefhckoj";//声明字符串
System.out.println("字符串的长度为:"+s.length());//获取字符串长度， 即字符个数
System.out.println("字符串第一个字符:"+s.charAt(0));
System.out.println("字符c第一次出现的位置:"+s.indexOf('c'));
System.out.println("字符c最后一次出现的位置:"+s.lastIndexOf('c'));
}

Konvertierung von String und Array:

public class Demo{
    public static void main(String[] args){
    String s = "abcdesgs";//声明一个字符串
    System.out.println("将此字符串装换为数组");
    char [] charArray = s.toCharArray();//字符串转换为字符数组。
    System.out.println("[);
    for(int i=0;i,charArray.length;i++){
          if(i !=charArray.length-1);
         Syetem.out.println(charArray[i]+",");
             //判断是否是数组最后一个元素，如果不是则在后面添逗号码
    }else{
        //否则 数组最后一个元素不加逗号。
 
       Syetem.out.println(charArray[i]+"]");
}
}
        Syetem.out.println("将Int 类型转换为String 类型:" +String.valueOf(20));
}
}

String-Beurteilungsoperationen:

public static void main(String[] args) {
String str1 = "abcdsg";//声明一个字符串
String str2 = "adc";
System.out.println("判断是否以字符串abc开头:"+str1.startsWith("abc"));
System.out.println("判断是否以字符串sg结尾:"+str1.endsWith("sg"));
System.out.println("判断是否包含字符串ds:"+str2.contains("ds"));
System.out.println("判断是否为空:"+str1.isEmpty());
System.out.println("判断两个字符串是否相等"+str1.equals(str2));

Abfangen und Segmentieren von Strings
String-Klasse bietet zwei Methoden zum Abfangen und Segmentieren von Strings, darunter den Teilstring Die Methode () wird verwendet, um einen Teil der Zeichenfolge abzufangen, und die Methode split () kann die Zeichenfolge entsprechend einem bestimmten Zeichen aufteilen.

package com.project.demo;

public class Test {
         public static void main(String[] args) {
            String string = "张三-李四-王五"; 
            //截取字符串
            System.out.println("从第4个字符截取到最后："+string.substring(3));
            System.out.println("从第3个字符截取到第6："+string.substring(2,6));
            // 字符串分割
            System.out.println("分割后的字符串数组元素依次是： ");
            String[] stringArray =string.split("-");//通过- 字符为标志，将其分割为字符串数组
            for(int i =0;i<stringArray.length;i++) {
                if(i != stringArray.length-1 ) {
                    System.out.println(stringArray[i]+",");
                    
                }else {
                    System.out.println(stringArray[i]);
                    System.out.println(string.length());
                }
                
            }
            
        }
}

So entfernen Sie Leerzeichen und ersetzen:

package com.project.demo;
public class Test {
         public static void main(String[] args) {
             String string = "    hello     word   ";
             //字符串替换操作
             System.out.println("将word 替换成java ："+string.replace("word", "java"));
             //字符串去空操作
             System.out.println("去除字符串两端的空格："+ string.trim());
             System.out.println("去除字符串中所有空格： "+string.replace(" ", ""));
             System.out.println("将小写转换为大写 ： " + string.toUpperCase());
         }
}

Zu beachten ist, dass String ein bestimmtes Zeichen annimmt Wenn beim Zugriff auf Zeichen in einer Zeichenfolge der Index des Zeichens nicht vorhanden ist, StringIndexOutOfBoundsException(String subscript out-of-boundsException)

StringBuffer:

Um die Änderung von Strings zu erleichtern, stellt JDK einen StringBuffer bereit Der größte Unterschied zwischen der StringBuffer-Klasse und der String-Klasse besteht darin, dass ihre Länge und ihr Inhalt einem String-Container ähneln. Beim Hinzufügen oder Löschen von Zeichen wird kein neues StringBuffer-Objekt erstellt generiert.

Werfen wir einen Blick auf die gängigen Methoden von StringBuffer in der API:

In Interviews werden wir oft nach dem Unterschied zwischen String, StringBuffer und StringBuilder gefragt??

Kurz gesagt , String-String-Konstante StringBuffer-String-Variable (Thread-sicher) StringBuilder-String-Variable (nicht Thread-sicher) Der Hauptleistungsunterschied zwischen String-Typ und StringBuffer-Typ besteht darin, dass String ein unveränderliches Objekt ist. Jedes Mal, wenn der String-Typ geändert wird, entspricht dies tatsächlich dem Generieren eines neuen String-Objekts und dem anschließenden Zeigen des Zeigers auf das neue String-Objekt. Daher ist es am besten, String nicht für Zeichenfolgen zu verwenden, deren Inhalt sich häufig ändert, da dies jedes Mal der Fall ist Das Generieren von Objekten wirkt sich auf die Systemleistung aus, insbesondere wenn zu viele nicht referenzierte Objekte im Speicher vorhanden sind. Der GC der JVM beginnt zu arbeiten und die Geschwindigkeit ist definitiv ziemlich langsam.

Wenn Sie die StringBuffer-Klasse verwenden, wird jedes Ergebnis auf das StringBuffer-Objekt selbst angewendet, anstatt ein neues Objekt zu generieren und dann die Objektreferenz zu ändern. Daher empfehlen wir im Allgemeinen die Verwendung von StringBuffer, insbesondere wenn sich String-Objekte häufig ändern. In einigen Sonderfällen wird die String-Verkettung von String-Objekten von der JVM tatsächlich als die Verkettung von StringBuffer-Objekten interpretiert, sodass in diesen Fällen die Geschwindigkeit von String-Objekten nicht langsamer ist als die von StringBuffer-Objekten, insbesondere die folgenden String-Objekte Unter ihnen ist die String-Effizienz viel schneller als bei StringBuffer:

 String S1 = “This is only a” + “ simple” + “ test”;

StringBuffer Sb = new StringBuilder(“This is only a”).append(“simple”).append(“test“); Sehr erfreut. Ich war überrascht, dass die Geschwindigkeit beim Generieren von String-S1-Objekten einfach zu hoch war und StringBuffer zu diesem Zeitpunkt tatsächlich überhaupt keinen Geschwindigkeitsvorteil hatte. Tatsächlich ist dies ein Trick der JVM. In den Augen der JVM lautet dieser String S1 = „Dies ist nur ein“ + „einfacher“ + „Test“; ”; also natürlich nicht. Es dauert zu lange.

Hier ist jedoch zu beachten, dass die Geschwindigkeit nicht so hoch ist, wenn Ihr String von einem anderen String-Objekt stammt, zum Beispiel:

String S2 = “This is only a”; String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;

这时候 JVM 会规规矩矩的按照原来的方式去做 在大部分情况下 StringBuffer > String StringBuffer Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。 可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。 StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。

例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。

在大部分情况下 StringBuilder > StringBuffer java.lang.StringBuilde java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

基本数据类型包装类：

何为包装类？

在java.lang包中有各种原生类相对应的类， 称作数值包装类。 这些类的名称， 大部分均以各原生类类型第一个字母换成大写的方式来命名 。简单的说就是将数据装换为对象，来应用更多的方法。 

包装类和基本数据类型在进行转换时，引入了装箱和拆箱的概念，其中装箱是指将基本数据类型的值转为引用数据类型， 反之， 拆箱是指将引用数据类型的对象转为基本数据类型。 

举个栗子：

方式一： 通过new关键字
Integer in = new Integer(5);
方式二： 直接赋值
Integer in = 5;

 构造函数可将原生数据类型数值或代表数值的字符串转换成一数值包装对象。

如： 在Double类中的构造函数
Double(double value)
Double(String s)
例：

Double tax=Double(8332349823.234);

 在数值包装类中所定义的方法， 最常用到的就是一些用来做字符串与数值间转换的方法。比如：

static float parseFloat(String s)
static Float valueof(String s)
static String toString(float f)
在使用包装类的时候我们需要注意一些问题.

1、 包装类都重写了Object类中的toString()方法，以字符串的形式返回被包装的基本数据类型的值；
2、 除了Character外， 包装类都有parseXXX(String s)的静态方法，将字符串转换为对应的基本类型的数据。 参数s不能为null， 而且同样必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会报错；
3、 除了Character外，包装类都有valueOf(String s)方法，可以根据String类型的参数创建包装类对象， 但参数字符串s不能为null，而且字符串必须是可以解析为相应基本类型的数据，否则虽然编译通过， 但运行时也会报错

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in die Java API (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!