一维数组：
(1)数组：存储同一种数据类型的多个元素的容器。
(2)特点：每一个元素都有编号，从0开始，最大编号是数组的长度-1。
编号的专业叫法：索引
(3)定义格式
A:数据类型[] 数组名;(一般用这种写法)
B:数据类型 数组名[];
(4)数组的初始化
A:动态初始化
只给长度，系统给出默认值
举例：int[] arr = new int[3];
B:静态初始化
给出值，系统决定长度
举例：int[] arr = new int[]{1,2,3};
或：int[] arr = {1,2,3};
(5)Java的内存分配
A:栈 存储局部变量(基本类型)
B:堆 存储所有new出来的（引用类型）
C:方法区(类和接口的方法)
D:本地方法区(系统相关)
E:寄存器(CPU使用)
注意：
a:局部变量 在方法定义中或者方法声明上定义的变量。
b:栈内存和堆内存的区别
栈：数据使用完毕，就消失。
堆：每一个new出来的东西都有地址
c:每一个变量都有默认值，并且数据使用完毕后，在垃圾回收器空闲的时候回收。
| byte,short,int,long | 0 |
| float,double | 0.0 |
| char | '\u0000' |
| boolean | false |
| 引用类型 | null |
(6)数组的常见操作
A:遍历
//方式一：
public static void printArray(int[] arr) {
for(int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
} //方式2：
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]+"]");
}else {
System.out.println(arr[x]+", ");
}
}
}
B:最值
//最大值
public static int getMax(int[] arr) {
int max = arr[0]; //假设第一个元素就是最大值
for(int x = 1; x < arr.length; x++) {
if(arr[x] > max) { //将假设的最大值与其他元素比较，若发现有更大的则直接赋值。
max = arr[x];
}
}
return max; //返回查找的最大值
} //最小值：
//与查找最大值的思想是一样的，假设第一个就是最小值，然后逐个进行比较
public static int getMin(int[] arr) {
int min = arr[0];
for(int x = 1; x < arr.length; x++) {
if(arr[x] < min) {
min = arr[x];
}
}
return min;
}
C:逆序
//方式1：
public static void reverse(int[] arr) {
for(int x = 0; x < arr.length/2; x++) {
int temp = arr[x];
arr[x] = arr[arr.length-1-x];
arr[arr.length-1-x] = temp;
/*使用异或位运算符交换
arr[x] = arr[x]^arr[arr.length-1-x];
arr[arr.length-1-x] = arr[x]^arr[arr.length-1-x];
arr[x] = arr[x]^arr[arr.length-1-x]
*/
}
} //方式2：
public static void reverse(int[] arr) {
for(int start=0,end=arr.length-1; start<=end; start++,end--) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
23 //两种方式的思想其实都是一样的，方式一利用了两个元素的索引相加为数组的长度减一；而方式二则是利用了两个变量分别从数组的始末位置相互靠拢，直到两个变量相遇
24 //推荐使用方式一，因为缺少一个变量，代码也更加的简洁，专业。
D:查表
//根据某个元素吵着在数组中所在的值，不存在返回-1
public static String getString(String[] strArray,int index) {
return strArray[index];
}
E:基本查找
//方式1：
public static int getIndex(int[] arr,int value) {
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
return x; //找到了就返回索引
}
}
return -1; //没找到就返回-1
} //方式2：比较专业
public static int getIndex(int[] arr,int value) {
int index = -1;
for(int x = 0; x < arr.length; x++) {
if(arr[x] == value) {
index = x;
break; //找到了，修改索引，并跳出循环
}
}
return index; //没找到，返回-1
}
F:二分查找（数组必须是有序的，假设是从小到大排序）
public static int getIndex(int[] arr,int value)
{
int maxIndex = arr.length-1;
int minIndex = 0;
int midIndex = (maxIndex+minIndex)/2; while(arr[midIndex]!=value)
{
//查找的元素在左边
if(arr[midIndex]>value){
maxIndex = midIndex - 1;
}
//查找的元素在左边
else if (arr[midIndex]<value) {
minIndex = midIndex + 1;
}
//找不到
if(minIndex > maxIndex){
return -1;
}
//每查找一次，就重新定位中间元素的索引
midIndex = (maxIndex+minIndex)/2;
} return midIndex;
}
二维数组：
(1)元素是一维数组的数组。
(2)格式：
A:数据类型[][] 数组名 = new 数据类型[m][n];
B:数据类型[][] 数组名 = new 数据类型[m][];
C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
D:数据类型[][] 数组名 = {{...},{...},{...}};
(3)双重for循环遍历
A:二维数组的遍历
B:二维数组的求和
C:杨辉三角形
结论：其实二维数组可以看成是一张表，每一行都相当于是一个一维数组。其实际的操作无非就是从二维转到一维，在使用一维的想想去解决问题
注意：
(1)Java中的参数传递问题
Java中只有值传递。
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
//参数为基本类型
public static void main(String[] args){
int a = 10;
int b = 20;
String aStr = "hello";
String bStr = "world";
change(a, b);
changer(aStr, bStr);
System.out.println("a="+a+"; b="+b); //a=10;b=20
System.out.println("aStr="+aStr+"; bStr="+bStr); //aStr=world;bStr=hello
} //两个整型交换变量
public static void change(int a,int b){
int tem = a;
a = b;
b = temp;
}
//方法的重载；两个字符串的交换
public static void change(String aStr,String bStr){
String tem = aStr;
aStr = bStr;
bStr = tempStr;
}