Java-Lernen – Blog 5

Language 2023-06-05 20:07:38 views: null

Inhaltsverzeichnis

Gemeinsame Utility-Klassen

String-Klasse

Zeichenfolge erstellen

String-Länge

Verbindungszeichenfolge

Gängige Methoden von String

StringTokenizer-Klasse

Methode

Detaillierte Analyse

Scannerklasse

Der Unterschied zwischen next() und nextLine()

StringBuffer-Klasse

StringBuffer-Methode

Datumsklasse und Kalenderklasse

Date-Klasse

Kalenderklasse

Austausch zwischen Kalenderobjekt und Datumsobjekt

Konvertierung zwischen Datums- und Kalenderobjekten

Datumsformatierung

DateFormat-Klasse

SimpleDateFormat-Klasse

Mathe-Klasse, BigInteger-Klasse und Random-Klasse

Matheunterricht

BigInteger-Klasse

Zufällige Klasse

Zahlenformatierung

NumberFormat repräsentiert die Formatierungsklasse von Zahlen

DecimalFormat formatiert Zahlen

ChoiceFormat formatiert Zahlen

Klassenklasse und Konsolenklasse (noch hinzuzufügen)

Klasse

Konsolenklasse

Musterklasse und Matcher-Klasse

Überblick

Musterklasse

Matcher-Klasse

Wissenszusammenfassung

Referenz

Gemeinsame Utility-Klassen

  • String-Klasse

Zeichenfolge erstellen

Abschlussklasse, nicht verlängerbar

1. Konstantes Objekt: Legen Sie es in den konstanten Pool

"Hallo"

2.String- Objekt: dynamischer Bereich, nicht konstanter Pool, Heap

String s = new String("Hello");//s speichert die Referenz

Konstruktionsmethode:

Von String erstellte Zeichenfolgen werden im öffentlichen Pool gespeichert, während von new erstellte Zeichenfolgenobjekte auf dem Heap liegen:

char a[]={'J','A','V','A'};

String s = new String(a);

oder

String s = new String(a,0,1);//J

3. Referenzieren Sie das konstante Objekt

Zeichenfolge s,s2;

s = "Hallo";

s2 = „Hallo“;

s, s2 haben die gleiche Referenz s==s2 ist wahr

Tipps: Die String-Klasse ist unveränderlich. Sobald Sie also ein String-Objekt erstellt haben, kann sein Wert nicht mehr geändert werden.

Wenn Sie viele Änderungen an der Zeichenfolge vornehmen müssen, sollten Sie sich für die Verwendung  der Klassen StringBuffer und StringBuilder entscheiden .

String-Länge

Methoden zum Abrufen von Informationen über ein Objekt werden als Zugriffsmethoden bezeichnet.

Eine der Zugriffsmethoden der String-Klasse ist die Methode length(), die die Anzahl der Zeichen zurückgibt, die ein String-Objekt enthält.

public class StringDemo {
    public static void main(String args[]) {
        String site = "www.CSDN.net";
        int len = site.length();
        System.out.println( "网址长度 : " + len );//    len=12
   }
}

Verbindungszeichenfolge

Die String-Klasse stellt Methoden zum Verketten zweier Strings bereit:

(1)string1.concat(string2);

Gibt eine neue Zeichenfolge aus Zeichenfolge2 zurück, die mit Zeichenfolge1 verkettet ist. Sie können die concat()-Methode auch für String-Konstanten verwenden, wie zum Beispiel:

„Mein Name ist“.concat(“CSDNxiaowang“);

(2) Es ist üblicher, den Operator „+“ zum Verbinden von Zeichenfolgen zu verwenden, z. B.:

„Hallo“, + „CSDNxiaowang“ + „!“

Ergebnis: „Hallo, CSDNxiaowang!“

Gängige Methoden von String

