一维数组及其运算

## 一维数组

```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){