Java数组求职_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;//返回一个负数

折半查找(二分查找) 先排序

一定是一个有序的数组,通过待查找的数和数组中间索引值进行比较

大于: 待查找值大于中间索引值,就需要向数组的右半边进行查找

等于:待查找值等于中间索引值,就是找到了

小于:待查找值下于中间索引值,就需要向数组的左半边进行查找

//定义开始值

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

if(RNum == array[i]){

//向前移动

for(int j = i;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

for(int y=0;y

system.out.println(arr[x][y]);

}

}