public int length();
public bolean equals();
public boolean startsWith(String s);
public int compare(String s）
public Booleancontains(String s)
public int indexOf(String s)/lastIndexOf(String s）
public String subString（int start,int end）
public String trim()
public void getChars(int start,int end,cha ch[],int offset)//将当前String对象字符串序列一部分复制到c数据中
public char[] toCharArray()
public byte[] getBytes(String charsetName)//使用参数指定字符编码

 Einzelheiten finden Sie unter: String (Java SE 11 & JDK 11) (runoob.com)

  • StringTokenizer-Klasse

StringTokenizer ist eine Anwendungsklasse, die zum Trennen von Strings verwendet wird.

Methode

1. Konstrukteur

  • public StringTokenizer(String str)
  • public StringTokenizer(String str, String delim)
  • public StringTokenizer(String str, String delim, boolean returnDelims)

Der erste Parameter ist die zu trennende Zeichenfolge, der zweite ist der Satz von Trennzeichen und der dritte Parameter gibt an, ob das Trennzeichen als Token zurückgegeben wird. Wenn kein Trennzeichen angegeben wird, lautet der Standardwert: „\t\n“. \r\f"

Tipps: Jede Kombination von durch Trennzeichen getrennten Token ist immer noch durch Trennzeichen getrennte Token
2. Kernmethode

  • öffentlicher boolescher Wert hasMoreTokens()
  • öffentlicher String nextToken()
  • public String nextToken(String delim)
  • public int countTokens()

Tatsächlich gibt es drei Methoden: Bei der Rückgabe des durch Trennzeichen getrennten Zeichenblocks kann auch das Trennzeichen angegeben werden, und das zuletzt angegebene Trennzeichen wird in Zukunft verwendet.
3. Redundante Methoden

  • öffentlicher boolescher Wert hasMoreElements()
  • öffentlicher boolescher Wert hasMoreElements()

Diese Klasse implementiert die Enumeration-Schnittstelle, daher gibt es zwei weitere Methoden. Tatsächlich besteht keine Notwendigkeit, diese Schnittstelle zu implementieren.
Ihr Name ist StringTokenizer und die Rückgabe eines Objekts ist bedeutungslos.

Gehört zu: Java .util-Paket.

Detaillierte Analyse

1. Konstrukteur.

  • StringTokenizer(String str): Konstruieren Sie ein StringTokenizer-Objekt zum Parsen von str. Die Java-Standardtrennzeichen sind „Leerzeichen“, „Tab (‘\t‘)“, „Neue Zeile (‘\n‘)“, „Wagenrücklauf (‘\r‘)“.
  • StringTokenizer(String str, String delim): Konstruieren Sie ein StringTokenizer-Objekt zum Parsen von str und stellen Sie ein angegebenes Trennzeichen bereit.
  • StringTokenizer(String str, String delim, boolean returnDelims): Konstruieren Sie ein StringTokenizer-Objekt zum Parsen von str, geben Sie ein angegebenes Trennzeichen an und geben Sie an, ob das Trennzeichen zurückgegeben werden soll.

2. Methode.
Hinweis:
1. Alle Methoden sind öffentlich;
2. Schreibformat: [Modifikator] <Rückgabetyp><Methodenname ([Parameterliste])>

Ein StringTokenizer-Objekt wird als String-Analysator bezeichnet. Der String-Analysator verwendet die Methode nextToken(), um nacheinander die Sprachsymbole (Wörter) in der Zeichenfolge abzurufen. Bei jedem Aufruf von nextToken() wird die nächste Sprache im Zeichenfolgensymbol abgerufen Sobald ein Sprachsymbol abgerufen wird, wird der Wert der Variablen, für deren Zählung der String-Analysator verantwortlich ist, automatisch um eins dekrementiert, und der Anfangswert der Zählvariablen entspricht der Anzahl der Wörter in der Zeichenfolge

Normalerweise wird eine While-Schleife verwendet, um Sprachtoken einzeln abzurufen. Um die Schleife zu steuern, können Sie die Methode hasMoreTokens() in der StringTokenizer-Klasse verwenden. Solange die Zeichenfolge Sprachtoken enthält, d. h Wenn der Wert der Zählvariablen größer als 0 ist, gibt diese Methode „true“ zurück, andernfalls ist sie „false“.

wie:

  • static int parseInt(String s) bedeutet: Diese Methode (parseInt) ist eine Klassenmethode (statisch), der Rückgabetyp ist (int) und die für die Methode erforderlichen Parameter sind vom Typ String.
  • 1. int countTokens(): gibt die Häufigkeit zurück, mit der die nextToken-Methode aufgerufen wird. Bei Verwendung der Konstruktoren 1 und 2 wird die Anzahl der Trennzeichen zurückgegeben (Beispiel 2).
  • 2. boolean hasMoreTokens(): Gibt zurück, ob es weitere Trennzeichen gibt.
  • 3. boolean hasMoreElements(): Das Ergebnis ist das gleiche wie 2.
  • 4. String nextToken(): Gibt den String von der aktuellen Position bis zum nächsten Trennzeichen zurück.
  • 5. Objekt nextElement(): Das Ergebnis ist das gleiche wie 4.
  • 6. String nextToken(String delim): Geben Sie ähnlich wie 4 das Ergebnis mit dem angegebenen Trennzeichen zurück.

Zum Beispiel:

String s = new String("The=Java=platform=is=the=ideal=platform=for=network=computing");
StringTokenizer st = new StringTokenizer(s,"=",true);
System.out.println( "Token Total: " + st.countTokens() );
while( st.hasMoreElements() ){
System.out.println( st.nextToken() );}
/*
结果为：
Token Total: 19
The
=
Java
=
platform
=
is
=
the
=
ideal
=
platform
=
for
=
network
=
computing
*/

  • Scannerklasse

Importpaket des Scanners

import java.util.Scanner;

Verwenden Sie reguläre Ausdrücke als Split-Token

Scanner scanner = new Scanner(“你好“);
s.useDelimiter(”[^012456789.]+");

Im Folgenden finden Sie die grundlegende Syntax zum Erstellen eines Scannerobjekts :

Scanner s = new Scanner(System.in);

Als Nächstes demonstrieren wir die einfachste Dateneingabe und erhalten die Eingabezeichenfolge über die Methoden next () und nextLine () der Scanner-Klasse. Vor dem Lesen müssen wir im Allgemeinen hasNext und hasNextLine verwenden, um festzustellen, ob Eingabedaten vorhanden sind:

        //    使用next方法
import java.util.Scanner; 
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
 
        // next方式接收字符串
        System.out.println("next方式接收：");
        // 判断是否还有输入
        if (scan.hasNext()) {
            String str1 = scan.next();
            System.out.println("输入的数据为：" + str1);
        }
        scan.close();
    }
}
/*
执行以上程序输出结果为：

$ javac ScannerDemo.java
$ java ScannerDemo
next方式接收：
runoob com
输入的数据为：runoob
*/
        //    使用nextLine方法
import java.util.Scanner;
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
 
        // nextLine方式接收字符串
        System.out.println("nextLine方式接收：");
        // 判断是否还有输入
        if (scan.hasNextLine()) {
            String str2 = scan.nextLine();
            System.out.println("输入的数据为：" + str2);
        }
        scan.close();
    }
}
/*
执行以上程序输出结果为：

$ javac ScannerDemo.java
$ java ScannerDemo
nextLine方式接收：
runoob com
输入的数据为：runoob com

*/

