1.概念：
（1）一维数组
定义一组数据，且全都是同一种类型。
数组是一种引用类型，如果不知道引用对象，可以用null来初始化，但千万别用0来赋值，因为0是整型。
每个数据的下标都是从0开始的。这个概念还是跟c语言的类似。
数组名存的是一个地址。数组名传参，传的就是地址。
（2）二维数组
定义一组数据，且全都是同一种类型。
数组是一种引用类型，如果不知道引用对象，可以用null来初始化，但千万别用0来赋值，因为0是整型。
数组名存的也是地址，是每个元素（一维数组）的地址。数组名传参，传的就是地址。
每个数据的下标都是从0开始的。这个概念还是跟c语言的类似。
2.数组的定义方式
（1）一维数组
这是定义一维数组的方式。
（2）二维数组
最后一种不太规则，可以随意指定列为多少。也就是二维数组的每个一维数组的大小可以随意制定，比如：
代码：
public static void main(String[] args) {
int[][] array4 =new int[3][];
array4[0]= new int[4];
array4[1]= new int[14];
array4[2]= new int[1];
System.out.println(Arrays.deepToString(array4));
}
结果：
3.获取数组长度
（1）一维数组
数组名.length
（2）二维数组
如果我们每次都要人为来数行和列，未免太麻烦了。
如果一维数组的长度是通过数组名.length实现的，那二维数组呢？
我们通过以下代码来试探一下：
int[][] array4 ={{1,2},{3,4,6},{5}};
System.out.println(array4.length);
结果：
这个数字和该数组的行有关系，经过测试，我们可以知道这个就是二维数组的行大小。
那怎么获取二维数组的列呢？
我们通过行来实现
这下我们可以理解为什么通过行来实现了。
我们来试一下：
代码：
int[][] array4 ={{1,2},{3,4,6},{5}};
System.out.println(array4[0].length);
System.out.println(array4[1].length);
System.out.println(array4[2].length);
结果：
4.数组的遍历方式
（1）一维数组
①普通遍历方式
int[] array4 ={1,2,3,4};
for(int i = 0;i<array4.length;i++){
System.out.print(array4[i]+" ");
}
这是遍历结果：
所用的概念还是控制下标的遍历，和c语言一样。
②for_each遍历方式
样例：
for (int x:arrary4) {
System.out.print(x+" ");
}
这是遍历的结果：
就相当于把数组的每个元素都一个一个给了x（随便设的变量名），然后一个一个遍历。
foreach循环是有缺点的，我们不能得到下标，也不能用我们一眼看出来的下标去改变原数组的值，这样的操作对于foreach循环是不起作用
③toString方法遍历
样例：
public class sd {
public static void main(String[] args) {
int[] array={1,2,3,4,5};
String a = Arrays.toString(array);
System.out.println(a);
}
}
这个就是我们的用例
结果是：
（2）二维数组
①普通遍历方式
public static void main(String[] args) {
int[][] array4 ={{1,2},{3,4,6},{5}};
for(int i = 0;i< array4.length;i++){
for(int j = 0;j<array4[i].length;j++){
System.out.print(array4[i][j]+" ");
}
System.out.println();
}
}
结果：
②for_each遍历方式
代码：
public static void main(String[] args) {
int[][] array4 ={{1,2},{3,4,6},{5}};
for (int[] x:array4) {
for (int y:x) {
System.out.print(y+" ");
}
System.out.println();
}
}
结果：
③deepToString
为什么这里不能用toString呢？
因为二维数组名存的是一维数组的地址，直接用toString打印出来的是二维数组中每个元素（一维数组）的地址。
所以用deepToString
代码：
public static void main(String[] args) {
int[][] array4 ={{1,2},{3,4,6},{5}};
System.out.println(Arrays.deepToString(array4));
}
结果：
5.通过数组来实现两个整型的交换
由于整型的传参是传的形参，无法改变对应实数的值，而且java当中没有指针的概念，所以我们只能传引用，数组就是引用的一个好方式。
这是交换的原理：
先把要交换的数，存在数组里，再通过数组传引用，借助改变数组来交换2个数字。
以下是代码：
public class doa {
public static void Swap(int[] array){
int temp = array[0];
array[0]=array[1];
array[1]=temp;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入需要交换的第一个数:");
int a = sc.nextInt();
System.out.println("请输入需要交换的第二个数:");
int b = sc.nextInt();
int[] array = {a,b};
System.out.println("交换前："+array[0]+" "+array[1]);
Swap(array);
System.out.println("交换后："+array[0]+" "+array[1]);
}
}
结果：
6.拷贝方式
这几个都是直接在后面加（数组名）使用就行了。
（1）for循环拷贝
（2）copyOf拷贝
（3）copyOfRange部分拷贝
（4）System.arraycopy
（5）array.clone
8.数组排序
（1）冒泡排序
思路分析：
代码：
为什么加flag，因为如果和后面所有数都没有交换顺序，说明这个数组内元素就是按照升序排列的，所以在一定条件下加flag可以减少代码的循环次数
import java.util.Arrays;
public class mao {
public static void bubble_sort(int[] array){
int flag = 0;
for(int i = 1;i<array.length;i++){
for (int j = 0 ;j< array.length-i;j++){
if(array[j]>array[j+1]){
flag = 1;
int temp = array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
if(flag==0){
break;
}
}
}
public static void main(String[] args) {
int[] array ={8,7,5,3,1};
bubble_sort(array);
System.out.println(Arrays.toString(array));
}
}
结果
9.数组逆序
就是把2个首尾下标的值交换：
代码
import java.util.Arrays;
public class da {
public static void reverse(int[] array) {
int head = 0;
int tail = array.length-1;
while(head<tail){
int temp = array[head];
array[head]=array[tail];
array[tail]=temp;
head++;
tail--;
}
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
reverse(array);
System.out.println(Arrays.toString(array));
}
}
结果：
10.二分查找
前提一定要是有序
就是通过首尾的下标，和中间值下表，来搜索目标值。
若中间值小于目标值，则让首下标=中间值下标+1；
若中间值大于目标值，则让尾下标=中间值下标-1；
然后再根据新的左右下标（原来的首位下标，来定位新的中间值下标）；
重复上述步骤，直到左下标大于右下标为止。
代码自己写一遍。和c语言的实现方式一样。
当然，Java有个Arrays方法,包含二分查找。
public static void main(String[] args) {
int[] array4 ={1,2,3,4,56,7};
System.out.println(Arrays.binarySearch(array4, 4));
}
结果：
结果返回的是目标值的下标。
11.练习题（一部分）
（1）求数组的平均值
这个其实也不难。有c语言基础就行。这个也没有特殊知识点，就是练一下代码熟悉度。
代码：
public class ad {
public static double average(int[] array){
int sum=0;
for(int i = 0;i<array.length;i++){
sum +=array[i];
}
return sum*1.0/array.length;
}
public static void main(String[] args) {
int[] array ={1,2,3,4};
double ret = average(array);
System.out.println(ret);
}
}
这是结果：
（2）改每个数组元素的值为原来的二倍
①改变原数组
也没什么特殊的，就是利用下标和引用来改变数组元素的值。
代码：
public class dew {
public static void Double(int[] array){
for(int i =0;i<array.length;i++){
array[i]*=2;
}
}
public static void main(String[] args) {
int[] array = {1,2,3};
System.out.println("改变之前："+ Arrays.toString(array));
Double(array);
System.out.println("改变之后："+ Arrays.toString(array));
}
}
结果：
②改动新的数组
代码：
public class eqwe {
public static int[] Double(int[] array) {
int[] ret =new int[array.length];
for (int i = 0;i<array.length;i++){
ret[i]=2*array[i];
}
return ret;
}
public static void main(String[] args) {
int[] array ={1,2,3};
int[] ret = Double(array);
System.out.println("改变之后的array为："+ Arrays.toString(array));
System.out.println("改变之后的ret为："+ Arrays.toString(ret));
}
}
这是结果：
