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.使用標記進行排序操作

相關文章