Der Unterschied zwischen next() und nextLine()

nächste():

  • 1. Achten Sie darauf, gültige Zeichen zu lesen, bevor Sie die Eingabe beenden.
  • 2. Die next()-Methode entfernt automatisch Leerzeichen, die vor der Eingabe gültiger Zeichen auftreten.
  • 3. Erst nachdem gültige Zeichen eingegeben wurden, wird das dahinter eingegebene Leerzeichen als Trennzeichen oder Endzeichen verwendet.
  • next() kann keine Zeichenfolge mit Leerzeichen abrufen.

nächste Zeile():

  • 1. Verwenden Sie die Eingabetaste als Endzeichen. Das heißt, die Methode nextLine () gibt alle Zeichen vor dem Wagenrücklauf zurück.
  • 2. Rohling kann erhalten werden.

Wenn Sie Daten vom Typ int oder float eingeben möchten, wird dies auch in der Scanner-Klasse unterstützt. Es ist jedoch besser, vor der Eingabe die Methode hasNextXxx () zur Überprüfung zu verwenden und dann nextXxx () zum Lesen zu verwenden.

  • StringBuffer-Klasse

Wenn Sie Zeichenfolgen ändern, müssen Sie die Klassen StringBuffer und StringBuilder verwenden.

Im Gegensatz zur String-Klasse können Objekte der StringBuffer- und StringBuilder-Klassen mehrmals geändert werden, ohne dass neue unbenutzte Objekte erstellt werden.

Bei Verwendung der StringBuffer-Klasse wird jedes Mal das StringBuffer-Objekt selbst bearbeitet, anstatt ein neues Objekt zu generieren. Wenn Sie also die Zeichenfolge ändern müssen, wird empfohlen, StringBuffer zu verwenden.

Die StringBuilder-Klasse wurde in Java 5 vorgeschlagen. Der größte Unterschied zwischen ihr und StringBuffer besteht darin, dass die Methoden von StringBuilder nicht threadsicher sind (nicht synchron auf sie zugegriffen werden kann).

Da StringBuilder gegenüber StringBuffer einen Geschwindigkeitsvorteil hat, wird in den meisten Fällen die Verwendung der StringBuilder-Klasse empfohlen.

Wenn die Anwendung jedoch Thread-Sicherheit erfordert, muss die StringBuffer-Klasse verwendet werden.

StringBuffer-Methode

Im Folgenden sind die wichtigsten Methoden aufgeführt, die von der StringBuffer-Klasse unterstützt werden:

Seriennummer Methodenbeschreibung
1 public StringBuffer append(String s)
Hängt die angegebene Zeichenfolge an diese Zeichenfolge an.
2 public StringBuffer reverse()
 Ersetzt diese Zeichenfolge durch ihre umgekehrte Form.
3 public delete(int start, int end)
Entfernt Zeichen in Teilzeichenfolgen dieser Sequenz.
4 public insert(int offset, int i)
Fügt  int die String-Darstellung des Arguments in diese Sequenz ein.
5 insert(int offset, String str)
fügt  str den String des Arguments in diese Sequenz ein.
6

replace(int start, int end, String str)  Ersetzt Zeichen in Teilzeichenfolgen dieser Sequenz durch Zeichen in gegeben
. String

In der folgenden Liste sind weitere häufig verwendete Methoden der StringBuffer-Klasse aufgeführt:

Seriennummer Methodenbeschreibung
1 int Capacity()
gibt die aktuelle Kapazität zurück.
2 char charAt(int index)
Gibt den Wert am angegebenen Index in dieser Sequenz zurück  char .
3 void secureCapacity(int minimumCapacity)
stellt sicher, dass die Kapazität mindestens dem angegebenen Minimum entspricht.
4 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
Kopiert Zeichen aus dieser Sequenz in das Ziel-Zeichenarray  dst.
5 int indexOf(String str)
Gibt den Index innerhalb dieser Zeichenfolge des ersten Vorkommens der angegebenen Teilzeichenfolge zurück.
6 int indexOf(String str, int fromIndex)
Gibt den Index des ersten Vorkommens der angegebenen Teilzeichenfolge in der Zeichenfolge zurück, beginnend mit dem angegebenen Index.
7 int lastIndexOf(String str)
gibt den Index innerhalb dieser Zeichenfolge des ganz rechten Vorkommens der angegebenen Teilzeichenfolge zurück.
8 int lastIndexOf(String str, int fromIndex)
Gibt die Position des letzten Vorkommens des Teilstrings im String-Objekt zurück.
9 int length()
 gibt die Länge (Anzahl der Zeichen) zurück.
10 void setCharAt(int index, char ch)
Setzt das Zeichen am angegebenen Index auf  ch.
11 void setLength(int newLength)
legt die Länge der Zeichenfolge fest.
12 CharSequence subSequence(int start, int end)
Gibt eine neue Zeichenfolge zurück, die eine Teilsequenz dieser Sequenz ist.
13 String substring(int start)
gibt eine neue  StringTeilsequenz zurück, die die derzeit in dieser Zeichenfolge enthaltenen Zeichen enthält.
14 String substring(int start, int end)
gibt eine neue  StringTeilsequenz zurück, die die derzeit in dieser Sequenz enthaltenen Zeichen enthält.
15 String toString()
返回此序列中数据的字符串表示形式。

