1. 数组
数组是引用数据类型 , 用来保存多个数据
1.1. 数据结构
数据结构是计算机存储、组织数据的方式 . 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合 . 通常情况下 , 精心选择的数据结构可以带来更高的运行或者存储效率 . 数据结构往往同高效的检索算法和索引技术有关.
1.2. 数组特性
连续存储 , 下标从0开始 , 数组一旦创建 , 长度不能修改.
查询和修改效率极高 , 添加和删除效率较低(并且数组没有提供添加和删除操作)
想要添加新数据 , 需要建一个新数组 , 把源数组内容复制过去 , 再放一个新数据即可.
数组中有length属性 , 保存了数组的长度
1.3. 数组声明
1.3.1. 静态声明
静态声明 :
在已知每个元素的时候使用静态声明
数据类型 [ ] 变量 = {值,值,值......}
int[] arr1 = { 1, 2, 3, 4 };
int arr1[] = { 1, 2, 3, 4 };
1.3.2. 动态声明
动态声明:
数据类型[ ] 变量名 = new 数据类型 [长度];
int[] arr2 = new int[10];
1.4. 内存中存储方式
1.5. 数组使用
1.5.1. 获取数据
查询 :
数组 [ 下标 ] 下标从0开始
System.out.println(arr1[0]);
System.out.println(arr1[3]);
查新最后一个数据
System.out.println(arr1[arr1.length-1]);
长度
System.out.println(arr1.length)
1.5.2. 更改数据
修改 :
数组 [下标] =值;
array[2] = 12;
1.5.3. 遍历
遍历 :
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
1.5.4. 常见异常
下标越界
// 常见异常
// Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
// 运行时异常,下标越界
// 下标最大为 length-1
arr1[10] = 2;
// 会终止程序执行
System.out.println("===============");
1.5.5. 数组传递
public static void main(String[] args) {
int i = 1;
m1(i);
m1(1);
int[] arr = { 1, 3, 4 };
m1(arr);
// 字面量写法
m1(new int[] { 1, 3, 4 });
}
public static void m1(int a) {
}
public static void m1(int[] arr) {
}
1.5.6. 给Main方法传参
1.6. 传值和传址
引用类型传递,因为是传递的地址,所以两个变量会指向同一个堆内存对象数据
所以某一个地方把对象中数据进行修改,则所有进行访问该对象的数据时,都是修改之后的
public static void main(String[] args) {
int i = 10;
m1(i);
System.out.println(i);
int[] arr = {1,2};
m2(arr);
System.out.println(arr[0]);
}
public static void m1(int i) {
i++;
System.out.println(i);
}
public static void m2(int[] arr){
arr[0] = 11;
System.out.println(arr[0]);
}
1.7. 数组替换复制
public static void main(String[] args) {
int [] src = {1, 2, 3, 4, 5, 6, 7, 8 };
int [] dest = { 11, 12, 13, 14, 15, 16, 17, 18 };
// 源数组,源数组起始位置(包含),目标数组,目标数组起始位置(包含),复制个数
arraycopy(src, 1, dest, 1, 3);
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
}
public static void arraycopy(int[] src, int srcIndex, int[] dest,
int destIndex, int length) {
for (int i = 0; i < length; i++) {
dest[destIndex] = src[srcIndex];
destIndex++;
srcIndex++;
}
}
1.8. 数组插入复制
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] src = {1,2,3,4,5,6,7,8};
int[] Dest = {11,22,33,44,55,66,77,88};
// {11,22,33,}
int dest[] = array(src, 1, Dest, 2, 3);
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
}
public static int[] array(int[] src , int srcIndext , int[] Dest ,
int DestIndext , int length) {
//定义一个新数组
int[] newDest = new int[Dest.length + length];
//将目标数组的初始位置之前(包含)的数据传到新数组中
for (int i = 0; i <DestIndext+1; i++) {
newDest[i] = Dest[i];
}
//将原数组初始位置到插入长度位置(包含)的数据传入到新数组中
int Index = DestIndext;
for (int j = srcIndext; j < srcIndext+length; j++) {
Index++;
newDest[Index] = src[j];
}
//将目标数组中的剩余数据传入到新数组中
for (int k = DestIndext+1; k < Dest.length; k++) {
Index++;
newDest[Index] = Dest[k];
}
return newDest ;
}
2. 二维数组
2.1. 声明方式
数据类型[] 变量 = {值,值....};
int[] arr1 = { 1, 2, 7, 5, 3 };
二维数组,保存的都是一维数组
int[][] arr2 = {arr1,arr1};
二维数组声明
1 静态声明
int[][] arr3 = {
{1,2,3},{4,3,2},{1,5,3,7}
};
2 动态声明
二维数组中,有3个一维数组,并且每个一维数组中有5个元素
int[][] arr4 = new int[3][5];
2.2. 内存中存储方式
2.3. 使用方式
2.3.1. 获取数据
// 查询 数组[下标]
int i = arr1[2];
int[] arr3_0 = arr3[0];
int arr3_0_1 = arr3_0[1];
// 第0个一维数组中的第1个数据(下标)
// 二维数组[下标][下标]
arr3_0_1 = arr3[0][1];
// 第一个一维数组中的第一个元素
System.out.println(arr3[0][0]);
// 最后一个一维数组中的最后一个元素
System.out.println(arr3[2][3]);
int[] arr3_2 = arr3[arr3.length-1];
int arr3_2_3 = arr3_2[arr3_2.length-1];
System.out.println(arr3_2_3);
System.out.println(arr3[arr3.length-1][arr3[arr3.length-1].length-1]);
2.3.2. 更改数据
arr4[2][3] = 29;
2.3.3. 遍历
遍历 :
for (int j = 0; j < arr4.length; j++) {
// int[] arri = arr4[j];
for (int k = 0; k < arr4[j].length; k++) {
System.out.print(arr4[j][k] + " ");
}
System.out.println();
2.3.4. 动态声明锯齿状(典型杨辉三角)
public static void main(String[] args) {
// TODO Auto-generated method stub
int[][] array = new int[7][];
// 给二维数组中的一维数组规定个数
for (int i = 0; i < array.length; i++) {
array[i] = new int[i + 1];
}
// 写出杨辉三角规则
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if (j == 0|| j == array[i].length-1) {
array[i][j] = 1;
} else {
array[i][j] = array[i-1][j-1] + array[i-1][j];
}
}
}
// 遍历打印前七行
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]);
}
System.out.println();
}
}
3. 交换变量得值
int a = 10;
int b = 5;
// 1 开发常用,中间变量,简单易懂
int c = b;
b = a;
a = c;
// 2 相加
a = 10;
b = 5;
a = a + b;
b = a - b;
a = a - b;
// 2 异或运算,面试常用
a = 10;
b = 5;
// a= 0000 1010
// b= 0000 0101
// a= 0000 1111
a = a ^ b;
// b= 0000 1010
b = a ^ b;
// a= 0000 0101
a = a ^ b;
System.out.println(a + " : " + b);