## 一維陣列

```java
陣列的定義: 資料型別 陣列名[] = new 資料型別[大小]
```

```java
陣列細節
//1.陣列是多個相同型別資料的組合，實現對這些資料的統一管理
int[] array1 = {1,34,678,54};//編譯通過
//2. 陣列中的元素可以是任何資料型別，包括基本型別和 引用型別，但是不能混用
String[] a = {"名字","hello"};
//3.陣列建立後如果沒有賦值 有預設值
// int 0, short 0, byte 0, long 0,float 0.0,double 0.0,
// char \u0000, boolean false, String null
//6.陣列下標必須在指定範圍內使用，否則報:下標越界異常，比如
// int [] arr=new int[5]; 則有效下標為0-4 陣列越界是容易犯的錯誤
//即陣列的下標/索引 最小是0 最大是 陣列長度-1
int[] arr = new int[5];
System.out.println(arr[4]);
//7.陣列屬引用型別，陣列型資料是物件(object)
```

## 陣列賦值

```java
//基本資料型別規值，賦值方式為值拷貝 拷貝的是具體資料
//--->n2的變化,不會影響到n1的值
int n1 = 10;
int n2 = n1;
n2 = 8;
System.out.println("n1=" + n1 + " " + "n2=" + n2);//n1 = 10 n2 = 8;

//陣列在預設情況下是引用傳遞， 賦的值是地址，賦值方式為引用賦值 拷貝的是地址
//是一個地址，--->arr2變化會影響到arr1的值 =====>相當於一個空間兩個入口
int arr1[] = {1,2,3};
int arr2[] = arr1;//把arr1 賦給了arr2
arr2[0] = 10;
System.out.println("====arr1的元素=====");
for(int i = 0;i < arr1.length;i++){
System.out.print(arr1[i] + " ");//10,2,3
}
```

## 陣列拷貝

```java
int[] arr1 = {10,20,30] 拷貝到arr2陣列，// 要求資料空間是獨立的.
/**思路分析：
1、建立一個數組arr2 開闢新的資料空間 大小為arr1.length
int[] arr2 = arr1 =====> 這樣的話，空間就是共享的了
2、遍歷 arr1 把每個元素拷貝到 arr2 對應的元素位置
3、修改arr2 的元素
4、遍歷輸出 arr1 arr2 的值
*/
int[] arr1 = {10,20,30};
int[] arr2 = new int[arr1.length];
for(int i = 0;i < arr1.length;i++){
arr2[i] = arr1[i];//將arr1 中的元素拷貝到 arr2 中
}
arr2[0] = 100;
for(int i = 0;i < arr1.length;i++){
System.out.println(arr1[i]);
}
for(int i = 0;i < arr2.length;i++) {
System.out.println(arr2[i]);
}
```

## 陣列翻轉

```java
int[] arr = {11,22,33,44,55,66};
//1、建立一個數組 arr2 大小====arr.length
//2、逆序遍歷arr,將arr的每個元素拷貝到arr2的元素中(順序拷貝)
//3、建議增加一個迴圈變數j---> 0-5 正向遍歷
int[] arr2 = new int[arr.length];
//(arr.length - 1) 陣列的長度為6 而陣列的最後一位是arr[5];也就是長度-1
for(int i = arr.length - 1, j = 0; i >= 0; i--,j++){
arr2[j] = arr[i];//將 arr 中的元素拷貝到 arr2中
}
//4、當for 迴圈結束時 arr2就是一個逆序的陣列{66,55,44,33,22,11}
//5、讓arr 指向arr2 的空間 此時 arr原來的資料空間就沒有變數引用
arr = arr2;//空間指向
//6、遍歷輸出
System.out.println("arr的元素情況");
for(int i =0 ;i < arr.length;i++){
System.out.print(arr[i] + " ");
}
```

## 陣列擴容

```java
/**
要求:實現動態的給陣列新增元素效果，實現對陣列擴容。ArrayAdd.java
1)原始陣列使用靜態分配int[] arr = {1,2,3}
2)增加的元素4，直接放在陣列的最後arr = {1,2,3,4}
3)使用者可以通過如下方法來決定是否繼續新增，新增成功，是否繼續? y/n
*/
/**思路分析
1、定義初始陣列 int[] arr = {1,2,3};
2、創設一個新的陣列 int[] arr2 = new int[arr.length+1]
3、遍歷arr陣列 依次將arr陣列中的元素拷貝到arr2中
4、把4賦給 arr2[arr2.length-1]=4;把4賦得arr2最後一個元素
5、將 arr 指向 arr2 ; arr = arr2; 原來的陣列就成為垃圾啦
6、建立一個Scanner 來接收使用者輸入
7、因為不確定使用者什麼時候推出程式 所以用 do-while + break 來控制
*/
Scanner myScanner = new Scanner(System.in);
//1、創設陣列
int[] arr = {1,2,3};
do{
//2、創設新的陣列
int[] arr2 = new int[arr.length+1];
//3、迴圈遍歷
for(int i = 0;i < arr.length;i++){
//4、資料拷貝
arr2[i] = arr[i];
}
System.out.println("請輸入你要新增的元素");
int ele = myScanner.nextInt();//這裡用int
//5、賦值
arr2[arr2.length-1]=ele;//賦值
//6、空間指向(地址)
arr = arr2;
//7、遍歷輸出
System.out.println("====arr擴容後元素情況=====");
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + " ");
}
System.out.println("是否要繼續新增 N/Y");
int key = myScanner.next().charAt(0); //這裡用char不要用int
if(key == 'N'){
break;
}
}while(true);
System.out.println("你退出了新增");
```

## 陣列縮減

```java
// 有一個數組{1, 2, 3, 4, 5}可以將該陣列進行縮減，
/**思路分析
* 初始化陣列
* 遍歷 arr 陣列，依次將arr的元素拷貝到 arrNew陣列
* 空間指向(地址)
* 遍歷輸出arr 看看效果
* 問使用者是否繼續
*/
Scanner myScanner = new Scanner(System.in);
int[] arr = {1, 2, 3, 4, 5};
do {
int[] arrNew = new int[arr.length - 1];
for(int i = 0; i < arr.length-1; i++) {
arrNew[i] = arr[i];
}
System.out.println("請輸入你要縮減的元素");
int ele = myScanner.nextInt();
arr = arrNew;
System.out.println("====arr縮減後元素情況====");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println("是否繼續縮減 y/n");
char key = myScanner.next().charAt(0);
if( key == 'n' ) {
//如果輸入n ,就結束
System.out.println("你退出了新增...");
break;
}else if(arr.length==1){

System.out.println("只有一個元素，不能再縮減");
break;
}
}while(true);
```