文章目录
数组概述
- 数组（Array）：多个相同类型的数据，按一定顺序排列的集合，并用一个名字命名，通过编号方式统一管理；属于引用数据类型。
- ①数组名；②下标（索引）：从0开始；③元素 ④数组长度：元素的个数
- 特点：①有序排列；②引用数据类型的变量，数组元素可以是基本数据类型变量和引用数据类型变量 ③创建数组，会在内存中开辟一整块连续的空间 ，数组名中引用的是这块空间的首地址；④数组一旦创建，长度不可修改；
- 分类：维数分为 一维数组，二维数组
数组元素类型：基本数据类型，引用数据类型
一维数组的使用
1.一维数组的声明和初始化
①静态初始化：数组的初始化和元素的赋值操作同时进行
int [ ] array=new int [ ] { 0,4,3,5,6,8};
②动态初始化：数组的初始化和元素的赋值操作分开进行
String [ ] names=new String[5];
初始化完成，其长度就确定了。
2.调用指定位置的元素
通过索引的方式调用，从0开始到数组长度 -1 结束
names[0]="王刚“；
names[1]="赵四”；
3.获取数组长度
length 属性
int sum = names.length//元素的个数
4 遍历数组
for(int i=0;i<names.length;i++){
System.out.print(names[i]+"\t");}
5 数组元素默认初始化值
整型： 0
浮点型： 0.0
char型：0（ascll码值为0）或“ \u000"
布尔型：false
引用数据类型：null
6.数组的内存解析
二维数组
理解：一维数组array[]又作为另一个一维数组array1[] 的元素存在；
1.二维数组的初始化
①静态初始化
int [] [] array=new int[][]{{1,2,3},{4,6},{0,5,78,92}};
② 动态初始化
int [][]array=new int[4][5];
2.调用数组元素
首先先理解
外层数组元素：array[3];
内层数组元素：array[1][0];
System.out.print(arry[0][1];//输出为2
System.out.print(arry[2][1]];//输出为5
3.获取数组长度
length属性
System.out.print(array.length);// 3
System.out.print(array[0].length);//3
System.out.print(array[1].length);//2
4.遍历数组元素
for(int i=0;i<array.length;i++){
for(int j=0;j<array[i].length;j++){//i与j 不同时
System.out.print(array[i][j]+"\t");
} }
5.数组默认初始值
int [][] array=new int[4][5];
外层元素array[1],array[2] 默认初始值为地址值
内层元素array[0][2],array[2][1] 默认初始值为与一维数组元素类型初始化情况相同；
int [][] array=new int[4][ ];
外层元素初始化值为null( 元素为数组，引用数据类型默认值为null)
内层元素默认初始化值报错，指针指向错误，空指针
6.内存解析
数组中常见的算法
1. 数组元素的赋值(杨辉三角，回形数）
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
* @Description 杨辉三角
* @author Mr hlr
* @date 2020年4月8日上午9:04:38
*/
public class YanghuiTest {
public static void main(String[] args) {
//1.定义数组
int [][] arry=new int[10][];//定义数组
//2.1给数组元素赋值
for(int i=0;i<arry.length;i++) {
arry[i]=new int[i+1];
//2.2给首末元素赋值
arry[i][0]=arry[i][i]=1;
//if(i>1) { //可加可不加
//2.3给非首末元素赋值
for(int j=1;j<arry[i].length-1;j++) {
arry[i][j]=arry[i-1][j-1]+arry[i-1][j];
//}
}
}
//3.遍历数组，输出数据
for(int i=0;i<arry.length;i++) {
for(int j=0;j<arry[i].length;j++) {
System.out.print(arry[i][j]+" ");
}
System.out.println();
}
}
}
//创建一个长度为6的int型数组，要求数组元素的值在1-30之间的数，且随机赋值，同时要求元素的值各不相同；
public class ArrayTest {
public static void main(String[] args) {
//方法1
// int [] arr= new int[6];
//
// for(int i=0;i<arr.length;i++) {
// arr[i]=(int)(Math.random()*30)+1;//产生随机数
//
// boolean flag=false;//标识
// while(true) {
// for(int j=0;j<i;j++) {
// if(arr[i]==arr[j]) {
// flag=true;
// break;
// }
// }
//
// if(flag) {//如果为true，重新赋值
// arr[i]=(int)(Math.random()*30)+1;//产生1-30的随机数
// flag=false;//改变标识
// continue;
// }
// break;
// }
// }
// for(int i=0;i<arr.length;i++) {//输出
// System.out.println(arr[i]);
// }
//方法2；
int [] arr=new int[6];
for(int i=0;i<arr.length;i++) {
arr[i]=(int)((Math.random()*30)+1);
for(int j=0;j<i;j++) {
if(arr[i]==arr[j]) {//如果相同，i--,重新赋值
i--;
break;
}
}
}
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
2.求数值型数组中元素的最大值最小值平均值，总和""""
3.数组的复制，反转，查找（线性查找，二分查找）
public class Sort {
public static void main(String[] args) {
int [] arr=new int[] { 34,5,22,-98,6,-76,0,-3};
//数组的反转
// for(int i=0;i<arr.length/2;i++) {
// int temp=arr[i];
// arr[i]=arr[arr.length-1-i];
// arr[arr.length-1-i]=temp;
// }
// for(int i=0;i<arr.length;i++) {
// System.out.print(arr[i]+"\t");
// }
// System.out.println();
//数组的复制
// int[] arr1=new int[arr.length];
// for(int i=0;i<arr.length;i++) {
// arr1[i]=arr[i];
// }
// for(int i=0;i<arr.length;i++) {
// System.out.print(arr[i]+"\t");
// }
//线性查找 更具有
int dest=0;
for(int i=0;i<arr.length;i++) {
if(dest==arr[i]) {
System.out.println("找到了！位置为："+i);
break ;
}else if(i==arr.length-1) {
System.out.println("未找到！");
}
}
}
}
//二分查找
//前提条件：所要查找的数组必须有序
public class BinarySearch {
public static void main(String [] args) {
int []find=new int [] {-1,-4,5,43,53,76,86,87,89,90,99,788};//有序数组
int head=0;//定义首位置
int end=find.length-1;//末位置
boolean flag=true;//标识
int dest=86;//要查找的值
while(head<=end){ //条件
int midol=(head+end)/2;//中间位置
if(dest==find[midol]) {
System.out.println("找到了。位置为："+midol);
flag=false;
break;
}else if(find[midol]>dest) {//要查找的数小于中间位置的数
end=midol-1;//将中间位置改为末位置
}else {//find[midol]<dest 要查找的数大于中间位置的数
head=midol+1;//将中间位置改为首位置
}
}
if(flag) {//flag为true说明没有进入到条件判断中
System.out.println("没有找到哦！");
}
}
}
4.数组元素的排序算法
目的：快速查找
衡量排序算法的优劣： 时间复杂度，空间复杂度，稳定性
十大内部排序算法
1.选择排序 ：直接选择排序，堆排序（O(nlogn)思想
2.交换排序：冒泡排序（On^2) 快速排序(O(nlogn)实现
3.插入排序：直接插入排序， 折半插入排序，Shell排序（希尔排序）
4**.归并排序**（O(nlogn)）思想
5.桶式排序
6.基数排序
冒泡排序的实现
//冒泡排序
//思想： 从第一个元素开始，比较两个相邻元素，若前面一个数比后面一个数大，就交换两个数的位置，使较大的数移到数据的右边
import java.util.Scanner;
public class Bubblesort {
public static void main(String[] args) {
Scanner reader=new Scanner(System.in);
System.out.println("请输入五个数：");
int[] number=new int[5];
for(int i=0;i<number.length ;i++) {
number[i]=reader.nextInt();
}
int temp;
System.out.println("从小到大排序为：");
for(int i=0;i<number.length-1 ;i++) {//循环次数
for(int j=0;j<number.length-1-i;j++) {//排序
if(number[j]>number[j+1]) {//交换
temp=number[j];
number[j]=number[j+1];
number[j+1]=temp;
}
}
}
for(int i=0;i<number.length ;i++) {
System.out.println(number[i ]);
}
}
}
快速排序思想
选取一个基准元素，然后通过与基准元素比较，将比基准数大的数放在右边，比基准数小的放在左边，划分为两个部分，再分别对两部分作相同的操作。
Arrays的工具类
java.util.Arrays; 操作数组的工具类
常用的几种方法：
boolean equals(int[] a,int[]b) 判断两数组是否相等
String toString (int[] a) 输出数组信息
void fill(int []a,int val) 将指定值填充到数组之中
void sort(int [ ]a) 对数组进行排序
int binarySearch(int [ ] a,int key) 对排序后的数组进行二分法检索指定的值
具体操作：
public class ArrayTest2 {
public static void main(String[] args) {
int [] num=new int [] {11,62,31,24};
int [] bug=new int[] { 34,56,38,2};
// boolean equals(int[] a,int[]b) 判断两数组是否相等
boolean isequal=Arrays.equals(num, bug);
System.out.println(isequal);
//String toString (int[] a) 输出数组信息
System.out.println(Arrays.toString(bug));
//void fill(int []a,int val) 将指定值填充到数组之中
Arrays.fill(bug, 10);
System.out.println(Arrays.toString(bug));
//void sort(int [ ]a) 对数组进行排序
Arrays.sort(num);
System.out.println(Arrays.toString(num));
//int binarySearch(int [ ] a,int key) 对排序后的数组进行二分法检索指定的值
int [] is=new int [] {-12,-2,0,12,34,45,66,67,80,90};
int dex=Arrays.binarySearch(is, 0);
if(dex<0) {
System.out.println("没有找到！");
}else
System.out.println("位置为："+dex);
}
}
数组中的常见异常
1.数组角标（索引）越界的异常：ArrayIndexOutOfBoundsException;
2.空指针异常 NullPointerException
情况一
int [] arr=new int []{1,2,3,4};
arr=null;
System.out.print(arr[0]);
情况二
int [] [] arr=new int[3][];
System.out.print(arr[0][0]);
70
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