更多内容：

  • Date类与Calendar类

Date类

 Date类对象的创建：

1、创建一个当前时间的Date对象

//创建一个代表系统当前日期的Date对象

  Date d = new Date();

2、创建一个我们指定的时间的Date对象：

使用带参数的构造方法Date(int year, int month, int day) ，可以构造指定日期的Date类对象，Date类中年份的参数应该是实际需要代表的年份减去1900，实际需要代表的月份减去1以后的值。

//创建一个代表2022年2月5号的Date对象

Date d1 = new Date(2022-1900, 2-1, 5); （注意参数的设置）

3、正确获得一个date对象所包含的信息

如：

    Date d2 =  new Date(2022-1900, 2-1, 5);

        //获得年份 （注意年份要加上1900，这样才是日期对象d2所代表的年份）

        int year = d2.getYear() + 1900;

        //获得月份  （注意月份要加1，这样才是日期对象d2所代表的月份）

        int month = d2.getMonth() + 1;

        //获得日期

        int date = d2.getDate();

        //获得小时

        int hour = d2.getHours();//不设置默认为0

        //获得分钟

        int minute = d2.getMinutes();

        //获得秒

        int second = d2.getSeconds();

   //获得星期 （注意：0代表星期日、1代表星期1、2代表星期2，其他的一次类推了）

int day = d2.getDay();

// 创建日期对象，把当前的时间
System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018
// 创建日期对象，把当前的毫秒值转成日期对象
System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
//把日期对象转换成对应的时间毫秒值。
public long getTime() 
//用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
public SimpleDateFormat(String pattern)
//将Date对象格式化为字符串。
public String format(Date date)
//将字符串解析为Date对象。
public Date parse(String source)



import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把Date对象转换成String
*/
public class Demo03DateFormatMethod {
    public static void main(String[] args) {
        Date date = new Date();
        // 创建日期格式化对象,在获取格式化对象时可以指定风格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2008年1月23日
    }
}

Calendar类

 Calendar类的功能要比Date类强大很多，可以方便的进行日期的计算,获取日期中的信息时考虑了时区等问题。而且在实现方式上也比Date类要复杂一些

1、Calendar类对象的创建

   Calendar类是一个抽象类，由于Calendar类是抽象类，且Calendar类的构造方法是protected的，所以无法使用Calendar类的构造方法来创建对象，API中提供了getInstance方法用来创建对象。

2、创建一个代表系统当前日期的Calendar对象

 Calendar c = Calendar.getInstance();//默认是当前日期

3、创建一个指定日期的Calendar对象

使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。

//创建一个代表2014年5月9日的Calendar对象

Calendar c1 = Calendar.getInstance();

c1.set(2022, 2 - 1, 5)；//调用：public final void set(int year,int month,int date)

4、Calendar类对象信息的设置与获得

 1）Calendar类对象信息的设置

 A、Set设置

       如：Calendar c1 = Calendar.getInstance();

       调用：public final void set(int year,int month,int date)

   c1.set(2014, 6- 1, 9);//把Calendar对象c1的年月日分别设这为：2014、6、9

  B、利用字段类型设置

  如果只设定某个字段，例如日期的值，则可以使用public void set(int field,int value)

 //把 c1对象代表的日期设置为10号，其它所有的数值会被重新计算

     c1.set(Calendar.DATE,10);

 //把c1对象代表的年份设置为2014年，其他的所有数值会被重新计算

     c1.set(Calendar.YEAR,2015);

 其他字段属性set的意义以此类推

Calendar类中用一下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想

Calendar.YEAR——年份

Calendar.MONTH——月份

Calendar.DATE——日期

Calendar.DAY_OF_MONTH——日期，和上面的字段意义相同

Calendar.HOUR——12小时制的小时

Calendar.HOUR_OF_DAY——24小时制的小时

Calendar.MINUTE——分钟

Calendar.SECOND——秒

Calendar.DAY_OF_WEEK——星期几

 C、Add设置(可用与计算时间)

  Calendar c1 = Calendar.getInstance();

 //把c1对象的日期加上10，也就是c1所表的日期的10天后的日期，其它所有的数值会被重新计算

  c1.add(Calendar.DATE, 10);

 //把c1对象的日期加上-10，也就是c1所表的日期的10天前的日期，其它所有的数值会被重新计算

 c1.add(Calendar.DATE, -10);

 其他字段属性的add的意义以此类推

2）、Calendar类对象信息的获得(使用get（）)

 Calendar c1 = Calendar.getInstance();

// 获得年份

int year = c1.get(Calendar.YEAR);

// 获得月份

int month = c1.get(Calendar.MONTH) + 1;（MONTH+1）

// 获得日期

int date = c1.get(Calendar.DATE);

// 获得小时

int hour = c1.get(Calendar.HOUR_OF_DAY);

// 获得分钟

int minute = c1.get(Calendar.MINUTE);

// 获得秒

int second = c1.get(Calendar.SECOND);

// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）

int day = c1.get(Calendar.DAY_OF_WEEK);

Calendar对象和Date对象之间的互转

//1 .将Calendar对象转换为Date(c.getTime())
Calendar c = Calendar.getInstance();
Date d = c.getTime();
// 2.将Date转换为Calendar对象(s.setTime(date))
Calendar c1 = Calendar.getInstance();
Date d1 = new Date();
//通过setTime（）方法后，日历c1所表示的日期就d1的日期
c1.setTime(d1);

