Java常用類（一）

来源:https://www.cnblogs.com/xiaozhao01/archive/2022/08/10/16574053.html
-Advertisement-
Play Games

Java常用類（一） 一、String 類：（不可變的字元序列） 1.1 String：字元串，使用一對 " " 引起來表示。 String 類聲明為 final 的，不可被繼承。 String 類實現了 Serializable 介面：表示字元串是支持序列化的。實現了 Comparable 介面： ...


Java常用類（一）

目錄

一、String 類：（不可變的字元序列）

1.1 String：字元串，使用一對 " " 引起來表示。

  1. String 類聲明為 final 的，不可被繼承。

  2. String 類實現了 Serializable 介面：表示字元串是支持序列化的。實現了 Comparable 介面：表示 String 可以比較大小的。

  3. String 內部定義了 final char[] value 用於存儲字元串數據。（ JDK8 與 JDK8 之前版本 ）

    public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
	/** The value is used for character storage. */
	private final char value[];
	/** Cache the hash code for the string */
	private int hash; // Default to 0
    ...
}

  4. String：代表不可變的字元序列。簡稱：不可變性。
    體現：

    （1）當對字元串重新賦值時，需要重寫指定記憶體區域賦值，不能使用原有的 value 進行賦值。

    （2）當對現有的字元串進行連接操作時，也需要重新指定記憶體區域賦值，不能使用原有的 value 進行賦值。

    （3）String 的 replace() 方法修改指定字元或字元串時，也需要重新指定記憶體區域賦值，不能使用原有的 value 進行賦值。

  5. 通過字面量的方式（區別於new）給一個字元串賦值，此時的字元串值聲明在字元串常量池中。

  6. 字元串常量池中是不會存儲相同內容的字元串的。

public class test1{
    public static void main(String[] args){
     // 當對字元串重新賦值時，需要重寫指定記憶體區域賦值，不能使用原有的value進行賦值。   
    	String s1 = "abc";	//字面量的定義方式
     	String s2 = "abc";
     	System.out.println(s1 == s2);	//比較s1和s2的地址值：true 
     	
    	s1 = "hello";
     	System.out.println(s1 == s2);	//比較s1和s2的地址值：false
	
     	System.out.println(s1);	//hello
     	System.out.println(s2);	//abc

	 	//	當對現有的字元串進行連接操作時，也需要重新指定記憶體區域賦值，不能使用原有的value進行賦值。
     	String s3 = "abc";
     	s3 += "def";
     	System.out.println(s3);	//abcdef
     	System.out.println(s2);	//abc
	
     	// String的replace()方法修改指定字元或字元串時，也需要重新指定記憶體區域賦值，不能使用原有的value進行賦值。
     	String s4 = "abc";
     	String s5 = s4.replace('a', 'm');
     	System.out.println(s4);	//abc
     	System.out.println(s5);	//mbc
    }
}

1.2 String 對象的創建：

  1. 方式一：通過字面量定義的方式

    方式二：通過 new + 構造器的方式

public class test2{
    public static void main(String[] args){
        //通過字面量定義的方式：此時的s1和s2的數據javaEE聲明在方法區中的字元串常量池中。
        String s1 = "javaEE";
        String s2 = "javaEE";
        
        //通過new + 構造器的方式:此時的s3和s4保存的地址值，是數據在堆空間中開闢空間以後對應的地址值。
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");

        System.out.println(s1 == s2);	//true
        System.out.println(s1 == s3);	//false
        System.out.println(s1 == s4);	//false
        System.out.println(s3 == s4);	//false

        Person p1 = new Person("Tom",12);
        Person p2 = new Person("Tom",12);

        System.out.println(p1.name.equals(p2.name));	//true
        System.out.println(p1.name == p2.name);			//true

        p1.name = "Jerry";
        System.out.println(p2.name);//Tom
    }
}

public class Person {

    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

  1. 面試題：String s = new String("abc");方式創建對象，在記憶體中創建了幾個對象？

    兩個：一個是堆空間中 new 結構，另一個是 char[] 對應的常量池中的數據："abc"。

1.3 String 不同拼接操作對比：

