java學習筆記(四)數組

數組

數組是一組數據類型相同的數據的組合，將這些數據統一管理起來
數組本身是一個引用數據類型，數組內存儲的類型可以是基本類型 也可以是引用類型
1.數組是一個引用數據類型
2.數組是在堆內存中的一串連續的地址存在
4.數組在初始化時必須指定長度
4.堆內存的數組長度一旦確定 不能再次發生改變
5.棧內存的變量中存儲的是數組的地址引用
6.數組內部存儲的類型可以是基本的 也可一是引用

1.數組的定義(聲明)

數據類型[] 數組名字
int[] x;
char[] y;
boolean[] z;
String[] m;

int[] x; ---->比較規範
int x[];
int []x;

2.數組的賦值(初始化)

靜態初始化 有長度 有元素
     int[] array=new int[]{10,20,30,40,50};
     int[] array={10,20,30,40,50};
     
     int[] array;
     一百行
     array=new int[]{};//此時編譯器無法確定變量類型，必須要創建(new)
動態初始化 有長度 沒有元素(不是真的沒有 默認值)
    int[] array =new int[5];
    整數默認值---0
    浮點數默認值---0.0
    字符型默認值---  0--char 97-a   65-A  48-'0'      
    布爾型默認值---false
    引用數據默認值---null

3.數組元素的訪問

通過元素在數組中的位置來訪問
位置---->index索引
索引是有取值範圍的 [從0開始----數組長度-1]
如果數組的索引超過了上述範圍
會出現一個運行時異常 ArrayIndexOutOfBoundsException

4.數組元素的遍歷(輪詢)

通過循環的方式訪問數組的每一個元素
for(;;){
}
JDK1.5版本 javaSE5.0 增加了新的特性： 增強for循環 加強for forEach
for(自己定義的變量(接收數組內每一個元素):遍歷數組array){
}

正常的for循環已及加強的for循環都要熟練掌握
1.正常的for　　有三個必要條件 index索引 找到某一個元素的位置
　　　　　　　　可以通過index直接訪問數組的某一個位置 取值 存值都可以
　　　　　　　　不好在於寫法相對來說比較麻煩
2.增強for　　  有兩個條件　用來取值的變量　用來遍歷的數組 沒有index索引
　　　　　　　 好處寫法相對比較容易
　　　　　　　 不好只能取值 不能存值
　　　　　　　 沒有index索引 找不到元素哪一個

public class TestArray{
    public static void main(String[] args) {
         String[] array=new String[5] ;
         for(String value:array){
            System.out.println(value);
         }

//        int[] array=new int[]{10,20,30,40,50};
       //通過元素在數組中的位置index(索引 下標)來訪問
       //array[index] index從0開始
       //從數組內取得某一個位置的元素
       //int value =array[0];
       //System.out.println(value);
       //向數組內的某一個位置存入元素
       //array[3] = 400;
       //索引有範圍的
       
       //int value=array[5];
       //System.out.println(value);
       //異常 ---運行時異常   
       //ArrayIndexOutOfBoundsException 數組索引越界
       //index索引  0開始----數組(長度-1)結束  
       
       //將數組中的每一個元素都拉出來看一看
     /*
       for(int index=0;index<array.length;index++ ){ //每一次做一樣的事情 取數組的值 5次 
          int value =array[index];
          System.out.println(value);
       }    
       System.out.println("-----我是一個華麗的分隔符-----");
       
       for(int value:array){
       System.out.println(value);
       }
       */
    }
}

5.基本數據類型和引用數據類型在內存結構上的區別

所有的變量空間存儲在棧內存
變量空間可以存儲基本數據類型 可以存儲引用數據類型
如果變量空間存儲的是基本數據 存儲的是值 一個變量改變 另一個不會跟着改變
如果變量空間存儲的是引用數據類型 存儲的是引用(地址) 一個變量地址對應的值改變 另一個跟着改變

public class TestArray2{
    public static void main(String[] args) {
         int a = 10;
         int b=a;
             b=100;
         System.out.println(a);//? 10
 
         int[]x=new int[]{10,20,30};
         //棧內存中的小容器 類型定義了只能存儲這種東西 容器中只能存一份
         //見到new 關鍵字 相當於 在 堆內存中申請開闢一塊新的空間
         //數組在堆內存的空間形態 是一串連續的地址
         //基本類型變量空間存儲的是值 傳遞的是值 一個改變 另一個不變
         //引用類型變量空間存儲的是地址(引用) 傳遞的就是引用 一個改變 另一個跟着改變
         int[] y =x;
         y[0] =100;
         System.out.println(x[0]);//?100

    }
}

需求 容器(變量 數組)

1.創建一個數組 用來存儲1-100之間的偶數