Date个Calendar对象之间的转换

//1.Date 转化为Calendar
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
//2.Calenda转换为Date
 Calendar calendar = Calendar.getInstance();
 Date date =calendar.getTime();

  • 日期的格式化

格式化日期表示将日期/时间格式转换为预先定义的日期/时间格式。例如将日期“Fri May 18 15:46:24 CST2016” 格式转换为 “2016-5-18 15:46:24 星期五”的格式。
在 Java 中，可以使用 DateFormat 类和 SimpleDateFormat 类来格式化日期。

DateFormat 类

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期→文本）、解析（文本→日期）和标准化日期。


在创建 DateFormat 对象时不能使用 new 关键字，而应该使用 DateFormat 类中的静态方法 getDateInstance()，示例代码如下：

DateFormat df = DateFormat.getDatelnstance();

在创建了一个 DateFormat 对象后，可以调用该对象中的方法来对日期/时间进行格式化。

DateFormat类的常用方法如下：

方法 描述
String format(Date date) 将 Date 格式化日期/时间字符串
Calendar getCalendar() 获取与此日期/时间格式相关联的日历
static DateFormat getDateInstance() 获取具有默认格式化风格和默认语言环境的日期格式
static DateFormat getDateInstance(int style) 获取具有指定格式化风格和默认语言环境的日期格式
static DateFormat getDateInstance(int style,
Locale locale)		 获取具有指定格式化风格和指定语言环境的日期格式
static DateFormat getDateTimeInstance() 获取具有默认格式化风格和默认语言环境的日期/时间
格式
static DateFormat getDateTimeInstance(int
dateStyle,int timeStyle)		 获取具有指定日期/时间格式化风格和默认语言环境的
日期/时间格式
static DateFormat getDateTimeInstance(int
dateStyle,int timeStyle,Locale locale)		 获取具有指定日期/时间格式化风格和指定语言环境的
日期/时间格式
static DateFormat getTimeInstance() 获取具有默认格式化风格和默认语言环境的时间格式
static DateFormat getTimeInstance(int style) 获取具有指定格式化风格和默认语言环境的时间格式
static DateFormat getTimeInstance(int style,
Locale locale)		 获取具有指定格式化风格和指定语言环境的时间格式
void setCalendar(Calendar newCalendar) 为此格式设置日历
Date parse(String source)

将给定的字符串解析成日期/时间

格式化样式主要通过 DateFormat 常量设置。将不同的常量传入到表 1 所示的方法中，以控制结果的长度。DateFormat 类的常量如下。

  • SHORT：完全为数字，如 12.5.10 或 5:30pm。
  • MEDIUM：较长，如 May 10，2016。
  • LONG：更长，如 May 12，2016 或 11:15:32am。
  • FULL：是完全指定，如 Tuesday、May 10、2012 AD 或 11:l5:42am CST。

SimpleDateFormat 类

如果使用 DateFormat 类格式化日期/时间并不能满足要求，那么就需要使用 DateFormat 类的子类——SimpleDateFormat。

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类，它允许进行格式化（日期→文本）、解析（文本→日期）和规范化。SimpleDateFormat 使得可以选择任何用户定义的日期/时间格式的模式。

SimpleDateFormat 类主要有如下 3 种构造方法：

  • SimpleDateFormat()：用默认的格式和默认的语言环境构造 SimpleDateFormat。
  • SimpleDateFormat(String pattern)：用指定的格式和默认的语言环境构造 SimpleDateF ormat。
  • SimpleDateFormat(String pattern,Locale locale)：用指定的格式和指定的语言环境构造 SimpleDateF ormat。

SimpleDateFormat 自定义格式中常用的字母及含义与示例如下：

