String字串，陣列

serendipity_xr發表於2020-10-16

一.String字串

簡單使用API
1.生成自己的api文件
根據自己的java程式碼生成自己的幫助文件
2。使用java命令操作帶包的java檔案
Javac -d . java檔案編譯命令
執行命令 java 全路徑（包.Class名）
3.字串用法
所有的字串當做變數來使用
資料型別名字 =值
String str=”hello world”；
字串是常量；它們的值在建立之後不能改變。
a.字串的擷取
字串其實是多個字元組成的 123456
使用String提供的方法獲取字串中的子串
一個字串可以看做是一組字元組成的
一個字串可以看做是對個子字串組成的
每一個字串都有長度

在字串中每一個字元都有一個位置使用標記 0------str.length()
charAt 返回指定索引處的char值

public class Stringmean {
 public static void main(String[] args) {
  String str="abcdefghijkd";
  char c=str.charAt(0);
  System.out.println(c);//a
  //length() 返回此字串的長度
  System.out.println(str.length());//12
  //indexOf返回指定字元在此字串中第一次出現處的索引
      System.out.println(str.indexOf("a"));//0
      System.out.println(str.indexOf("a",4));//-1
      //lastIndexOf返回最後一次出現的指定字元在此字串中的索引
      System.out.println(str.lastIndexOf("d"));//11
      //substring() 返回一個新的字串，它是此字串的一個子字串
      //substring（int beinIndex)/substring（int beinIndex,int endIndex)
      System.out.println(str.substring(4));//efghijkd
      System.out.println(str.substring(4,5));//e
      //toLowerCase()  將此 String 中的所有字元都轉換為小寫
      System.out.println(str.toLowerCase());//abcdefghijkd
      //toUpperCase() 將此 String 中的所有字元都轉換為大寫
      System.out.println(str.toUpperCase());//ABCDEFGHIJKD
      //trim() 返回字串的副本，忽略前導空白和尾部空白
      String str1="    hxryfyxm     ";
      System.out.println("含空格的長度"+str1.length());
      str1=str1.trim();
      System.out.println(str1);
      System.out.println("不含有空格的長度"+str1。length());
      //valueOf() 返回括號內引數的字串表示形式
      //轉換    新的變數接收一下 
      //字串與數值型轉換      數值型轉為String型    任意的基本型別轉為String型別 
      //  123  轉為   “123”  
      int num=123;
      // System.out.println(num+""+100);  
      System.out.println("轉換前=="+(num+100));
      String numstr = String.valueOf(num);
      System.out.println("轉換後的num值=="+(num+100));
      System.out.println("轉換後=="+(numstr+100));
     //獲取字串中的子字串
      char c =str.charAt(0);
      System.out.println(c);
     //指定字元 在字串中的位置  使用下標 
      System.out.println("a在str中第一次出現的位置 "+str.indexOf("hello"));
      System.out.println("a在str中最後一次出現的位置 "+str.lastIndexOf("a"));
     //從哪個位置開始找 
     System.out.println("a在str中第一次出現的位置  "+str.indexOf("a",3));
    }
}

b.字串的比較