public class SavaNum {
   public static void main(String[] args) {
        //1.需要創建一個數組
        int[] array =new int[50];
        //2.需要將1-100之間的偶數存入數組內
       for(int i=0;i<array.length;i++) {//執行50次 
          array[i]=2*i+2;
       }
       for(int value:array){
          System.out.println(value);
       }

   }
}

設計程序的時候出現的小問題
 1.創建一個數組    動態初始化????
         元素個數比較少 靜態 元素個數很多有規律 動態  元素很多沒規律
 2.用了兩個循環 一個只爲了存值 另一個只爲了輸出看一看
         存放時直接看結果可能由於存放誤操作---看時正確 之後就發生變化
         存放不一定必須要查看 存放是一件事情 查看是另一件

2.數組練習

0.創建一個數組來存儲1-100的奇數

public class SavaNum {
   public static void main(String[] args) {
        //1.需要創建一個數組
        int[] array =new int[50];
        //2.需要將1-100之間的奇數存入數組內
       for(int i=0;i<array.length;i++) {//執行50次 
          array[i]=2*i+1;
       }
       for(int value:array){
          System.out.println(value);
       }

   }
}

---

1.給定兩個數組a{1,2,3,4} b{5,6,7,8} 將兩個數組內的元素對應位置調換

public class Practice1 {
        public static void main(String[] args) {
         //給定兩個數組a{1,2,3,4} b{5,6,7,8} 將兩個數組內的元素對應位置調換
         //1.靜態初始化兩個數組
          int[] a={1,2,3,4};
          int[] b={5,6,7,8,9};

          //2.元素對應index位置的互換 每一次交換兩個數字 4次
          //方式一 交換數組中對應的元素(循環次數好多次 受長度限制)
          /*for(int i=0;i<a.length;i++){
                 a[i]=a[i] ^  b[i];
                 b[i]=b[i] ^  a[i];
                 a[i]=a[i] ^  b[i];     
          }*/
          //方式二 直接交換變量a和b中的數組引用(地址) 沒有循環一次搞定 不受長度限制(兩個數組長度要相同)
          int[] temp =a; 
          a=b;
          b=temp; 

//        3.輸出查看
          for(int i:a){
            System.out.println("a  " + i);
          }
          for(int i:b){
            System.out.println("b  " + i);
          }
       }
}

---

2.給定一個數組a{1,2,3,4,5,6}將兩個數組中的元素頭尾對應互換位置

public class Practice2 {
        public static void main(String[] args) {
         //給定一個數組a{1,2,3,4,5,6}將兩個數組中的元素頭尾對應互換位置
         //1.靜態初始化一個數組
          int[] a={1,2,3,4,5,6};
          //2.循環做一件事 將素頭尾對應元素調換
          for(int i=0;i<a.length/2;i++){
//               頭尾對應互換0<-->5 1<-->4 2<-->3
                 a[i]=a[i] ^  a[a.length-1-i];
                 a[a.length-1-i]=a[a.length-1-i] ^  a[i];
                 a[i]=a[i] ^  a[a.length-1-i];     
          }
//        3.輸出查看
          for(int v : a){
            System.out.println(v);
          }
       }
}

3.給定一個數組a{1,2,3,4,5,6}計算所有數組元素的平均值

public class Practice3{
       public static void main(String[] args) {
          //給定一個數組a{1,2,3,4,5,6}計算所有數組元素的平均值
          //靜態初始化一個數組a
          int[] a={1,2,3,4,5,6};
          //計算平均值 1.取出所有以元素相加 2.相加的和除以元素個數即爲平均值
          int num=0;
           for(int aa :a ){
              num+=aa;
           }
          System.out.println("平均值爲 "+num/a.length); // 21/6 = 3
    }
}

4.給定一個數組a{1,2,5,7,9,0,2,4,6,8}找尋數組中的最大值和最小值

public class Practice4 {
      public static void main(String[] args) {
            //給定一個數組a{1,2,5,7,9,0,2,4,6,8}找尋數組中的最大值和最小值
            //買一件襯衫  百貨商城 最便宜的
            //第一家  200元  記錄一下200 (筆記本 腦子裏) 
            //第一家  180元  如果比記錄的這個便宜 抹去記錄信息 重新記錄
            //第一家  250元  如果比記錄的筆記本數據貴 繼續找下一家  
            //第一家  50元   如果比筆記本便宜 抹去 重新記錄  筆記本50
            //以上是思路分析
            //靜態初始化一個數組
            int[] a = {3,2,5,7,9,1,2,-4,6,8};
     
            //1.創建一個變量 當做筆記本 記錄信息
            int max =a[0];   //記錄最大     
            int min =a[0];   //記錄最小 
            //2.挨個尋找數組中的元素 與變量中的元素進行比較    
            for(int i=0;i<a.length;i++)  {
                 if(a[i]>max){
                    max=a[i];
                 }
                 if(a[i]<min){
                    min=a[i];
                 }
               }
           System.out.println("最大"+max);
           System.out.println("最小"+min);
    }
}