字母 含义 示例
y 年份。一般用 yy 表示两位年份，yyyy 表示 4 位年份 使用 yy 表示的年扮，如 11；
使用 yyyy 表示的年份，如 2011
M 月份。一般用 MM 表示月份，如果使用 MMM，则会
根据语言环境显示不同语言的月份		 使用 MM 表示的月份，如 05；
使用 MMM 表示月份，在 Locale.CHINA
语言环境下，如“十月”；在 Locale.US
语言环境下，如 Oct
d 月份中的天数。一般用 dd 表示天数 使用 dd 表示的天数，如 10
D 年份中的天数。表示当天是当年的第几天， 用 D 表示 使用 D 表示的年份中的天数，如 295
E 星期几。用 E 表示，会根据语言环境的不同， 显示不
同语言的星期几		 使用 E 表示星期几，在 Locale.CHINA 语
言环境下，如“星期四”；在 Locale.US 语
言环境下，如 Thu
H 一天中的小时数（0~23)。一般用 HH 表示小时数 使用 HH 表示的小时数，如 18
h 一天中的小时数（1~12)。一般使用 hh 表示小时数 使用 hh 表示的小时数，如 10 (注意 10 有
可能是 10 点，也可能是 22 点）
m 分钟数。一般使用 mm 表示分钟数 使用 mm 表示的分钟数，如 29
s 秒数。一般使用 ss 表示秒数 使用 ss 表示的秒数，如 38
S 毫秒数。一般使用 SSS 表示毫秒数 使用 SSS 表示的毫秒数，如 156

  • Math类、BigInteger类和Random类

Math类

public static long abs(double s):返回a的绝对值

public static double max(double a,doublce b):返回a,b 的最大值

public static  double pow(double a,double b):返回a的b次幂

public sqrt(double a)返回a的平方根

public  log(double a）返回对数

public dobule ceil(a)

public round(a);四舍五入的值

  //Math类
      double a=10.0;
      double sum=Math.pow(a,2);
      System.out.println(sum);
      sum=Math.log(a);
      System.out.println(sum);
      sum=Math.sqrt(a);
      System.out.println(sum);

BigInteger类

程序如果需要处理特别大的整数，就可以用java.math包中的BigInteger类的对象。可以使用构造方法public BigInteger(String val)构造一个十进制的BigInteger对象。该构造方法可以发生异常。String 必须是合法字符。

常用方法：
public BigInteger add(BigInteger val):返回当前对象与val的和；

public BigInteger subtract( var)差

public  multiply 积

divide 商

remainder 余 类似%

compareTo 比较大小

abs()绝对值

toString  字符串

  //BigInteger
      BigInteger result=new BigInteger("0");
      BigInteger one=new BigInteger("123456789");
      BigInteger two=new BigInteger("2344532");
      result=one.add(two);
      System.out.println("和"+result);
      result=one.multiply(two);
      System.out.println("积"+result);
      result=one.subtract(two);
      System.out.println("差"+result);
      result=one.divide(two);
      System.out.println("商"+result);

Random类

可以返回随机数

Random=new Randow().nextInt(100)返回0-99的随机数

   //Random类
      System.out.println(new Random().nextInt(100));
      System.out.println(new Random().nextDouble()*100);

  • 数字格式化

NumberFormat表示数字的格式化类

NumberFormat 是所有数值格式的抽象基类。此类提供格式化和解析数值的接口。NumberFormat 还提供了一些方法来确定哪些语言环境具有数值格式，以及它们的名称是什么。

NumberFormat 可用于格式化和解析任何语言环境的数值。使代码能够完全独立于小数点、千位分隔符甚至所用特定小数位数的语言环境约定，并与数值格式是否为偶小数无关。

  • 若要格式化当前 Locale 的数值，可使用其中一个工厂类方法：NumberFormat.getInstance().format(myNumber);
  • 若要格式化不同 Locale 的日期，可在对 getInstance 的调用中指定它：NumberFormat nf = NumberFormat.getInstance(Locale.FRENCH);
  • 还可以使用 NumberFormat 来解析数值：myNumber = nf.parse(myString);

使用 getInstance 或 getNumberInstance 来获取常规数值格式。使用 getIntegerInstance 来获取整数数值格式。使用 getCurrencyInstance 来获取货币数值格式。使用 getPercentInstance 来获取显示百分比的格式。使用此格式，小数 0.53 将显示为 53%。

使用 setMinimumFractionDigits 之类的方法还可以控制数值的显示。如果想对格式化和解析进行更多的控制（或者给予用户更多的控制），可以尝试将从工厂方法获取的 NumberFormat 强制转换为 DecimalFormat。这适用于大多数语言环境；只是要记住将其放入一个 try 代码块中，以防遇到特殊情况。

API

  • Object clone()     重写 Cloneable

  • boolean equals(Object obj)     重写 equals

  • int hashCode()     重写 hashCode

  • String format(double number)     格式规范。

  • abstract  StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition pos)     格式规范。

  • String format(long number)     格式规范。

  • abstract  StringBuffer format(long number, StringBuffer toAppendTo, FieldPosition pos)     格式规范。

  • StringBuffer format(Object number, StringBuffer toAppendTo, FieldPosition pos)     格式化一个数并将所得文本添加到给定字符串缓冲区。

  • Number parse(String source)     解析给定字符串开头的文本，生成一个数值。

  • abstract  Number parse(String source, ParsePosition parsePosition)     如果可能则返回 Long （例如，在 [Long.MIN_VALUE, Long.MAX_VALUE] 范围内且没有小数），否则返回 Double。

  • Object parseObject(String source, ParsePosition pos)     解析字符串中的文本，以生成一个 Number。

  • int getMaximumFractionDigits()     返回数的小数部分所允许的最大位数。

  • int getMaximumIntegerDigits()     返回数的整数部分所允许的最大位数。

  • int getMinimumFractionDigits()     返回数的小数部分所允许的最小位数。

  • int getMinimumIntegerDigits()     返回数的整数部分所允许的最小位数。

  • void setMaximumFractionDigits(int newValue)     设置数的小数部分所允许的最大位数。

  • void setMaximumIntegerDigits(int newValue)     设置数的整数部分所允许的最大位数。

  • void setMinimumFractionDigits(int newValue)     设置数的小数部分所允许的最小位数。

  • void setMinimumIntegerDigits(int newValue)     设置数的整数部分所允许的最小位数。

  • static Locale[] getAvailableLocales()     返回一个数组，它包含所有此类的 get*Instance 方法可以为其返回本地化实例的语言环境。

  • static NumberFormat getCurrencyInstance()     返回当前默认语言环境的【货币】格式。

  • static NumberFormat getCurrencyInstance(Locale inLocale)     返回指定语言环境的【货币】格式。

  • static NumberFormat getInstance()     返回当前默认语言环境的通用【数值】格式。

  • static NumberFormat getInstance(Locale inLocale)     返回指定语言环境的通用【数值】格式。

  • static NumberFormat getIntegerInstance()     返回当前默认语言环境的【整数】格式。

  • static NumberFormat getIntegerInstance(Locale inLocale)     返回指定语言环境的【整数】格式。

  • static NumberFormat getNumberInstance()     返回当前默认语言环境的【通用数值】格式。

  • static NumberFormat getNumberInstance(Locale inLocale)     返回指定语言环境的【通用数值】格式。

  • static NumberFormat getPercentInstance()     返回当前默认语言环境的【百分比】格式。

  • static NumberFormat getPercentInstance(Locale inLocale)     返回指定语言环境的【百分比】格式。

  • Currency getCurrency()     获取格式化货币值时此数值格式使用的货币。

  • RoundingMode getRoundingMode()     获取在此 NumberFormat 中使用的 RoundingMode。

  • boolean isGroupingUsed()     如果此格式中使用了分组，则返回 true。

  • boolean isParseIntegerOnly()     如果此格式只将数作为整数解析，则返回 true。

  • void setCurrency(Currency currency)     设置格式化货币值时此数值格式使用的货币。

  • void setRoundingMode(RoundingMode roundingMode)     设置在此 NumberFormat 中使用的 RoundingMode。

  • void setGroupingUsed(boolean newValue)     设置此格式中是否使用分组。

  • void setParseIntegerOnly(boolean value)     设置数是否应该仅作为整数进行解析。

DecimalFormat格式化数字

DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。允许我们指定格式模式获取我们想要的格式化数值，数值的小数部分，默认显示3位小数该类设计有各种功能，使其能够解析和格式化任意语言环境中的数，包括对西方语言、阿拉伯语和印度语数字的支持。它还支持不同类型的数，包括整数 (123)、符点数 (123.4)、科学记数法表示的数 (1.23E4)、百分数 (12%) 和金额 ($123)。所有这些内容都可以本地化。

Double  d=Double.parseDouble(num);
            java.text.NumberFormat percentFormat =java.text.NumberFormat.getPercentInstance(); 
            percentFormat.setMaximumFractionDigits(2); //最大小数位数
            percentFormat.setMaximumIntegerDigits(3);//最大整数位数
            percentFormat.setMinimumFractionDigits(2); //最小小数位数
            percentFormat.setMinimumIntegerDigits(1);//最小整数位数
            return percentFormat.format(d);//自动转换成百分比显示

0    表示一个数字，被格式化数值不够的位数会补0
#    表示一个数字，被格式化数值不够的位数会忽略
.    小数点分隔符的占位符
,    分组分隔符的占位符
-    缺省负数前缀
%    将数值乘以100并显示为百分数
\u2030    将数值乘以1000并显示为千分数

要获取具体语言环境的 NumberFormat，可调用 NumberFormat 的某个get**Instance()工厂方法 ，通常其就是 DecimalFormat 类型。

System.out.println(NumberFormat.getInstance() instanceof DecimalFormat);//true

通常不直接调用 DecimalFormat 的构造方法，因为 NumberFormat 的工厂方法可能返回不同于 DecimalFormat 的子类。

如果需要自定义格式对象，可执行：

NumberFormat f = NumberFormat.getInstance(loc);
((DecimalFormat)f).setDecimalSeparatorAlwaysShown(true);

Tips：DecimalFormat 通常不是同步的。建议为每个线程创建独立的格式实例。如果多个线程同时访问某个格式，则必须保持外部同步。

DecimalFormat 包含一个模式 和一组符号。可直接使用 applyPattern() 或间接使用 API 方法来设置模式。符号存储在 DecimalFormatSymbols 对象中。使用 NumberFormat 工厂方法时，可从已本地化的 ResourceBundle 中读取模式和符号。

ChoiceFormat格式化数字

ChoiceFormat允许将格式化运用到某个范围的数，通常与MessageFormat一同使用。ChoiceFormat在构造方法中接收一个format数组和一个limits数组，这两个数组的长度必须相等，例如：

limits = {1,2,3,4,5,6,7}
formats = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}