//在使用String 的equals方法的時候    
// 如果string變數的值為null   會產生空指標異常 
//可以用一個不為null 的字串與null的字串進行比較  
//不要使用值為null的東西與字串進行比較
public static void main(String[] args) {
   String str1="123";
   String str2="456";
   String str3="123";
   String str4="123456";
   String str5=new String("123");
   String str6=str1+str2;
   String str7=null;
   //==普通方法比較的是值
   System.out.println(str1==str2);
   System.out.println(str1==str3);
   //變數與stringnew方法==比較
   System.out.println("變數與stringnew方法==比較"+str1==str5);
   System.out.println("變數與null方法==比較"+str1==str7);
   System.out.println("變數與兩個str拼接方法==比較"+str4==str6);
   //
   System.out.println(str1.equals(str2));
   System.out.println(str1.equals(str4));
   System.out.println(str4.equals(str6));
   System.out.println(str1.equals(str7));
   // java.lang.NullPointerException 空指標異常   
   System.out.println(str7.equals(str1));

在使用String 的equals方法的時候
如果string變數的值為null 會產生空指標異常
可以用一個不為null 的字串與null的字串進行比較
不要使用值為null的東西與字串進行比較

二.陣列

陣列是用來存放相同資料型別的一個容器，這些相同的資料在容器中是有序排列的。在容器中的資料使用下標來進行標記的。
陣列是在程式執行期間用來存放資料的容器
變數：在程式執行期間其值可以改變儲存一個值
陣列：在程式執行期間內部資料可以改變儲存多個值

//陣列的長度一旦宣告，在執行期間無法改變
public class array01 {
 public static void main(String[] args) {
  int[] arr = new int[5];// 宣告一個int型別的陣列
  
  System.out.println("陣列的長度為" + arr.length);
  arr[0] = 12;// 給陣列的第一個元素賦值
  arr[1] = 44;
  arr[2] = 20;
  arr[4] = 33;
  System.out.println("第一個元素是" + arr[0]);
  System.out.println("第四個元素是" + arr[3]);
  
  // 陣列的遍歷
  for (int i = 0; i < arr.length; i++) {
   System.out.println("第"+(i+1)+"個元素是" + arr[i]);
  }
  int index = 0;
  for (int j = 0; j < arr.length; j++) {
   System.out.println("第" + index + "個元素是" + arr[index]);
   index++;
  }
 }
}

1 陣列的宣告
陣列的長度陣列中資料的個數
陣列中的每一個資料稱為元素
陣列中每一個元素都使用下標來確定它在陣列中的位置 0 - 陣列的長度-1
語法：

型別 [] 陣列名字 =new 型別[int value]   宣告時給定長度  
型別 [] 陣列名字 =new 型別[]{value...}   宣告的時候根據實際給陣列中方的資料的個數來確定陣列的長度

eg:

//宣告一個長度為5的陣列，型別是int型別
int[] nums=new int[5];//只有大小和型別，沒有具體的資料，擁有預設值
int[] nums={10,20,30}//不推薦使用
//int nums[]          int    []    nums
int nums[]=new int[]{12,20,30,40,50};//在建立的時候就明確陣列的長度和陣列中的資料

//陣列長度的改變
public class array0 {
 public static void main(String[] args) {
  //陣列的預設長度是null，陣列元素的預設值是根據陣列的型別而定
  //GC垃圾回收機制                   new（就會建立一個新的例項 ，儲存到堆內容中）
  int [] a=null;
  a=new int[3];
  System.out.println("陣列的地址是"+a);
  System.out.println("陣列的長度是"+a.length);
  a=new int[5];
  System.out.println("陣列的地址是"+a);
  System.out.println("改變後陣列的長度是"+a.length);
  int [] temp=new int[3];
  a=temp;
  System.out.println("陣列的地址是"+a);
  System.out.println("陣列的長度是"+a.length);}}

2.陣列的具體使用

陣列不能一次給所有元素賦值只能挨個賦值
陣列中可以根據元素的下標給指定位置的元素賦值
陣列一旦建立其長度不能改變
a.賦值
b.查詢

public class array01 {
 public static void main(String[] args) {
  int[] arr = new int[5];// 宣告一個int型別的陣列
  
  System.out.println("陣列的長度為" + arr.length);
  //賦值
  arr[0] = 12;// 給陣列的第一個元素賦值
  arr[1] = 44;
  arr[2] = 20;
  arr[4] = 33;
  //查詢（根據下標查詢）
  System.out.println("第一個元素是" + arr[0]);
  System.out.println("第四個元素是" + arr[3]);
  
  // 陣列的遍歷
  for (int i = 0; i < arr.length; i++) {
   System.out.println("第"+(i+1)+"個元素是" + arr[i]);
  }
  int index = 0;
  for (int j = 0; j < arr.length; j++) {
   System.out.println("第" + index + "個元素是" + arr[index]);
   index++;
  }
 }
}

當要查詢的陣列元素下標的值超過陣列的元素下標最大值報異常陣列元素下標越界異常

3.二維陣列----------多維陣列
陣列中的元素是陣列稱為二維陣列
語法：資料型別 [] 名字 = new 資料型別[5]; String [] stus=new String[5]; 資料型別 [][] 名字 =new 資料型別[3][2];

public class numArray {
 public static void main(String[] args) {
  //院系
  String[][][]yx=new String[2][2][2];
  //建立班級
  String[] stuclass1=new String[] {"stu1","stu2"};
  String[] stuclass2=new String[] {"stu3","stu4"};
  String[] stuclass3=new String[] {"stu5","stu6"};
  String[] stuclass4=new String[] {"stu7","stu8"};
  //建立專業
  String[][] major1=new String[2][2];
  String[][] major2=new String[2][2];
  //數學專業
  major1[0]=stuclass1;
  major1[1]=stuclass2;
  //物理專業
  major2[0]=stuclass3;
  major2[1]=stuclass4;
  //院系
  yx[0]=major1;
  yx[1]=major2;
  System.out.println(yx[0][1][0]);
  //迴圈
  for (int i = 0; i < yx.length; i++) {
   System.out.println("專業========================");
   for (int j = 0; j <yx[i].length; j++) {
    System.out.println("班級=========================");
    for (int k = 0; k < yx[i][j].length; k++) {
     System.out.println(yx[i][j][k]);
    }
   }
   System.out.println("*************************************");
  }
 }
}

二維陣列的子陣列的長度是可以發生變化，子陣列的實際表示的陣列是可以重新賦值的。陣列長度不可變，是指你當前所引用的陣列的長度不可變，一旦引用發生改變陣列的長度就改變了
陣列與陣列之間的拷貝

public class ArrayCope {
 public static void main(String[] args) {
  int [] num1=new int[] {10,20,30,40,50};
  int [] num2=new int[] {100,200,300};
  //大陣列----小陣列
  //小陣列----大陣列
  //num1----num2把哪些陣列賦值過去
  System.out.println("==========num1----num2把哪些陣列賦值過去=============");
  for (int i = 0; i < num2.length; i++) {
   num2[i]=num1[i];
   System.out.print(num2[i]+"\t");//10   20   30
  }
    //30  40-----200   300
    //注意一定不要越界
  System.out.print("\n");
  System.out.println("==========30  40-----200   300=============");
    for (int i =1; i < num2.length; i++) {
     num2[i]=num1[i+1];
    }
    //增強for迴圈（foreach）：將陣列全部輸出，不能做到單獨取幾個數
    for (int i : num2) {
     System.out.print(i+"\t");
    }
    System.out.println("\n");
    System.out.println("==========陣列的長度=============");
    System.out.println(num1.length+" "+num1[0]);
    System.out.println(num2.length);
  //交換陣列的值和長度
    System.out.println("========交換陣列的值和長度==============");
    int []temp=null;
    temp=num1;
    num1=num2;
    num2=temp;
    System.out.println(num1.length+" "+num1[0]);
    System.out.println(num2.length);
  }
 }

4.陣列的交換
陣列的引用交換
在這裡插入圖片描述
5.陣列的排序
int[] grand =new int[]{10,5,48,16,20};
排序：正序（從小到大asc）和逆序 (從大到小desc)
外層迴圈控制需要比較的次數，內層迴圈是用類每一遍具體比較交換的操作
a.氣泡排序
氣泡排序（Bubble Sort），是一種電腦科學領域的較簡單的排序演算法。
依次比較兩個相鄰的元素，如果是正序第一比第二大交換否則不交換。每一次比較完叫陣列中的最大值方法最後。下一次比較的時候就不需要比較上次最大的值。

//每一次實際比較交換的操作  每一次都是從第一個元素開始到上一次最大值前一個
public class maoPaoSort {
 public static void main(String[] args) {
  int []grade=new int[] {4,23,54,18,46};
   System.out.println("=====================排序前===================");
   for (int stu : grade) {//增強for迴圈，輸出grade裡面的全部元素
    System.out.print(stu+"     ");
   }
    System.out.println();
   System.out.println("=====================排序====================="); 
   int count=0;
   //外層迴圈迴圈一次，內層迴圈迴圈一遍
   for (int i = 0; i < grade.length-1; i++) {//外層迴圈
    for (int j = 0; j < grade.length-1-i; j++) {//內層迴圈
      if(grade[j]>grade[j+1]) {
      int temp=0;
      temp=grade[j+1];
      grade[j+1]=grade[j];
      grade[j]=temp;
         }
      count++; 
    }
   }
   System.out.println("總共比較的次數是："+count);
   System.out.println("===================排序後==================");
   for (int stu : grade) {
    System.out.print(stu+"      ");
   }
  }
}

b.選擇排序
ASC 每一次比較選擇一個位置的元素與後面的每一個元素進行比較，如果當前元素比後面的元素大就交換，每一次比較完將本次的最小值放到當前位置。
其實從0小開始，以後的每一次比較都從下一個元素開始

public class chooseSort {
 public static void main(String[] args) {
  int []array=new int[] {45,12,78,66,11,30};
  System.out.println("=====================排序前===================");
  for (int stu : array) {//增強for迴圈，輸出grade裡面的全部元素
   System.out.print(stu+"     ");
  }
   System.out.println();
  System.out.println("=====================排序====================="); 
  int count=0;
  //外層迴圈迴圈一次，內層迴圈迴圈一遍
  for (int i = 0; i < array.length-1; i++) {//外層迴圈
   for (int j =i; j < array.length-1; j++) {//內層迴圈
     if(array[i]>array[j+1]) {
        int temp=0;
     temp=array[i];
     array[i]=array[j+1];
     array[j+1]=temp;
        }
     count++; 
   }
  }
  System.out.println("總共比較的次數是："+count);
  System.out.println("===================排序後==================");
  for (int stu : array) {
   System.out.print(stu+"      ");
  }
}
}

public class Sort {
public static void main(String[] args) {
int[] grade = new int[] { 4, 8, 6, 3, 5, 7, 9 };// 宣告一個int型別的陣列容量為7
  System.out.println("排序前：");
  for (int stu : grade) {// 增強for迴圈遍歷輸出
   System.out.print(stu + "   ");
  }
  System.out.println("");
  System.out.println("=========================");
  int compare = 0;// 建立一個標記，記錄比較次數
  int exchange = 0;//建立一個標記，記錄交換次數
  int i;
  for (i = 0; i < grade.length; i++) {//外層迴圈控制min標記符的起始下標
   int min = i;// 建立一個標記，記錄最小值下標 採用正序
   for (int j = i + 1; j < (grade.length); j++) {//內層控制陣列的變化
    if (grade[j] < grade[min]) {//將陣列值進行比較
     min = j;//小的一方的索引值由min儲存
    }
    compare++;//每比較一次compare數值加一
   }
   if (min != i) {
   int temp = 0;// 定義一箇中間變數
    temp = grade[i];// 交換
    grade[i] = grade[min];
    grade[min] = temp;
    exchange++;//每交換一次exchange數值加一
   }
  }
  for (int l : grade) {//輸出排序後的陣列
   System.out.print(l + "   ");
  }
  System.out.println("");
  System.out.println("比較次數：" + compare);//輸出比較次數
  System.out.println("交換次數：" + exchange);//輸出交換次數
  }
  }

c.插入排序
d.使用標記進行排序操作

Golang 陣列和字串之間的相互轉換[]byte/string
2018-09-24
Golang陣列字串
C#位元組陣列byte[]和字串string如何互相轉換
2020-09-26
C#陣列字串
陣列和字串
2024-08-03
陣列字串
C++陣列字串
2024-07-13
C++陣列字串
字元陣列與字串
2024-06-13
字元陣列字串
shell切分字串到陣列
2019-10-07
字串陣列
LeetCodet探索——陣列與字串
2020-11-05
LeetCode陣列字串
PHP 陣列 & 字串處理
2019-04-03
PHP陣列字串
JS陣列字串方法整理
2018-03-22
JS陣列字串
string與char陣列相互轉換
2019-03-20
陣列
將字串陣列轉換為浮點數陣列
2022-04-06
字串陣列
u8 陣列轉換成 string
2019-12-23
陣列
string 字串
2024-06-07
字串
String字串
2020-12-24
字串
JavaScript split() 分割字串生成陣列
2019-11-08
JavaScript字串陣列
JavaScript 字串轉換為陣列
2019-12-28
JavaScript字串陣列
json字串轉換為陣列
2018-10-18
JSON字串陣列
字串和陣列常用方法整理
2019-01-04
字串陣列
PHP 陣列排序（複雜字串）
2018-11-26
PHP陣列排序字串
資訊學奧賽複賽複習01-CSP-J2019-01-字元、字元陣列、字串、string、字串讀取
2024-09-23
字元陣列字串
指標陣列練習排列字串
2024-05-20
指標陣列字串
重拾Kotlin（3）-陣列、字串模板
2021-09-09
Kotlin陣列字串
JavaScript2：變數、陣列、字串
2018-11-14
JavaScript變數陣列字串
shell 使用陣列及字串擷取
2019-02-01
陣列字串
面試必備：陣列和字串
2018-08-20
面試陣列字串
JavaScript將陣列轉換為字串
2018-05-22
JavaScript陣列字串
js 陣列,字串,json互相轉換
2018-04-23
陣列字串JSON
JavaScript String 字串
2018-08-27
JavaScript字串
PHP中文字串轉陣列
2024-03-26
PHP字串陣列
字串陣列轉為樹形結構
2020-07-05
字串陣列
1.11 JavaScript2：變數、陣列、字串
2018-11-09
JavaScript變數陣列字串
陣列與字串方法與相互轉換
2019-01-16
陣列字串
JS中字串和陣列的常用方法
2019-03-30
JS字串陣列
C# 字串（String）
2024-06-14
C#字串
JavaScript 字串(String) 大全
2019-08-05
JavaScript字串
String：字串型別
2020-10-29
字串型別
Java-string字串
2018-12-17
Java字串
工作中常用的字串和陣列方法
2024-11-27
字串陣列

String字串，陣列

一.String字串

二.陣列

相關文章