为什么要有数组
问题1:
声明变量时,每一个变量都是一个单独的空间
表示班级里面的学生的年龄35,全校学生的年龄
第65个学生的年龄,操作,可读,维护
int age1....35 =?
问题2:
求两个数的和需要方法--> 定义2个参数
--> 5个参数
--> 100个参数
定义:
数组:数组是一个定长的容器,数组中存储的数据类型需要是一致的
数组中存储的数据类型:
值类型(基本数据类型):8中基本数据类型
引用类型:数组
使用数据类型定义数组,数组给当前元素存储默认值
byte,short ,int ,long 0
float ,double 0.0
boolean false
char 控制符'\u0000'
引用数据类 null
数组的四种定义方式:
1.标准
数据类型是数组中元素的数据类型
//数据类型[] 数组名 = new 数据类型[数组中元素的个数]
int[] array = new int[10];
ps:数组是有默认值的{0,0,0,0,0,0,0,0,0,0,}
int数据类型是数组中元素的数据类型
数组的数据类型是 int[]
元素 --> 数组中储存的值
数组的长度 --> 数组中的元素个数
2.先声明数组,然后再进行赋值
//在类中,定义成员变量,方法传递
int[] array2;
array2 = new int[10];
3.创建数组的同时,给定当前数组中储存元素的值
//数组的长度:后面{}中储存多少个值,数组就有多长
int[] array3 = new int[]{1,2,3,4}
4.第3的简化版本
int[] array4 = {1,2,3,4}
数组的静态赋值和动态赋值
静态赋值
在创建数组的同时就给当前数组进行赋值
int[] array = {1,2,3};
动态赋值
先创建好数组,然后在向数组中存储值
Scanner -->next() nextInt()
随机数 Math.random();
数组的下标和数组中元素的访问
数组的下标是从0开始,到当前数组的长度-1结束
例如: int[] array = new int[3];
{0,0,0}
0 1 2
//数组的下标是从0开始到数组长度-1结束
int[] array = new int[10];
//取出数组中的值 --> 数组名[下标值]
int x = array[0];
array[9] = 10;
//属性length -->获取数组的长度 数组名.length
System.out.println(array.length); //10
数组的遍历
1.普通for循环
for(int i = 数组第一个元素的下标; i < 数组的长度; i++){
数组名[i] //取值和赋值操作
}
2.增强for循环 --> foreach JDK1.5
for(数组中元素的数据类型 变量名 :数组名){
可以对变量进行操作
}
ps:将数组中的元素的值取出来,存储到当前变量中,对变量进行一个操作了
增强for循环只能用来对数组中的元素进行取值或操作值进行计算等操作,
但是不能对数组中原有存储的值进行修改
数组排序
数组排序有很多中:冒泡 ,选择,插入,快速,堆等等
* 速度最快的就是 堆 排序
冒泡排序 ( 两两相比 )
是相邻的两个数组元素进行比较
若当前元素大于后面的元素,交换两个元素的位置
若当前元素不大于后面的元素,就不交换
比较所有相邻的元素,最终的到一个有序的结果
冒泡最大的特点就是会先找出最大的值,然后放到数组的最后一位
升序(从小到大),降序(从大小) --> 默认排序都是升序
只要经过一轮排序,肯定会有一个数放到正确的位置上
3,7,4,6,9,1 --> 存储到数组中是无序,通过冒泡排序,数组升序排列
3,4,6,7,1,9 -- > 9
3,4,6,1,7,9 --> 7,9
3,4,1,6,7,9 --> 6,7,9
3,1,4,6,7,9 --> 4,6,7,9
1,3,4,6,7,9 --> 1,3,4,6,7,9
for(int i = 0 ; i < array.length - 1 ; i++){
for(int j = 0 ; j < array.length -1 -i ; j++){
if(array[j] > array[j + 1]){
int tmp = array[j];
array[j] = array[j+1];
array[j + 1] = tmp;
}
}
选择排序 ( 固定一位一次向后比 )
升序(从小到大),降序(从大小) --> 默认排序都是升序
固定一个元素,依次和后面的元素进行比较
若当前元素大于后面的元素,交换
若当前元素不大于后面的元素,不交换
每次比较完成们都会有一个数放到正确的位置上,小的那个数
3,7,4,6,9,1 --> 存储到数组中是无序,通过冒泡排序,数组升序排列
1,7,4,6,9,3 --> 1
1,3,7,6,9,4 --> 1,3
1,3,4,7,9,6 --> 1,3,4
1,3,4,6,9,7 --> 1,3,4,6
1,3,4,6,7,9 --> 1,3,4,6,7,9
for(int i = 0 ; i < array.length ; i++){
for(int j = i+1 ; j < array.length ;j++){
if(array[i] > array[j]){
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
}
数组的基本操作
线性查找(顺序查找)
从数组中的第一个元素开始,依次向后查找,直到找当前要查找的值
要么是找到了,要么就是没有找到
//顺序查找
for (int i = 0; i < array.length; i++) {
if(n == array[i]){
return i; //需要范围找到的下标,系统API
}
}
return -1; //返回一个负数
return i; //需要范围找到的下标,系统API
}
}
return -1; //返回一个负数
折半查找(二分查找) 先排序
一定是一个有序的数组,通过待查找的数和数组中间索引值进行比较
大于: 待查找值大于中间索引值,就需要向数组的右半边进行查找
等于:待查找值等于中间索引值,就是找到了
小于:待查找值下于中间索引值,就需要向数组的左半边进行查找
//定义开始值
int beginIndex = 0;
//定义结束值
int endIndex = array.length-1;
//获取中间值
int middleIndex = (beginIndex+endIndex)/2;
//进行比较 用中间值来比较要查找的值
//第一种比较的次数应该是数组的长度
//第二中死循环
while(true){
//缩小范围
if(n > array[middleIndex]){
//修改开始值
beginIndex = middleIndex+1;
}else if(n < array[middleIndex]){
//修改结束值
endIndex = middleIndex -1;
}else{
return middleIndex;
}
//无论是开始值还是结束中发生了改变
//就要重新结算中间值
middleIndex = (beginIndex+endIndex)/2;
//若出现了一种情况 开始 > 结束
if(beginIndex > endIndex){
return -1;
}
}
增加
修改
public static boolean ChangeArrayNumber(int[] array,int location,int number){
if( location >= array.length){
return false;
}else{
array[location] = number;
return true;
}
}
删除
//定义一个变量,统计删除的个数
int count = 0;
//去掉删除的次数
for(int i = 0;i<array.length-count;i++){
if(RNum == array[i]){
//向前移动
for(int j = i;j<array.length-1;j++){
//后一个元素向前移动覆盖
array[j] = array[j+1];
}
count++;
i--; //向后移动一次
}
}
return count;
二维数组:
格式 一: 数据类型 [] [] 变量名 = new 数据类型 [ m ] [ n ];
m: 表示这个二维数组有多少个一维数组
n: 表示每一个一维数组的元素个数
int [] [] arr = new int[3][2]
int [] [] arr = new int [] []{{1,2},{6,4,9},{9,5,13,4}};
遍历:
for(int i =0 ; i<arr.length;i++){
for(int y=0;y<arr[x].length;y++){
system.out.println(arr[x][y]);
}
}