limits数组实际上是个区间，可开可闭，并且必须按升序排列，如果不按升序排列，格式化结果将会不正确，还可以使用\u221E(表示无穷大)。

ChoiceFormat的匹配公式：

limit[j] <= X <limit[j+1]

其中X表示使用format方法传入的值，j表示limit数组中的索引。当且仅当上述公式成立时，X匹配j，如果不能匹配，则会根据X是太小还是太大，匹配limits数组的第一个索引或最后一个索引，然后使用匹配的limits数组中的索引，去formats数组中寻找相同索引的值。

ChoiceFormat类中的几个常用方法

（1）nextDouble(double d)静态方法查找大于d的最小double值，用在limits数组中，从而使limits数组形成一个右开区间数组，例如：

limits = {0,1,ChoiceFormat.nextDouble(1)}

（2）nextDouble(double d, boolean positive)静态方法，如果positive参数为true，表示查找大于d的最小double值；如果positive参数为false，表示查找小于d的最大double值，这样就可以使limits形成一个左开区间数组。

（3）previousDouble(double d)静态方法，查找小于d的最大double值
ChoiceFormat类的构造方法也允许我们传入一个模式字符串，format方法会根据这个模式字符串执行格式化操作。一个模式元素的格式如下：

doubleNum [占位符] formatStr

Tips：模式字符串中的每个模式元素之间使用"|"分割，"|"前后可以添加空格以美化代码，而且必须按照升序进行书写，否则会出现java.lang.IllegalArgumentException的运行时异常。

  • Class类与Console类（待补充）

Class

可以得到类的实例

Class a=new Class("Hello"):
Hellow h=(Hellow)a.newInstace();

Console类