5.給定兩個數組a{1,2,3} b{4,5}合併兩個數組(創建一個新的數組5長度)

public class Practice5 {
       public static void main(String[] args) {
            //給定兩個數組a{1,2,3} b{4,5}合併兩個數組(創建一個新的數組5長度)
            //1.靜態初始化兩個數組
            int[] a={1,2,3};
            int[] b={4,5};
           //2.因爲數組長度一旦確定 不能再次改變  需要創建新數組 長度等於a 和 b的總長度
            int[] newArray =new int[a.length+b.length]; //只有長度 元素默認值是0
             //3.思路二 想將新數組填滿
            for(int i=0;i<newArray.length;i++){
               if(i<a.length) {//新數組索引位置還沒有a數組長度範圍以外
                 newArray[i]=a[i];
               }else{
                 newArray[i] =b[i-a.length];
               }
            }

           //3.思路一 分別將a和b數組的元素存入新數組內
           /* 
            for(int i=0;i<a.length;i++){//將a數組的元素存入新數組內
               newArray[i]=a[i];
            }//newArray--->{1,2,3,0,0}
            for(int i=0;i<b.length;i++){ //將b數組的元素存入後面位置
               newArray[a.length+i] =b[i];
            }*/
            //輸出查看
           for(int v:newArray){
              System.out.println("newArray  "+v); 
           }
       }
}

6.給定一個數組a{1,2,3,9,4,5}按照數組中的最大值的位置，將數組拆分成兩個{1,2,3}{4,5}

public class Practice6 {
       public static void main(String[] args) {
            //給定一個數組a{1,2,3,9,4,5}按照數組中的最大值的位置，將數組拆分成兩個{1,2,3}{4,5}
            
            //1.需要一個數組 
           int[] oldArray ={1,2,3,9,4,5};

            //2.找尋最大值的索引位置-->爲了通過這個位置 確定兩個小數組的長度
            int max   =oldArray[0]; //數組的第一個元素值
            int index =0;// 數組的第一個索引的位置
            for(int i=0;i<oldArray.length;i++) {
                  if(oldArray[i]>max){
                     max=oldArray[i];
                     index=i;
                  }
             }
           System.out.println("最大值    "+max);
           System.out.println("最打值位置 "+index);
            //3.需要兩個小數組分別承載元素
            int[]  newa =new int[index];
            int[]  newb =new int[oldArray.length-index-1];
            //分別將兩個小數組填滿
            for(int i=0;i<newa.length;i++)  {
                newa[i]=oldArray[i];
            }
              
            for(int i=0;i<newb.length;i++)  {
                newb[i]=oldArray[(index+i)+1];
            }
           for(int v:newa){
              System.out.println("newa  "+v); 
           }
            for(int v:newb){
              System.out.println("newb  "+v); 
           }
       }
}

7.給定一兩數組a{1,2,3,0,0,4,5,0,6,0,7}去掉數組中的0元素(創建一個新的數組 非零元素挑出來)

public class Practice7 {
       public static void main(String[] args) {
            //1.需要一個數組 
           int[] oldArray ={1,2,3,0,4,5,6,0,6,7,8,0,9,10,11};
           //2.找尋原數組中的非零元素個數---->才能確定新數組的長度
           //思路二 創建一個足夠長的數組
            int[] newArray=new int[oldArray.length];
            int index=0; //控制新數組的索引變化
            for(int i=0;i<oldArray.length;i++){
                if(oldArray[i]!=0){
                   newArray[index++]=oldArray[i];
                }
            }         
           int[] newArray2=new int[index];

            for(int i=0;i<index;i++){
                   newArray2[i]=newArray[i];
            } 

 /*         int count=0;//記錄原數組非零個數
          for(int i=0;i<oldArray.length;i++ ){
             if(oldArray[i]!=0){
               count++;
             }
          }
          System.out.println("原數組非零個數  "+count);
          //3.創建一個新數組 裝原數組中的非零元素
          int[] newArray=new int[count];  //擴展二 創建一個足夠長的數組
          //4.將原數組中非零元素挑出來 存入新數組
          int index=0; //控制新數組的索引變化
          for(int i=0;i<oldArray.length;i++){
             if(oldArray[i]!=0){
                newArray[index++]=oldArray[i];
               
             }
          }
*/
          //5.舊數組沒有用 刪掉
          oldArray=null;  //清除引用
          newArray=null;
         //驗證新數組
         for(int v: newArray2){
           System.out.println(v);
         }
         
    }
}

8.創建一個數組 存儲2-100之間的素數(質數)

