数组的格式:
public static void main(String[] args) {
//格式1
/**
* 需要一个容器,但是不明确容器的具体数据
*/
int[] arr=new int[3];
//元素类型[] 数组名=new 元素类型[]{元素,元素,...}
/**
* 需要一个容器,存储已知的具体类型。
*/
int arr2[]=new int[] {2,3};
int arr3[]= {2,3,4,5,6};
}
数组的遍历:
int arr2[]=new int[] {2,3};
int arr3[]= {2,3,4};
/**
* 对数组操作最基本的动作就是存和取
* 核心思想:就是对角标的操作。
*/
System.out.println(arr3[1]);
for(int i=0;i<arr3.length;i++) {
System.out.println(arr3[i]);
}
数组常见操作——最值
- 获取最大值
- 获取最小值
public static void main(String[] args) {
/**
* 获取数组中的最大值。 思路: 1.需要进行比较。并定义变量记录住每次比较后较大的值 2.对数组中的元素进行遍历取出,和变量中记录的元素进行比较。
* 如果遍历到的元素大于变量中记录的元素,就用变量记录住该大的值。 3.遍历结果,该变量记录就是最大值
*/
int arr[] = { 2, 4, 9, 0 };
int max = getArrayMax(arr);
int max_jiaobiao=getArrayMax2(arr);
System.out.println(max);
System.out.println(arr[max_jiaobiao]);
}
/**
* 用数值比较
* @param array
* @return
*/
public static int getArrayMax(int array[]) {
int temp = array[0];
for (int i = 1; i < array.length; i++) {
if (temp < array[i]) {
temp = array[i];
}
}
return temp;
}
/**
* 用角标比较
* @param array
* @return
*/
public static int getArrayMax2(int array[]) {
int temp = 0;
for (int i = 0; i < array.length; i++) {
if (array[temp] < array[i]) {
temp = i;
}
}
return temp;
}
数组常见操作选择排序
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[] = new int[] { 23, 24, 3, 35, 29 };
printArray(arr);
sort(arr);
printArray(arr);
}
/**
* 选择排序 从小到大
* @param arr
*/
public static void sort(int arr[]) {
for (int i = 0; i < arr.length - 1; i++) {//这里为什么减1,因为最后一个不需要比较。看如下图:
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
/**
* 输出
* @param arr
*/
public static void printArray(int arr[]) {
for (int k = 0; k < arr.length; k++) {
if(k!=arr.length-1) {
System.out.print(arr[k] + "——");
}else {
System.out.println(arr[k]);
}
}
}
- 首先为什么外循环要减一?
- 因为最后一个不需要在比较。
- y=x+1 ,为什么加一?
- 随着外循环的增加一次,内循环次数减一,也就是说y的值越大了。内循环的次数也就越小了
数组常见操作冒泡排序
数组常见功能:查找
public static void main(String[] args) {
int []arr=new int[] {2,3,4,5};
int []arr2=new int[9];
int index=getIndex(arr, 2);
System.out.println("index="+index);
}
/**
* 数组常见功能:查找
*/
public static int getIndex(int [] arr,int key) {
for(int i=0;i<arr.length;i++) {
if(arr[i]==key) {
return i;
}
}
return -1;
}
数组折半查找
//数组必须是有序的。
public static int halfSearch2(int []arr,int key) {
int max,min,mid;
min=0;
max=arr.length-1;
while(min<=max) {
mid=(min+max)>>1;//mid=(min+max)/2
if(key>arr[mid]) {
min=mid+1;
}else if (key<arr[mid]){
max=mid-1;
}else {
return mid;
}
}
return -1;
}
/**
* 折半查找,
* @param arr 这个数组必须是有序的,从小到大或者从大到小。
* @param key
* @return
*/
public static int halfSearch(int [] arr,int key) {
int max,min,mid;//角标,index
min=0;
max=arr.length-1;
mid=(min+max)/2;
while(arr[mid]!=key) {
if(key>arr[mid]) {
min=mid+1;
}else if(key<arr[mid]) {
max=mid-1;
}
if(max<mid) {
return -1;
}
mid=(min+max)/2;
}
return mid;
}
面试题:
给定一个有序的数组,如果往该数组中存储一个元素,并保证这个数组还是有序的,那么这个元素的存储的角标位如何获取。
有序并且数组查找就想到折半查找
二维数组
- 二维数组的创建
int [][]arr2=new int [3][2];//c创建一个二维数组,该数组中有3个一维数组,每一个一维数组中有2个元素
内存图示
示例:
int [][]arr2=new int [3][2];//创建一个二维数组,该数组中有3个一维数组,每一个一维数组中有2个元素
System.out.println(arr2);//直接打印二维数组
System.out.println(arr2[0]);//直接打印二维数组中的角标0的一维数组 [I@6d06d69c @左边是实体的类型,@右边是哈希值
System.out.println(arr2[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。
打印结果:
[[I@15db9742
[I@6d06d69c
0
- 另外还有一种只定义了二维数组的长度,没有定义一维数组的长度如下:
代码
int[][] arr3=new int [3][];
System.out.println(arr3);//直接打印二维数组
System.out.println(arr3[0]);//null
System.out.println(arr3[0][0]);//没有指向地址
打印结果:
[[I@15db9742
null
Exception in thread "main" java.lang.NullPointerException
at com.study.array2.Array2Demo.main(Array2Demo.java:18)
- 二维数组的另一种形式
//int [][]arr4=new int [3][2];
// System.out.println(arr4.length);//打印二维数组的长度,其实就是一维数组的个数
// System.out.println(arr4[1].length);//打印二维数组中角标为1的一维数组的长度。
int [][] arr5= {{3,2,1},{4,5,6},{4,2}};
for(int i=0;i<arr5.length;i++) {
for(int x=0;x<arr5[i].length;x++) {
System.out.println(arr5[i][x]);
}
}