Java学习第五章

第五章：数组

一.数组是什么？

我们原来用普通变量例如int、double、char定义变量的时候，会遇到不知道到底定义几个变量，定义变量太多的情况，不好区分，而且复杂，所以在Java中我们引用了数组来解决这个问题。数组的本质是空间大小相等，地址连续的一篇储存空间，在同一个数组中，所有元素的类型必须是统一的，如果数组的类型是int，那么这个数组中所有元素都必须为int类型。

数组的长度定义时可为变量，但定义后不可改变。

 二.一维数组的定义。

1. 数据类型[] 数组名=new 数据类型[长度];
2. 数据类型[] 数组名=new 数据类型[]{1,2,3,4,5}；
3. 数据类型[] 数组名={1,2,3,4,5};

例如我们定义一个长度为10的数组：

public class test{
	public static void main(String []args) {
		int []num = new int[10];
	}
}

在这个数组中，如果要访问数组中的某一个元素，我们只需要访问这个元素对应的下标即可。

数组元素下标是从0开始的，数组最后一个元素的下标是数组的长度-1

数组的遍历输出一般使用循环，我们来看一下这个数组没有被初始化任何数值它输出的是什么？

public class test{
	public static void main(String []args) {
		int []num = new int[10];
		for(int i = 0;i<num.length;i++) {
			System.out.println(num[i]);
		}
	}
}

 我们发现输出的结果为十个0。这是因为在Java中我们定义的元素是默认被赋予初值的。他们分别为：

• int类型：0
• double类型：0.0
• 布尔类型：false
• 引用数据类型：null

我们使用数组名.length来读取数组的长度

 我们对数组进行输入赋值：

import java.util.Scanner;
public class test{
	public static void main(String []args) {
		int []num = new int[10];
		Scanner in = new Scanner(System.in);
		for (int i = 0;i<10;i++) {
			num[i] = in.nextInt();
		}
		for (int i = 0;i<10;i++) {
			System.out.println(num[i]);
		}
	}
}

我们读取用户输入的数值对数组进行赋值。最后输出结果。

数组通过角标来访问元素的具体计算方式是 所要访问数据的地址=首元素地址+角标*数据类型大小

三.数组的最大值最小值问题

我们读取数组的最大值最小值依然采用便利的方法来判断，例如我们先给数组赋值，然后调用函数求最大值：

import java.util.Scanner;
public class test{
	public static int max(int []a){
		int max = a[0];
		for (int i =0;i<a.length;i++) {
			if (a[i]>max) max = a[i];
		}
		return max;
	}
	public static void main(String []args) {
		int []num = new int[]{1,2,3,4,5,6,7,8,9,10};
		Scanner in = new Scanner(System.in);
		int max= max(num);
		System.out.println(max);
	}
}

 我们通过函数将num数组中最大值通过遍历找出来，最后返回主函数输出。

调用函数求最小值：

import java.util.Scanner;
public class test{
	public static int min(int []a){
		int min = a[0];
		for (int i =0;i<a.length;i++) {
			if (a[i]<min) min = a[i];
		}
		return min;
	}
	public static void main(String []args) {
		int []num = new int[]{1,2,3,4,5,6,7,8,9,10};
		Scanner in = new Scanner(System.in);
		int min= min(num);
		System.out.println(min);
	}
}

方法同求最小值。

四.数组的查找

1.线性查找

import java.util.Scanner;
public class test{
	public static void main(String []args) {
		int []num = new int[]{1,2,3,4,5,6,7,8,9,10};
		Scanner in = new Scanner(System.in);
		int key = 11;
		int m = 0 ;
		boolean find = false;
		for (int i = 0;i<num.length;i++) {
			if (num[i]==key) {
				find = true;
				m = i+1;
			}
		}
		if(find) {
			System.out.println("第"+m+"个");
		}else {
			System.out.println("没找到");
		}
	}
}

线性查找，就是把数组遍历一遍，看数组中有没有需要查找的数值，如果有，就输出第几个，否则输出没找到。

这个很简单，但是效率很低，在数据量很大的时候不适用。我们采用二分查找实现。

2.二分查找

二分查找就是每次取数组中间的数值，数组的可以取到的数值随查找的进行而改变。

比如我们要查找8这个元素，第一次先找中间是5，比8小，第二次我们找5右半部分的中间，是8就找到了。

具体代码如下：

import java.util.Scanner;
public class test{
	public static void main(String []args) {
		int []num = new int[]{1,2,3,4,5,6,7,8,9,10};
		Scanner in = new Scanner(System.in);
		int key = 2;
		int left = 0;
		int right = num.length-1;
		int mid = (left+right)/2;
		boolean flag = true;
		while (num[mid]!=key) {
			if (num[mid]>key) {
				right = mid-1;
				mid = (left+right)/2;
			}
			if (num[mid]<key) {
				left = mid+1;
				mid = (left+right)/2;
			}
			if (left>right) {
				flag = false ;
				break;
			}			
		}
		if (flag) {
			System.out.print(mid);
		}else {
			System.out.print("no find");
		}
	}
}

 二分查找大大提高了查找效率，适用于数据较多时的查找。

五.数组的排序

1.选择排序法

选择排序法是比较常见的一种排序法，不过他的算法的时间复杂度太高，一般不用选择排序法，快速排序更受欢迎，不过选择排序法适合初学者入门排序。选择排序法是开始第一个数字和后面所有的数字进行比较，比他小的和第一个数字进行交换，这样就找出来了最小的数字放在第一位，然后第二个和后面的进行比较，比他小的和他交换，以此类推，我们看看代码：

 public static void selectSort(){
        int[] arr={8,5,9,2,7,4,6,1,3};
        for(int i=0;i<arr.length-1;i++){//-1是因为没有必要进行最后一个数字的比较
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]>arr[j]){
                    swap(arr,i,j);//即用-即释放
                }
            }
        }
        show(arr);
    }
 public static void show(int[] arr){
        //[1,2,3,4,5,6,7,8,9]
        String s="[";
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                s+=arr[i]+"]";
            }else{
                s+=arr[i]+",";
            }
        }
        System.out.println(s);
    }
}
public static void swap(int[] arr,int i,int j){
    arr[i]=arr[i]+arr[j];
        arr[j]=arr[i]-arr[j];
        arr[i]=arr[i]-arr[j];
    }

2.冒泡排序

冒泡排序是相邻两个数字之间进行比较，从左开始，如果大就和右边的交换，最后最右边的就是最大的数字。后然第二轮排序依旧从第一个数字开始，到倒数第二个数字。每次都在右边少排序一个数字。所以代码这么写：

public static void bubbleSort(){
        int[] arr={8,5,9,2,7,4,6,1,3};
        for(int i=0;i<arr.length-1;i++){//-1是少一轮比较
            for(int j=0;j<arr.length-1-i;j++){//-1避免重复比较和角标越界
                if(arr[j]>arr[j+1]){