  1. 常量與常量的拼接結果在常量池。且常量池中不會存在相同內容的常量。
  2. 只要其中有一個是變數，結果就在堆中。
  3. 如果拼接的結果調用 intern() 方法，返回值就在常量池中。
public class test3{
    public static void main(String[] args){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4);	//true
        System.out.println(s3 == s5);	//false
        System.out.println(s3 == s6);	//false
        System.out.println(s3 == s7);	//false
        System.out.println(s5 == s6);	//false
        System.out.println(s5 == s7);	//false
        System.out.println(s6 == s7);	//false

        String s8 = s6.intern();	//返回值得到的s8使用的常量值中已經存在的“javaEEhadoop”
        System.out.println(s3 == s8);	//true
        
        final String s9 = "xiaozhao";
        String s10 = s9 + "java";
        String s11 = "xiaozhaojava";
        System.out.println(s10 == s11);	//true（原因：s9用final修飾，類似於常量，存儲在常量池中）
    }
}
/*
	s1 = s1 + "b"; 
	說明：實際上原來的“a”字元串對象已經丟棄了，現在在堆空間中產生了一個字元串s1+"b"（也就是"ab")。如果多次執行這些改變串內容的		 操作，會導致大量副本字元串對象存留在記憶體中，降低效率。如果這樣的操作放到迴圈中，會極大影響程式的性能。
*/

特殊例子：

public class StringTest {

    String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };

    public void change(String str, char ch[]) {	// 將實參str和ch的地址值傳遞給形參str和ch
        // this.str = "test ok"; 如果使用該語句，則ex.str輸出為 test ok
        str = "test ok";
        System.out.println(str);	// test ok
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);		// good
        System.out.println(ex.ch);		// best
    }
}

1.4 String 類的常用方法

int length()：返回字元串的長度：return value.length
char charAt(int index)：返回某索引處的字元：return value[index]
boolean isEmpty()：判斷是否是空字元串：return value.length == 0
String toLowerCase()：使用預設語言環境，將 String 中的所有字元轉換為小寫
String toUpperCase()：使用預設語言環境，將 String 中的所有字元轉換為大寫
String trim()：返回字元串的副本，忽略前導空白和尾部空白
boolean equals(Object obj)：比較字元串的內容是否相同
boolean equalsIgnoreCase(String anotherString)：與equals方法類似，忽略大小寫
String concat(String str)：將指定字元串連接到此字元串的結尾。 等價於用“+”
int compareTo(String anotherString)：比較兩個字元串的大小
String substring(int beginIndex)：返回一個新的字元串，它是此字元串的從beginIndex開始截取到最後的一個子字元串。
String substring(int beginIndex, int endIndex) ：返回一個新字元串，它是此字元串從beginIndex開始截取到endIndex(不包含)的一個子字元串。

public class test1 {
    public static void main(String[] args){}
        String s1 = "HelloWorld";
        System.out.println(s1.length());	// 10
        System.out.println(s1.charAt(0));	// H
        System.out.println(s1.isEmpty());	// false

        String s2 = s1.toLowerCase();
        System.out.println(s1);				// HelloWorld（s1不可變的，仍然為原來的字元串）
        System.out.println(s2);				// helloworld（改成小寫以後的字元串）

        String s3 = "   he  llo   world   ";
        String s4 = s3.trim();
        System.out.println(s3);				//    he  llo   world   
        System.out.println(s4);				// he  llo   world
    
    	String s5 = "helloworld";
    	System.out.println(s1.equals(s5));	// false
        System.out.println(s1.equalsIgnoreCase(s5));	// true
    
    	String s6 = s1.concat("ByJava");	
    	System.out.println(s6);				// HelloWorldByJava
    
    	String s7 = "abc";
    	String s8 = new String("abe");
    	System.out.println(s7.compareTo(s8));// -2
    
    	String s9 = "小釗學Java";
        String s10 = s9.substring(2);
        System.out.println(s9);				// 小釗學Java
        System.out.println(s10);			// 學Java

        String s11 = s9.substring(1, 4);
        System.out.println(s11);			// 釗學J
    }
}

boolean endsWith(String suffix)：測試此字元串是否以指定的尾碼結束
boolean startsWith(String prefix)：測試此字元串是否以指定的首碼開始
boolean startsWith(String prefix, int toffset)：測試此字元串從指定索引開始的子字元串是否以指定首碼開始

