数组

Simp1e

1.数组的概念：用于存储一组相同数据类型的元素java一共有两大类数据类型:基本数据类型(简单类型，原始类型) -引用数据(复合类型，复杂类型)类型数组的定义:声明和初始化两部分(1).声明部分:

[Java] 纯文本查看 复制代码

byte b = 10;int i = 20;
//三种声明方式:
1.int[] a =
2.int a[] =
3.int []a =

(2).初始化 : 赋值三大必要因素:元素，长度，索引（下标-一个从0开始的位置编号 6）数组的最大索引=数组长度-1a.静态初始化

[Java] 纯文本查看 复制代码

int[] a = {2,1,5,4,3,7}; 
//常规操作
//取值
int w = a[4];
//赋值
a[4] = 100;
//遍历
for (int i = 0;i < a.length  ;i++ ){//a.length-1
	//i的变化规律刚好符合数组元素索引的变化规律
	System.out.println(a[i]);
}
//遍历方式-增强for,forEach JDK1.5以后为了方便我们遍历数组
for (int w : a){// for (用于接收每个值的变量 : 要遍历的数组)
	System.out.println(w);
}

b.动态初始化

[Java] 纯文本查看 复制代码

//声明 = 初始化方式 元素 [长度 索引] leetCode
int[] v = new int[5];//动态初始化 长度 5 索引 0-4
//单个赋值
v[0] = 1;
v[1] = 7;
v[2] = 8;
v[3] = 9;
v[4] = 22;
//觉得v0不好看，改改
v[0] = 100;
//取值
int w = v[1];
System.out.println(w);
//遍历
for (int i = 0;i < v.length ;i++ ){
	System.out.println(v[i]);
}

c.数组的使用场景(1).如果需要对多个元素进行统一的操作(遍历 查看 还是处理)

[Java] 纯文本查看 复制代码

int[] v = {10,20,30,15,22,33,44};//求元素累加和  sum(=0) + v[0] = 10
int sum = 0;//存储累加和
for (int i = 0;i < v.length ;i++ ){
int w = v[i];//v[2]
    //我把到当前位置所有元素的累加和放在了a变量里
    //i = 1 sum:10 + v[1]:20  a = 30
    //i = 2 sum:30 + v[2]:30  a[60] = 40
    sum = sum + v[i];//sum=前几个数的和 v[i]=是当前数 a=30
}
System.out.println("累加和:"+sum);
System.out.println("平均值:"+sum/v.length);

(2).什么时候用动态初始化？什么时候又用静态初始化？动态初始化场景a.动态初始化适合元素比较多，还有一定规律b.开始并不明确知道元素是什么，但是可以知道长度静态初始化a.元素比较少，而且没什么规律性，同时必须保证元素，长度，索引 都为已知注意：逆序循环做后置输出

[Java] 纯文本查看 复制代码

int[] v = {1,2,3,4,5};
for (int i = v.length - 1;i >= 0 ;i-- ){//终点判断:可执行范围 
	System.out.println(v[i]);
}

注意: ArrayIndexOutOfBoundsException : 数组的索引越界 索引界限:[0 ~ 长度-1]-数组的长度一旦固定，那么在后续的使用中是不可以超长度使用的数组一旦定义完成，它的长度是固定的!2.引用和基本类型之间的区别:(1).数组是一种引用类型元素(2).基本数据类型 : 在栈中存储(3).引用类型 :          栈中存放的是堆内部真实元素的地址引用        堆中存放的是真实的值本身(4).引用类型和基本数据类型区别就是变量中存放的到底是什么?        a. 基本数据类型，其内部存放的是值本身,独自管理自己的值，不受其他变量的影响        b. 引用类型变量里存储的并不是值本身，而是真实的值在堆中存储的内存地址，元素操作时，实际上        是一个寻址过程

[Java] 纯文本查看 复制代码

int[] a = {1,2,3,4};
//A.int   B.int[]
int[] b = a;//{1,2,3,4} a将数组1234的地址给了b
b[0] = 7;//b = {7,2,3,4}
System.out.println(a[0]);//a随着b变了
--------------------------------------------------------------
int[] a = {1,2,3,4};
//A.int   B.int[]
int[] b = {1,2,3,4};//此时创建了新的1234数组
b[0] = 7;//b = {7,2,3,4}
System.out.println(a[0]);//a不会随着b改变

3.数组的拆分和合并

注意:数组使用的重点(1).初始化方式选择好(2).赋值过程弄清楚(3).如何利用好循环和数组之间的关系4.多维数组数组中存储的元素并不是单一的基本类型，而是一个数组!(1).初始化方式 a.静态初始化

[Java] 纯文本查看 复制代码

int[][] v = {{1,2,3},{3,2,3},{4,4,4,4},{6,6,6,6}};
//取值 二维数组就素数组里存储的元素还是个数组
int[] vx = v[0];//A.int B.int[] C.不知道
int v2 = v[0][0];
int v3 = v[1][2];
System.out.println(v2);
for (int a : vx ){
    System.out.println(a);
}
//赋值
//v[0][2] = 9;
//静态初始化形式-静态初始化的标准写法
v[0] = new int[]{2,2,16,7,6};//赋值 比较-类型是否一致 v[0] = 数组
System.out.println(v[0][2]);
//遍历
for (int i = 0;i < v.length ;i++ ){
    for (int j = 0;j < v[i].length ;j++ ){
        System.out.println(v[i][j]);
    }
}
//增强for
for(int[] vx : v){
    for (int w : vx ){
        System.out.println(w);
    }
}

b.动态初始化

[Java] 纯文本查看 复制代码

int[][] v = new int[3][4];
v[0][0] = 1;
v[0][1] = 5;
v[0][2] = 7;
v[0][3] = 3;

v[1][0] = 1;
v[1][1] = 5;
v[1][2] = 7;
v[1][3] = 3;

v[2][0] = 1;
v[2][1] = 5;
v[2][2] = 7;
v[2][3] = 3;
//动态初始化的一些特殊情况
int[][] v = new int[3][];//第一个长度必须声明,而且长度的声明必须是连续的，中间不能出现长度中断
v[0] = new int[3];
v[0][0] = 1;
v[0][1] = 2;
v[0][2] = 3;
v[1] = new int[]{2,3,3,3};
v[2] = new int[]{3,1,2,3,4,5};
for(int[] vx : v){
    for (int w : vx ){
        System.out.println(w);
    }
}

5.数组算法

[Java] 纯文本查看 复制代码

//冒泡排序
for (int i = 0; i < v.length - 1;i++ ){//控制这个比较的过程到底要执行多少次
    for (int j = v.length - 1;j > i;j--){
        if (v[j] < v[j-1]){
            int c = v[j];
            v[j] = v[j-1];
            v[j-1] = c;
        }
    }
}

只是举个例子，排序算法不止这一个。
学习思路：

• 先弄清楚对方要做的事情究竟是什么
• 再想想自己要实现的话怎么办
• 结合对方的代码和自己的思路一起学习