JAVA数组详解

为什么要有数组

问题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]);
}
}