boolean contains(CharSequence s)：當且僅當此字元串包含指定的 char 值序列時，返回 true
int indexOf(String str)：返回指定子字元串在此字元串中第一次出現處的索引
int indexOf(String str, int fromIndex)：返回指定子字元串在此字元串中第一次出現處的索引，從指定的索引開始
int lastIndexOf(String str)：返回指定子字元串在此字元串中最右邊出現處的索引
int lastIndexOf(String str, int fromIndex)：返回指定子字元串在此字元串中最後一次出現處的索引，從指定的索引開始反向搜索
//	註：indexOf和lastIndexOf方法如果未找到都是返回-1

public class test2{
    public static void main(String[] args){
        String s1 = "zhaohelloworldzhao";
        boolean b1 = s1.endsWith("zhao");
        System.out.println(b1);					// true

        boolean b2 = s1.startsWith("Zhao");
        System.out.println(b2);					// false

        boolean b3 = s1.startsWith("hello",4);
        boolean b4 = s1.startsWith("hello",5);   
        System.out.println(b3);					// true
        System.out.println(b4);					// false

        String s2 = "zhao";
        System.out.println(s1.contains(s2));	// true

        System.out.println(s1.indexOf("zhao"));	// 0

        System.out.println(s1.indexOf("zhao",1));	// 14

        System.out.println(s1.lastIndexOf("zhao"));	//	14
        System.out.println(s1.lastIndexOf("zhao",6));	// 0

        //	什麼情況下，indexOf(str)和lastIndexOf(str)返回值相同？
        //	情況一：存在唯一的一個str。情況二：不存在str,均等於-1。
    }
}

// 替換
String replace(char oldChar, char newChar)：返回一個新的字元串，它是通過用 newChar 替換此字元串中出現的所有 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替換序列替換此字元串所有匹配字面值目標序列的子字元串。
String replaceAll(String regex, String replacement) ：使用給定的 replacement 替換此字元串所有匹配給定的正則表達式的子字元串。
String replaceFirst(String regex, String replacement) ：使用給定的 replacement 替換此字元串匹配給定的正則表達式的第一個子字元串。
// 匹配
boolean matches(String regex)：告知此字元串是否匹配給定的正則表達式。
// 切片
String[] split(String regex)：根據給定正則表達式的匹配拆分此字元串。
String[] split(String regex, int limit)：根據匹配給定的正則表達式來拆分此字元串，最多不超過 limit 個，如果超過了，剩下的全部都放到最後一個元素中。

public class test3{
    public static void main(String[] args){
        String s1 = "小釗學Java小釗";
        String s2 = s1.replace('釗', '明');

        System.out.println(s1);		// 小釗學Java小釗
        System.out.println(s2);		// 小明學Java小明
        
        String s = "12hello34world5java7891xiaozhao456";
        //把字元串中的數字替換成!，如果結果中開頭和結尾有!的話去掉
        String s3 = s.replaceAll("\\d+", "!");
        String s4 = s.replaceAll("\\d+", "!").replaceAll("^,|,$", "");
        System.out.println(s3);		// !hello!world!java!xiaozhao!
        System.out.println(s4);		// hello!world!java!xiaozhao

        String s5 = "12345";
        //判斷s5字元串中是否全部有數字組成，即有1-n個數字組成
        boolean matches = s5.matches("\\d+");
        System.out.println(matches);	// true
        
        String tel = "020-4534289";
        //判斷這是否是一個廣州的固定電話,且-後的號碼為7-8位
        boolean result = tel.matches("020-\\d{7,8}");
        System.out.println(result);		// true

        String s6 = "hello|world|java";
        String[] strs = s6.split("\\|");
        for (int i = 0; i < strs.length; i++) {
            System.out.print(strs[i] + " ");	// hello world java
        }
        System.out.println();
        String s7 = "hello.world.java";
        String[] strs2 = s7.split("\\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.print(strs2[i] + " ");	// hello world java
        }
    }
}