不让文本回显即不在命令行显示就用Console类

  //Console类
      Console cons=System.console();
      char[] chars;
      chars=cons.readPassword();
      System.out.println(chars.toString());

  • Pattern类与Matcher类

概述

  • Pattern类的作用在于编译正则表达式后创建一个匹配模式.
  • Matcher类使用Pattern实例提供的模式信息对正则表达式进行匹配

Pattern类

常用方法及介绍

  • Pattern complie(String regex)

由于Pattern的构造函数是私有的,不可以直接创建,所以通过静态方法compile(String regex)方法来创建,将给定的正则表达式编译并赋予给Pattern类

  • String pattern()

返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数

  • Pattern compile(String regex, int flags) 

方法功能和compile(String regex)相同,不过增加了flag参数

  • int flags() 

返回当前Pattern的匹配flag参数.flag参数用来控制正则表达式的匹配行为

  • Pattern.matcher(CharSequence input) 

对指定输入的字符串创建一个Matcher对象

  • String[] split(CharSequence input)

String[] split(CharSequence input, int limit)

  • String[] split(CharSequence input, int limit)

功能和String[] split(CharSequence input)相同,增加参数limit目的在于要指定分割的段数

  • Pattern.quote(String s)

返回给定的字符串的字面量

  • matches()方法

编译给定的正则表达式并且对输入的字串以该正则表达式为模开展匹配,该方法适合于该正则表达式只会使用一次的情况,也就是只进行一次匹配工作,因为这种情况下并不需要生成一个Matcher实例.

Matcher类

常用方法及介绍

  • boolean matches()

最常用方法:尝试对整个目标字符展开匹配检测,也就是只有整个目标字符串完全匹配时才返回真值.

  • boolean lookingAt()

对前面的字符串进行匹配,只有匹配到的字符串在最前面才会返回true

  • boolean find()

对字符串进行匹配,匹配到的字符串可以在任何位置

  • int start()

返回当前匹配到的字符串在原目标字符串中的位置

  • int end()

返回当前匹配的字符串的最后一个字符在原目标字符串中的索引位置.

  • String group()

返回匹配到的子字符串

  • Pattern.start(),Pattern.end(),Pattern.group()代码示例
  • Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher("aa22bb23");
m.find();
int start = m.start();//2
String group = m.group();//22
int end = m.end();//4
System.out.println(start);
System.out.println(group);
System.out.println(end);

知识点小结

  • String类是final 类，不可以有子类
  • “\hello"是错误的字符串常量，”\hello"是正确的字符串常量
  • 表达式"\t\nABC".length()的值是5【\t、\n算分别算一个字符】
  • 表达式"A".compareTo(“B”)的值是负数
  • 【.compareTo(),比较大小，前者>后者→正数，前者＜后者→负数，前者=后者→0】
  • 表达式"I love this game".contains(“love”)的值是true
  • 【.contains(),判断是否包含某字符串】
  • 表达式"RedBird".indexOf(“Bird”)的值是3
  • 【.indexOf(),返回目标字符串下标索引，若不存在则返回-1】
  • Integer.parseInt(“12.9”);会触发NumberFormatException异常
  • 【Integer.parseInt()字符串→整数，12.9为浮点数】
  • 表达式"D:/java/book/E.java".lastIndexOf("/")的值是12
  • 【.lastIndexOf()，返回目标字符出现的最后索引位置】
  • 表达式"89762.34".matches("[0-9.]+")的值是true
  • 表达式"3.14".matches("[0-9]+[.]{1}[0-9]+")的值是true
  • 【matches() ，返回是否匹配指定的字符串】
  • 表达式"89762.34".startsWith(“89”)的值是true
  • 表达式"89762.34".endsWith(“34”)的值是true
  • 表达式"java".equals(“java”)的值是true
  • 【.equals()，判断值是否相等，区别于= =（判断地址），表达式 new String(“abc”)== "abc"的值是false（地址不同）】
  • 表达式"bird".contentEquals(“bird”)的值是true
  • 【equals()和contentEquals()方法】
  • 表达式"Bird".equalsIgnoreCase(“bird”)的值是true
  • 【.equalsIgnoreCase()，忽略大小写判断是否等值】
  • 表达式new String(“abc”).contentEquals (“abc”)的值是true
  • 表达式new String(“abc”).equals (“abc”)的值是true
  • 表达式"abc" == "abc"的值是true
  • 表达式new String(“abc”) == new String(“abc”)的值是false
  • StringTokenizer对象的nextToken()方法返回一个String对象
  • StringTokenizer对象的countTokens()方法返回一个int型数据
  • String对象的字符序列是不可修改的
  • StringBuffer对象的字符序列是可修改的
  • Random对象的nextInt(int n)方法随机返回[0，n)之间的一个整数

参考

《Java 2 实用教程（第5版）》

https://blog.csdn.net/weixin_38235865/article/details/104588841

https://blog.csdn.net/m0_50609545/article/details/118017091

https://blog.csdn.net/weixin_42717928/article/details/97536281

Java-Datumsformatierung (DateFormat-Klasse und SimpleDateFormat-Klasse) (biancheng.net)

Ich denke du magst

Origin blog.csdn.net/K_savo/article/details/122744397
Empfohlen
Rangfolge
Täglich
Mehr
2024-05-27(1)
2024-05-26(0)
2024-05-25(1)
2024-05-24(13)
2024-05-23(34)
2024-05-22(10)
2024-05-21(34)
2024-05-20(5)
2024-05-19(0)
2024-05-18(31)

Code World

© 2018 codetd.com