JAVA_TOJAVASE_Day05(数组 、数组排序、冒泡法和排序法)

数组的格式：

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