数组的定义
数组是引用数据类型三种当中的其中一种。
概念：同一种类型数据的集合。其实数组就是一个容器。 数组的好处： 可以自动给数组中的元素从0开始标号，方便操作这些元素。 格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 格式2：元素类型[] 数组名 = new 元素类型[] {元素，元素，......}; int[] arr = new int[] {3,5,1,7}; int[] arr = {3,5,1,7};
class ArrayDemo2
{
public static void main(String[] args)
{
//int[] arr = new int[2]; //定义数组方法一
//int arr[] = new int[2]; //定义数组方法二
arr[0] = 90; //赋值
arr[1] = 78;
int[] arr = new int[]{3,1,6,5,4};
int[] arr = {3,1,6,5,4}; //静态初始化（定义）数组
}
}
为什么要把空间划分那么细呢？
因为每一片内存空间中的数据处理的方式不一样。栈内存中的数据使用完毕会自动释放。
栈内存：
- 用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存：
- 数组和对象，通过new建立的实例都存放在堆内存中。
- 每一个实体都有内存地址值
- 实体中的变量都有默认初始化值
- 实体不在被使用，会在不确定的时间内被垃圾回收器回收。
int [] x = new int[3] 结构说明
- 左边在栈内存中定义一个x,凡是局部变量都在栈内存里面。
- （右边）new 在堆内存中产生一个是数组。并指定了元素的类型和个数，每个元素都有一个角标。
- 关系：new会把这个数组的内存地址赋值给x。int[] 是定义数组元素的数据类型。栈里面的x只是调用了堆里的数组的地址。
int [] x = new int[3] 这句代码在内存中是什么样的呢？
- java在启动程序时一共在内存中划分了五片空间，来进行数据的存储：方法区，本地方法区，寄存器，栈内存（栈区），堆内存（堆区）
- 当我在主函数里面定义一个变量x=3的时候 （int x = 3;），
- 主函数运行的时候，会在栈内存中开辟一块空间（主函数区域）。这个空间里面就会有一个变量x,值就是3。
- 当这个函数一被执行完，这个主函数区域就会在栈内存中消失，那么里面的变量也会消失。
什么是局部变量呢？
定义在方法里面的变量，
定义在方法的参数里的变量，
定义在for循环里面的变量全都是局部变量。
堆内存中的实体中的数据都有默认初始化值：
int型数组的话默认就是0，
double默认就是0.0 ；
float默认就是0.0F ；
Boolean类型的数组，默认初始化值就是false。
堆内存的3个特点：
内存地址值，默认初始化值，垃圾回收机制（x=null），会不定时的清理垃圾。
栈内存的特点：
自动回收垃圾。
java中分为基本数据类型和引用数据类型：
一、基本数据类型： byte：Java中最小的数据类型，在内存中占8位(bit)，即1个字节，取值范围-128~127，默认值0 short：短整型，在内存中占16位，即2个字节，取值范围-32768~32717，默认值0 int：整型，用于存储整数，在内在中占32位，即4个字节，取值范围-2147483648~2147483647，默认值0 long：长整型，在内存中占64位，即8个字节-2^63~2^63-1，默认值0L float：浮点型，在内存中占32位，即4个字节，用于存储带小数点的数字（与double的区别在于float类型有效小数点只有6~7位），默认值0 double：双精度浮点型，用于存储带有小数点的数字，在内存中占64位，即8个字节，默认值0 char：字符型，用于存储单个字符，占16位，即2个字节，取值范围0~65535，默认值为空 boolean：布尔类型，占1个字节，用于判断真或假（仅有两个值，即true、false），默认值false
java中的数据类型和内存的关系：
在Java中，每个存放数据的变量都是有类型的，如： char ch； float x； int a,b,c； ch是字符型的，就会分配到2个字节内存。不同类型的变量在内存中分配的字节数不同，同时存储方式也是不同的。 所以给变量赋值前需要先确定变量的类型，确定了变量的类型，即确定了数据需分配内存空间的大小，数据在内存的存储方式。
四、Java数据类型在内存中的存储：
1）基本数据类型的存储原理：基本数据类型都是直接存储在内存栈上的，数据本身的值就是存储在栈空间里面，而Java语言里面八种数据类型是这种存储模型；
2）引用类型的存储原理:引用类型继承于Object类（也是引用类型），“引用”是存储在有序的内存栈上的，而对象本身的值存储在内存堆上的；
区别:基本数据类型和引用类型的区别主要在于基本数据类型是分配在栈上的，而引用类型是分配在堆上的（需要java中的栈、堆概念）
x,y指向的是同一个内存空间
a,b是两块内存空间
数组的操作：
打印数组中所有的元素，元素间用逗号隔开
class ArrayDemo3
{
public static void main(String[] args)
{
//int[] arr = new int[3];
int[] arr = {1,8,9};
printArray(arr); //如果System.out.print(arr) 将打印出类似[I@8ad82ed 这样的数据：[代表数组，I代表int类型。@后面的是数组的内存地址。
}
public static void printArray(int[] arr) //打印哪个数组的元素，要给出一个参数。
{
//获取数组元素个数：length
//使用方式：数组名称.length =
System.out.print("[");
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]+"]");
}
}
}
求数组元素的和
class ArrayDemo3
{
public static void main(String[] args)
{
//int[] arr = new int[3];
int[] arr = {1,8,9};
int sum = 0;
for(int x=0; x<arr.length; x++)
{
sum += arr[x];
}
System.out.println(sum);
}
}
给定一个数组{5,1,6,4,2,8,9}，获取数组中的最大值，以及最小值。
/* 思路： 1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定，通过一个变量进行临时存储。 2，让数组中的每一个元素都和这个变量中的值进行比较。把大的值赋值给变量。 步骤： 1：定义变量，初始化为数组中任意一个元素即可。 2：通过循环语句对数组进行遍历。 3：在循环过程中定义判断条件，两个元素哪个大就赋值给变量。 需要定义一个功能（函数），以便提高代码的复用性。 1，已明确的结果，数组中的元素为int型 2，未知内容：是哪个数组 */ class ArrayTest { public static int getMax(int[] arr) { int max = 0; for(int x=1; x<arr.length; x++) { if(arr[x]>arr[max]) max = x; } return arr[max]; } public static void main(String[] args) { int[] arr = {5,1,6,4,2,8,9}; int max = getMax(arr); System.out.println("max="+max); } }
//获取double类型数组的最大值。因为功能一致，所以定义相同函数名称，以重载形式存在。 public static double getMax(double[] arr) { }
在编译的时候不会报出异常，在执行的时候会报错。
访问了数组中不存在的角标。
红框中的内容为报错提示为什么报错。黄框中的内容提示报错的位置。
选择排序
class ArrayTest2
{
/*
选择排序。
内循环结束一次，最值出现头角标位置上。
*/
public static void selectSort(int[] arr)
{
for (int x=0; x<arr.length-1; x++)
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
//排序前
printArray(arr);
//排序
selectSort(arr);
//排序后
printArray(arr);
}
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.print(arr[x]+"]");
}
}
}
冒泡排序：
class ArrayTest3
{
/*
冒泡排序
*/
public static void bubbleSort(int[] arr)
{
for (int x=0; x<arr.length-1; x++)
{
for(int y=0; y<arr.length-x-1; y++) //-x让每次比较的元素减少，-1：避免角标越界。
{
if(arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
//排序前
printArray(arr);
//排序
//selectSort(arr);
bubbleSort(arr);
//排序后
printArray(arr);
}
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}
堆内存中换位置比较消耗资源。
先把需要换位置的角标和值记录到栈内存中，都比较完之后将最大的值放到最后。比较一圈只在堆内存中换了一次位置。
用内置方法排序：
import java.util.*;
class ArrayTest4
{
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
//排序前
printArray(arr);
//排序
Arrays.sort(arr);
//排序后
printArray(arr);
}
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}