1.5 String 與基本數據類型、包裝類的轉換

  • 字元串 >> 基本數據類型、包裝類

    Integer 包裝類的 public static int parseInt(String s)：可以將由“數字”字元組成的字元串轉換為整型。

    類似地，使用 java.lang 包中的 Byte、Short、Long、Float、Double 類調相應的類方法可以將由“數字”字元組成的字元串，轉化為相應的基本數據類型。

  • 基本數據類型、包裝類 >> 字元串

    調用 String 類的 public String valueOf(int n) 可將 int 型轉換為字元串

    相應的 valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(double d)、valueOf(boolean b) 可由參數的相應類型到字元串的轉換

public class test1{
    public static void main(String[] args){
        String str1 = "123";
//        int num = (int)str1;//錯誤的
        int num = Integer.parseInt(str1);

        String str2 = String.valueOf(num);	// "123"
        String str3 = num + "";

        System.out.println(str1 == str3);	// false（str3為堆地址值，str1為"123"在字元常量池的地址值）
    }
}

1.6 String 與字元數組 char[] 的轉換

  • String >> char[]：調用 String 的 toCharArray()
  • char[] >> String：調用 String 的構造器
public class test2{
	public static void main(String[] args){
        
        String str1 = "abc123";
        
        char[] charArray = str1.toCharArray();
        
        for (int i = 0; i < charArray.length; i++) {
            System.out.print(charArray[i] + " ");	// a b c 1 2 3 
        }

        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);					// hello
    }
}

1.7 String 與位元組數組 byte[] 的轉換

  • 編碼：String >> byte[]：調用 String 的getBytes()
  • 解碼：byte[] >> String：調用 String 的構造器
  • 說明：解碼時，要求解碼使用的字元集必須與編碼時使用的字元集一致，否則會出現亂碼。
	@Test
    public void test3() throws UnsupportedEncodingException {
        String str1 = "abc123中國";
        byte[] bytes = str1.getBytes();		//	使用預設的字元集，進行編碼。
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = str1.getBytes("gbk");	//	使用gbk字元集進行編碼。
        System.out.println(Arrays.toString(gbks));

        String str2 = new String(bytes);	//	使用預設的字元集，進行解碼。
        System.out.println(str2);

        String str3 = new String(gbks);
        System.out.println(str3);			//	出現亂碼。原因：編碼集和解碼集不一致！

        String str4 = new String(gbks, "gbk");
        System.out.println(str4);			//	沒有出現亂碼。原因：編碼集和解碼集一致！
    }

二、StringBuffer 類和 StringBuilder 類：（可變的字元序列）

2.1 StringBuffer 類：

  1. java.lang.StringBuffer 代表可變的字元序列，JDK1.0 中聲明，可以對字元串內容進行增刪，此時不會產生新的對象。

  2. 很多方法與String相同。

  3. 作為參數傳遞時，方法內部可以改變值。

  4. StringBuffer 類不同於 String，其對象必須使用構造器生成。有三個構造器：

    StringBuffer()：初始容量為16的字元串緩衝區。char[] value = new char[16];

    StringBuffer(int size)：構造指定容量的字元串緩衝區。

    StringBuffer(String str)：將內容初始化為指定字元串內容。

  5. StringBuffer 類的常用方法：

StringBuffer append(xxx)：提供了很多的append()方法，用於進行字元串拼接
StringBuffer delete(int start,int end)：刪除指定位置的內容
StringBuffer replace(int start, int end, String str)：把[start,end)位置替換為str
StringBuffer insert(int offset, xxx)：在指定位置插入xxx
StringBuffer reverse()：把當前字元序列逆轉
                                                       
public int indexOf(String str)：返回指定子字元串在此字元串中第一次出現處的索引
public String substring(int start,int end)：返回一個從start開始到end索引結束的左閉右開區間的子字元串
public int length()：返回字元串的（有效）長度
public char charAt(int n )：返回某索引處的字元
public void setCharAt(int n ,char ch)：修改n索引處的字元為ch

public class test1{
    public static void main(String[] args){
        StringBuffer s1 = new StringBuffer("abc");
        s1.setCharAt(0,'m');
        System.out.println(s1);		// mbc

        StringBuffer s2 = new StringBuffer();
        System.out.println(s2.length());	// 0
            
        s1.append(1);
        s1.append('1');
        System.out.println(s1);		// mbc11
//        s1.delete(2,4);			// mb1
//        s1.replace(2,4,"hello");	// mbhello1
//        s1.insert(2,false);		// mbfalsec11
//        s1.reverse();				// 11cbm
        String s2 = s1.substring(1, 3);
        System.out.println(s1);		// mbc11
        System.out.println(s1.length());	// 5
        System.out.println(s2);		// bc
    }
}