public class Practice8 {
      //創建一個數組 存儲2-100之間的素數(質數)
       public static void main(String[] args) {
          //思路一  空間佔用小 執行效率慢     
         //0.通過一個幾千次的循環找尋一個---count
         //1.創建一個數組 長度(剛剛好 沒有一個多餘的空間)
         //2.通過一個幾千次的循環找尋素數 將素數存入數組內
         
         //思路二  執行效率高 空間佔用大
         //0.創建一個足夠長的數組
         //1.通過一個幾千次的循環找尋素數 將素數存入數組內
         //2.將存入素數的數組 後面部分0元素去掉
         //0
         int [] primeNumberArray=new int[50];
          //2.找尋2-100之間素數的個數 將找到的素數存入數組內

          int index=0;//創建一個新的變量 記錄素數數組的索引變化 同時記錄素數個數
          for(int num=2;num<=100;num++){ //從2--100之間找尋還有沒有其他可以被整除的數
              boolean bl = false; //標識 用來記錄最初的狀態 
              for(int i=2; i<=num/2 ;i++){ 
                 if(num%i==0){  //如果還有能整除的數字 證明num不是素數
                      bl=true; //如果滿足條件(找到整除 證明不是素數 改變標識)
                      break;
                  }
               }     
                if(!bl){//如果標識與最初的一致 證明循環內的if從來沒有執行過
                   primeNumberArray[index++] =num;
                }

          }  

          int[] newArray =new int[index];

           for(int i=0;i < newArray.length;i++){
               newArray[i]  =primeNumberArray[i];
           } 

          primeNumberArray=null;
          for(int v :newArray){
             System.out.println(v);
          } 

          /*
          //0.找尋2-100之間素數的個數---->確定數組長度
          int count=0; //用來記錄素數的個數
          for(int num=2;num<=100;num++){ //從2--100之間找尋還有沒有其他可以被整除的數
              boolean bl = false; //標識 用來記錄最初的狀態 
              for(int i=2; i<=num/2 ;i++){ 
                 if(num%i==0){  //如果還有能整除的數字 證明num不是素數
                      //System.out.println(num+"不是素數");
                      bl=true; //如果滿足條件(找到整除 證明不是素數 改變標識)
                      break;
                  }
               }     
                if(!bl){//如果標識與最初的一致 證明循環內的if從來沒有執行過
                    //System.out.println(num+"是素數");
                   count++;
                }
          }

         System.out.println("經過找尋 2-100之間的素數個數爲 "+count);
          //1.創建一個數組 存素數
          int [] primeNumberArray=new int[count];
           
          //2.找尋2-100之間素數的個數 將找到的素數存入數組內
          int index=0;//創建一個新的變量 記錄素數數組的索引變化 
          for(int num=2;num<=100;num++){ //從2--100之間找尋還有沒有其他可以被整除的數
              boolean bl = false; //標識 用來記錄最初的狀態 
              for(int i=2; i<=num/2 ;i++){ 
                 if(num%i==0){  //如果還有能整除的數字 證明num不是素數
                      //System.out.println(num+"不是素數");
                      bl=true; //如果滿足條件(找到整除 證明不是素數 改變標識)
                      break;
                  }
               }     
                if(!bl){//如果標識與最初的一致 證明循環內的if從來沒有執行過
                    //System.out.println(num+"是素數");
                   primeNumberArray[index++] =num;
                }

          }    
          //輸出驗證
          for(int v :primeNumberArray){
             System.out.println(v);
          }     
          */ 
    }
}

9.數組元素的排序(冒泡 選擇 插入 快速 希爾 堆排序 桶排序 歸併排序 遞歸…

import java.util.Scanner;

public class Practice10 {
       public static void main(String[] args) {
           //1.需要一個數組保存賬號和密碼 相當於一個小數據庫
           String[] userBox ={"java","騰訊課堂","test"};
           int[] passwordBox ={123,666,888} ; 
           //輸入賬號和密碼
           Scanner input =new Scanner(System.in);
           System.out.println("請輸入賬號");
           String user= input.nextLine();
           System.out.println("請輸入密碼");
           int password=input.nextInt();
           //3.比較
           boolean bl=false;
           for(int i=0;i<userBox.length;i++){
               if(userBox[i].equals(user)){  //賬號存在
                    if(passwordBox[i]==password){  //密碼正確
                         System.out.println("登錄成功");
                         bl=true;
                    }
                    //賬號對了，就結束循環
                    break;  
               }
           }
           if(!bl){
               //用戶名 或 密碼有一個不對 需要輸出
               //bl標記的值與最初的一樣 沒有改
               System.out.println("用戶名不存在或密碼錯誤");
           }
      }
}

10.用戶的登錄認證(用數組當做小數據庫 存值 用戶驗證)