一、数组的遍历
遍历：依次访问，从第一个元素，访问到最后一个元素。
1、使用循环来遍历数组
for(int i = 0;i < arr.length; i++){
arr[i] = i;//赋值
System.out.println(arr[i]);//获取数值
}
2、for-each循环
for-each循环：【扩展】
增强for循环：JDK1.5的版本出现的。
特定的用法：专门用于获取数组中的每一个元素的值。
语法结构：
for(数据类型 变量名 : 数组名){
System.out.println(变量名);
}
工作原理：
for(int e :arr){
System.out.println(e);
}
int e，定义变量e， //e：element——>元素，数组中储存的数据——>数组的元素
依次获取数组的元素，赋值给e
注意点：
A：for-each只能获取数组的数据，但是不能给数组进行赋值
B：for-each，在代码这个层面，不能操作下标。
二、数组中的默认值
数组的默认值，就是数组创建后，里面存储的默认的数据。
数组的引用存在栈内存中，数组本身存在堆内存中。
数组创建完，就有默认的数据了。
数组中存储的默认值：
数组中是有默认值的
整数：0
小数：0.0
字符：\u0000
布尔：false
其他：null
三、创建数组的其他语法
1、//动态创建数组：先创建数组，然后再根据下标一个一个存储数据。
A：先声明，再创建(分配内存空间)
数据类型 [] 数组名;
数组名 = new 数据类型[长度];
B：声明并创建
数据类型 [] 数组名 = new 数据类型[长度];
数据类型 数组名[] = new 数据类型[长度];
2、//静态创建数组：声明，创建，赋值一起写完。
C：声明，创建，并赋值
数据类型[] 数组名 = {数值1,数值2,数值3,数值4.。。。};
=左边声明数组，=右边，会先根据{}中数据的个数，然后再将{}中数据，按照顺序存储进去。
完成了几件事：
1.先声明：int[] c
2.根据{}中数组值的个数，开辟堆内存
3.将{}中的数组值，依次按照顺序存入数组中
D：声明，创建，并赋值
数据类型[] 数组名 = new 数据类型[]{数值1,数值2,数值3,数值4.。。。}
四、数组的地址转移：知道
Java中的数据分为两大类：
基本类型：4类8种
操作的都是数值本身
引用类型：数组
操作的是地址
基本类型进行赋值：数值
引用类型进行赋值：地址
示例代码：
class Test4ArrayAddress
{
public static void main(String[] args)
{
/*
数组：引用类型的数据
数组名，存储是引用地址。
*/
int[] a = new int[3];
System.out.println(a.length);//3
System.out.println(a);//a数组的地址
System.out.println(a[0]);//0
a[0] = 1;
a[1] = 2;
a[2] = 3;
int[] b = {4,5,6,7};
System.out.println(b.length);//4
System.out.println(b);//b的地址
System.out.println(b[0]);//4
int[] c = a;//将a的值赋值给c，就是将a存储的数组的地址赋值给c
//a和c存储的地址相同，那么就指向了同一个数组
System.out.println(c.length);//3
System.out.println(c);//a的地址
System.out.println(c[0]);//1
c[0] = 100;
System.out.println(a[0]);//100
System.out.println(b[0]);//4
System.out.println(c[0]);//100
b = c;
b[1] = 200;
System.out.println(a[1]);//200
System.out.println(b[1]);//200
System.out.println(c[1]);//200
System.out.println("Hello World!");
}
}
五、数组作为参数
数组是引用类型：传递的是地址。就是参数也会指向这块内存。当方法结束的时候，参数就销毁了。
class Test5ArrayMethod
{
//设计一个方法，用于打印数组
public static void printArray(int[] arr){
//int[] arr = a;a的地址给了arr，那么arr和 / a指向同一块内存的数组
for(int e : arr){
System.out.print(e +"\t");
}
System.out.println();
}
public static void main(String[] args)
{
int[] a = {1,2,3,4,5};
printArray(a);//将a的地址，传递给arr
}
}
六、数组作为返回值
1、示例代码：
//设计一个方法，用于创建一个数组， 并赋值。数组要返回给调用处
public static int[] createArray(int len){
int[] arr = new int[len];
for(int i = 0;i <arr.length;i++){
arr[i] = i * 2;
}
return arr;
}
2、可变参数【扩展】
概念：一个方法可以接收的参数的数量不定(0-多个)，但是类型固定。
语法：数据类型 ... 参数名，可变参数在方法中当数组使用。
注意事项：
(1)如果参数列表中，除了可变参数还有其他的参数，可变参数要写在整个参数列表的最后。
(2)一个方法最多只能有一个可变参数。
class Test6Array
{
//求一组int类型的数据的和
public static void getSum(int ... nums ){
int sum = 0;
for(int i = 0;i <nums.length;i++){
sum += nums[i];
}
System.out.println("结果：" + sum);
}
public static void main(String[] args)
{
/*
可变参数：同一种类型的参数，类型固定的，但是个数不固定。
语法的支持：
数据类型 ... 参数名
可变参数，类型固定，个数可变。0-多个
在方法中可变参数当数组使用
*/
getSum(1,2,3);
getSum(1,2,3,4,5,6,7,8,9,10);
}
}
七、数组的排序
排序：数组是存储一组数据，而且这些数据是有顺序的。但是数值本身可能是无序的。通过算法来实现给数组进行排序，升序(数值从小到大)，降序(数值从大到小)。
1、冒泡排序：Bubble Sort
原理：比较相邻的两个数，将较大的数，向后移动。（升序）
class Test7BubbleSort
{
public static void main(String[] args)
{
int[] arr = {15,23,8,10,7};
for(int i= 1; i<arr.length;i++){//控制轮数：
for(int j = 0; j < arr.length - i; j++){
if(arr[ j ] > arr[ j + 1 ]){
//交换
int temp = arr[ j ];
arr[ j ] = arr[ j + 1 ];
arr[ j + 1 ] = temp;
}
}
}
for(int i = 0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
2、选择排序
思路(升序)：每次找个基准值，定一个变量k表示比较小的值的下标。每轮比较完，都在基准值上放一个比较小数。
//核心代码：
int[] a = {15,23,8,10,7};
for(int i = 0;i < a.length - 1 ; i++){//控制轮数，趟数
int k = i; 0
for(int j = k + 1; j < a.length; j ++){
if(arr[ k ] > arr[ j ]){
k = j;
}
}
//交换
if(k != i){
int temp = arr[k];
arr[k] = arr[i];
arr[i] = temp;
}
}
3、工具类：Arrays（数组）
JDK提供好的类：
A：Scanner，读取键盘
B：String，字符串
C：Math，数学的
D：Arrays，提供数组的常规操作的
E：System，
F：sort ?(排序)
八、数组的复制
就是将一个数组的数据，复制到另一个数值中。
方法一：通过循环，依次复制，将原数组的数据，一个一个，复制到目标数组中
方法二：Arrays类里方法：copyOf(原数组，新数组的长度)-->返回值是新数组
方法三：System类里的方法：arraycopy(原数组，原数组位置，新数组，新数组位置，拷贝的个数) System.arraycopy(..... , ...... , .... , ... , .....); ？
九、二维数组
维度：dimension
数组：存储相同类型的一组数据。
一维数组：数组中存储的就是数据了。
二维数组：存储的是一维数组。本质也叫数组的数组。也被称为矩阵：行和列的。
注： b.length == 3 是b有几个一维数组。