2.2 StringBuilder 類

  1. StringBuilder 和 StringBuffer 非常類似，均代表可變的字元序列，而且提供相關功能的方法也一樣。

  2. 面試題：對比 String、StringBuffer、StringBuilder

​ String：不可變的字元序列；底層使用 char[] 存儲
​ StringBuffer：可變的字元序列；線程安全的，效率低；底層使用 char[] 存儲
​ StringBuilder：可變的字元序列；jdk5.0新增的，線程不安全的，效率高；底層使用 char[] 存儲

註意：作為參數傳遞的話，方法內部String不會改變其值，StringBuffer和StringBuilder 會改變其值。

  1. StringBuffer 類和 StringBuilder 類初始容量均為 16 的字元串緩衝區，如果要添加的數據底層數組盛不下了，那就需要擴容底層的數組。預設情況下，擴容為原來容量的 2 倍加 2，同時將原有數組中的元素複製到新的數組中。

    因此開發中建議大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity) 。

  2. 對比 String、StringBuffer、StringBuilder 三者的效率：
    從高到低排列：StringBuilder > StringBuffer > String


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Java學習-第一部分-第二階段-第三節：異常
    異常 筆記目錄：(https://www.cnblogs.com/wenjie2000/p/16378441.html) 運行下麵的代碼，看看有什麼問題->引出異常和異常處理機制 public static void main(String[] args) { int num1 =10; int n ...
  • Java學習-第一部分-第二階段-第二節：枚舉和註釋
    枚舉和註釋 筆記目錄：(https://www.cnblogs.com/wenjie2000/p/16378441.html) 自定義類實現枚舉 先看一個需求 要求創建季節(Season)對象，請設計並完成。 創建Season對象有如下特點 1.季節的值是有限的幾個值(spring, summer, ...
  • 分庫分表ShardingSphere-JDBC筆記整理
    一、分庫分表解決的現狀問題 解決資料庫本身瓶頸 連接數： 連接數過多時，就會出現‘too many connections’的錯誤，訪問量太大或者資料庫設置的最大連接數太小的原因 Mysql預設的最大連接數為100.可以修改，而mysql服務允許的最大連接數為16384 資料庫分表可以解決單表海量數 ...
  • 2022-8-10 JAVA的反射機制
    #反射機制 AVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。 Java反射機制在框架設計中極為廣泛，需要深入理解。 ##反射基礎 RTTI（R ...
  • IOS OpenGL ES GPUImage 圖像縮放 GPUImageTransformFilter
    目錄 一.簡介 二.效果演示 三.源碼下載 四.猜你喜歡 零基礎 OpenGL (ES) 學習路線推薦 : OpenGL (ES) 學習目錄 >> OpenGL ES 基礎 零基礎 OpenGL (ES) 學習路線推薦 : OpenGL (ES) 學習目錄 >> OpenGL ES 轉場 零基礎 O ...
  • MySQL之JDBC編程增刪改查
    MySQL之JDBC 一、JDBC是什麼 Java DatabaseConnectivity （java語言連接資料庫） 二、JDBC的本質 JDBC是SUN公司制定的一套介面(interface)。 介面都有調用者和實現者。 面向介面調用、面向介面寫實現類，這都屬於面向介面編程。 三、為什麼要面向 ...
  • shiro認證- SpringBoot（20）
    1.認識shiro 除Spring Security安全框架外，應用非常廣泛的就是Apache的強大又靈活的開源安全框架 Shiro,在國內使用量遠遠超過Spring Security。它能夠用於身份驗證、授權、加密和會話管理， 有易於理解的API,可以快速、輕鬆地構建任何應用程式。而且大部分人覺得 ...
  • Java學習-第一部分-第二階段-第一節：面向對象編程（高級）
    面向對象編程（高級） 筆記目錄：(https://www.cnblogs.com/wenjie2000/p/16378441.html) 類變數和類方法(static) 類變數 類變數-提出問題 提出問題的主要目的就是讓大家思考解決之道，從而引出我要講的知識點.說:有一群小孩在玩堆雪人,不時有新的小 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類