Cet article vous apporte une introduction détaillée à l'API Java (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.
Introduction :
Les soi-disant API sont des bibliothèques de classes qui ont été écrites et peuvent être appelées directement. Java API avec des fonctionnalités puissantes , et est toujours en développement.
Obtenez d'abord le document d'aide Java en ligne, puis décompressez-le et recherchez l'API correspondante.
Introduction au package commun Java :
java.lang fournit des cours de base pour la programmation à l'aide du langage de programmation Java.
java jusqu'à Contient le cadre de collection, les classes de collection héritées, le modèle d'événement, les installations de date et d'heure, l'internationalisation et diverses classes d'utilitaires.
java io fournit des entrées et des sorties système via des flux de données, la sérialisation et les systèmes de fichiers.
L'applet Java fournit les classes nécessaires pour créer une applet et les classes que l'applet utilise pour communiquer avec d'autres contextes d'applet,
java awt contient toutes les classes utilisées pour créer des interfaces utilisateur et dessiner des images graphiques.
les java beans contiennent des classes liées au développement de beans, c'est-à-dire des composants basés sur l'architecture javaBeans.
java math fournit des cours pour effectuer l'arithmétique entière de précision arbitraire (BigInteger) et l'arithmétique décimale de précision arbitraire (BigDecimal).
Java net propose des cours pour la mise en œuvre d'applications réseau.
java sql fournit une API permettant d'utiliser le langage de programmation Java pour accéder et traiter les données stockées dans une source de données (généralement une base de données relationnelle).
Opération d'initialisation de la classe String : Java propose deux façons d'initialiser la classe String,
1 Utiliser directement les constantes de chaîne initialiser un objet String, tel que String name = "Zhang San"
2 Utilisez la méthode de construction String pour initialiser l'objet chaîne, tel que
| 方法 | 含义 |
| String () | 创建一个内容为空的字符串 |
| Stirng (String value) | 根据指定的字符串内容创建对象 |
| String (char[] value) | 根据指定的字符数组创建对象 |
Par exemple :
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);
}
Méthodes courantes de la classe Sring :
caractères Opérations de base sur les chaînes :
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'));
}
Conversion de chaînes et de tableaux :
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));
}
}
Opération de jugement de chaîne :
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));
Interception et segmentation de chaîne
Paire de classes de chaîne Deux méthodes sont fournies pour intercepter et diviser des chaînes. La méthode substring() est utilisée pour intercepter une partie de la chaîne, et la méthode split() peut diviser la chaîne en fonction d'un certain caractère.
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());
}
}
}
}
Pour supprimer des espaces et remplacer :
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());
}
}
Une chose à noter est que String est en cours de récupération Lors de l'accès à un caractère, l'index du caractère (index d'indice du tableau) sera utilisé Lors de l'accès aux caractères de la chaîne, si l'index du caractère n'existe pas, StringIndexOutOfBoundsException(String Under Mark). exception hors limites )
Afin de faciliter la modification des chaînes, JDK fournit une classe StringBuffer (également appelée tampon de caractères). La plus grande différence entre la classe StringBuffer et la classe String est que sa longueur et son contenu sont différents. La variable StringBuffer est similaire à un conteneur de chaîne, lorsque des caractères sont ajoutés ou supprimés, aucun nouvel objet StringBuffer n'est généré.
Jetons un coup d'œil aux méthodes courantes de StringBuffer dans l'API :
Lors des entretiens, on nous demande souvent la différence entre String, StringBuffer et StringBuilder ??
En bref , Constante de chaîne String Variable de chaîne StringBuffer (thread-safe) Variable de chaîne StringBuilder (non thread-safe) La principale différence de performances entre le type String et le type StringBuffer est que String est un objet immuable, donc chaque fois que le type String est modifié, cela équivaut en fait à générer un nouvel objet String, puis à pointer le pointeur vers le nouvel objet String. Il est donc préférable de ne pas utiliser String pour les chaînes dont le contenu change fréquemment, car à chaque fois c'est le cas. Les objets générés auront un impact sur les performances du système, surtout lorsqu'il y a trop d'objets non référencés dans la mémoire, le GC de la JVM commencera à fonctionner et la vitesse sera certainement assez lente.
Si vous utilisez la classe StringBuffer, chaque résultat fonctionnera sur l'objet StringBuffer lui-même, au lieu de générer un nouvel objet puis de changer la référence de l'objet. Donc, en général, nous recommandons d'utiliser StringBuffer, en particulier lorsque les objets chaîne changent fréquemment. Dans certains cas particuliers, la concaténation de chaînes d'objets String est en fait interprétée par la JVM comme la concaténation d'objets StringBuffer, donc dans ces cas, la vitesse des objets String ne sera pas plus lente que celle des objets StringBuffer, et en particulier les objets chaîne suivants sont généré Parmi eux, l'efficacité de String est beaucoup plus rapide que StringBuffer :
String S1 = “This is only a” + “ simple” + “ test”;
StringBuffer Sb = new StringBuilder("This is only a").append("simple").append("test you"); Vous serez surpris de constater que la vitesse de génération des objets String S1 est tout simplement trop rapide et qu'à l'heure actuelle, StringBuffer n'a aucun avantage en termes de vitesse. En fait, c'est une astuce de la JVM. Aux yeux de la JVM, cette String S1 = « Ceci n'est qu'un » + « simple » + « test » est en fait : String S1 = « Ceci n'est qu'un simple test » ; » ; donc bien sûr que non. Cela prend trop de temps.
Mais ce qu'il faut noter ici, c'est que si votre chaîne provient d'un autre objet String, la vitesse ne sera pas si rapide, par exemple :
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包中有各种原生类相对应的类， 称作数值包装类。 这些类的名称， 大部分均以各原生类类型第一个字母换成大写的方式来命名 。简单的说就是将数据装换为对象，来应用更多的方法。
| boolean | Boolean |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Chracter |
| float | Float |
| double | Double |
包装类和基本数据类型在进行转换时，引入了装箱和拆箱的概念，其中装箱是指将基本数据类型的值转为引用数据类型， 反之， 拆箱是指将引用数据类型的对象转为基本数据类型。
举个栗子：
方式一： 通过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，而且字符串必须是可以解析为相应基本类型的数据，否则虽然编译通过， 但运行时也会报错
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!