一、概念
数组:一种容器，可以同时存放多个数据值
特征
- 引用数据类型
- 多个数据类型必须一致
- 程序运行期间长度不可改变
二、一维数组
数组初始化:就是为数组中的数组元素分配内存空间，并为每个数组元素赋值
1. 静态初始化（声明+创建）
静态初始化（指定内容）：不直接指定数据个数多少，视数据内容而定
标准格式：数据类型 [] 数组名 = new 数据类型[]{
元素1,元素2,...}
常用格式：数据类型 [] 数组名 = {
元素1,元素2,...}
int [] arr = {
1,2,3};
2.动态初始化
动态初始化（指定长度）：初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型 [ ] 数组名 = new 数据类型[数组长度];
int [] arr = new int[3];
三、数组的操作
- 索引（index）:
int数字，0-(数组长度-1)，代表数组元素的位置 - 取值格式：数组名[索引]
- 赋值格式：数组名[索引]=元素值
1.使用动态初始化，元素会自动拥有一个默认值:
- 整型默认0
- 浮点型默认0.0
- 字符型默认’\u0000’
- boolean型默认false
- 引用类型默认null
public static void main(String[] args) {
int[] arr = new int[3];
arr[0]=1;
arr[1]=2;
arr[2]=3;
// 输出数组名
System.out.println(arr); // [I@880ec60
// 输出数组中的元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
2.异常
- 数组下标越界异常：
数组arr的索引编号从0开始，一直到arr.length为止
访问数组元素时，索引编号并不存在，将会发生数组越界异常
ArrayIndexOutOfBoundsException
- 空指针异常：
所有的引用数据类型变量，都可以赋值为null，代表什么都没有
数组必须进行new初始化才能使用
值为null的变量进行操作将会发生空指针异常
NullPointerException
3.获取数组长度
- 数组名称.length 返回int,数组长度
//数组一旦创建，程序运行期间，数组长度不可改变
int[] arr=new int[3];
int a = arr.length
4.遍历数组
遍历：对数组每一个元素进行逐一输出
- for循环遍历
public static void main(String[] args) {
int[] arr = {
11, 22, 33, 44, 55 };// 定义数组
for (int i = 0; i < arr.length; i++) {
// 使用通用的遍历格式
System.out.println(arr[i]);
}
}
- foreach遍历
for(type element: array){
System.out.println(element);
}
5.求最值
找出元素最大值
public static void main(String[] args) {
int[] arr = {
12, 45, 98, 73, 60 };// 定义数组
// 定义一个变量，用于保存最大值
// 取数组中第一个数据作为变量的初始值
int max = arr[0];
// 与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
for (int x = 1; x < arr.length; x++) {
if (arr[x] > max) {
max = arr[x];
}
}
// 循环结束后打印变量的值
System.out.println("max:" + max);
}
6.数组内存–Java内存
| 区域名称 | 作用 |
|---|---|
| 寄存器 | 给CPU使用，和我们开发无关 |
| 本地方法栈 | JVM在使用操作系统功能的时候使用，和我们开发无关 |
| 方法区 | 存储可以运行的class文件 |
| 堆内存 | 存储对象或者数组，new来创建的，都存储在堆内存 |
| 方法栈 | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行 |
-
栈内存：
存储局部变量
定义在方法中的变量，例如：arr
使用完毕，立即消失 -
堆内存：
- 堆内存：存储new出来的内容(实体，对象)
- 数组在初始化时，会为存储空间添加默认值:
整数：0
浮点数：0.0
布尔：false
字符：空字符
引用数据类型：null
- 每一个new出来的东西都有一个地址值
- 使用完毕，会在垃圾回收器空闲时被回收
四、二维数组
1.声明创建
- 静态声明
int [][]arr={
{
1,3,4}{
2,5,8,7}{
1,9}};
- 动态声明
int arr[][]=new int[3][4];
//[4]可以不写 即二维数组元素可以不定长度
2.遍历
二维数组打印arr[0] 输出地址 一维数组打印arr输出地址
二维数组遍历得到一维数组，再遍历一维数组
for(i=0;i<arr.length;i++){
for(j=0;j<arr[i].length;j++){
System.out.print(arr[i][j]);
}
System.out.println();
}
五、冒泡排序
1.原理
一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所
有的数据进行操作，直至所有数据按要求完成排序
如果有n个数据进行排序，总共需要比较n-1次
每一次比较完毕，下一次的比较就会少一个数据参与
2.代码实现
/*
冒泡排序：
一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，
依次对所有的数据进行操作，直至所有数据按要求完成排序
*/
public class ArrayDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {
24, 69, 80, 57, 13};
System.out.println("排序前：" + arrayToString(arr));
// 这里减1，是控制每轮比较的次数
for (int x = 0; x < arr.length 1; x++) {
// 1是为了避免索引越界，x是为了调高比较效率
for (int i = 0; i < arr.length 1 x; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
}
System.out.println("排序后：" + arrayToString(arr));
}
//把数组中的元素按照指定的规则组成一个字符串：[元素1, 元素2, ...]
public static String arrayToString(int[] arr) {
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length 1) {
sb.append(arr[i]);
} else {
sb.append(arr[i]).append(", ");
}
}
sb.append("]");
String s = sb.toString();
return s;
}
}
3.常见的排序算法
- 冒泡排序
冒泡排序
for(int i=0;i<a.length-1;i++){
//控制外循环的次数
for(int j=0;j<a.length-1-i;j++){
//控制内循环次数，比外循环少一次，与下一个比较
if(a[j]>a[j+1]){
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
- 选择排序
选择排序
for (int i = 0; i < a.length-1; i++) {
int k=i;
for (int j = i; j < a.length-1; j++) {
if (a[k]>a[j+1]) {
k=j+1;
}
}
if(i!=k){
int temp=a[i];
a[i]=a[k];
a[k]=temp;
}
}
- 顺序查找
顺序查找
public static int find(int []b,int a){
for (int i = 0; i < b.length; i++) {
if (a==b[i]) {
return i;
}
}
return -1;
}
- 二分查找
二分查找
public static int find(int b[],int a){
int max=b.length-1;
int min=0;
for (int i = 0; i < b.length; i++) {
int midle=(max+min)/2;
if(a==b[midle]){
return midle;
}else if(a>b[midle]){
min=midle+1;
}else if(a<b[midle]){
max=midle-1;
}
}
return -1;
}