JAVA编程学习记录（数组）

第三周：学习数组

数组概念：

数组是存储同一种数据类型多个元素的集合，也可以看成是一个容器。它既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式：

格式1：数组类型 [ ] 数组名；//定义了一个int类型的数组变量a

格式2：数据类型 数组名 [ ];    //定义了一个int类型的变量a数组

//两种格式写法读法不一样，但表达的效果一样，都是定义了一个数组，推荐使用第一种，因为可读性更强。

数组初始化：

Java中的数据必须先初始化，然后才能使用，所谓初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

1.动态初始化：

初始化时只指定数组长度，数组中的元素值由系统默认给定；

格式：    数据类型 [ ] 数组名 = new 数据类型[数组长度]；

 数组长度其实就是数组中元素的个数。    

举例： int a =new int [3]；//定义一个int类型的数组，这个数组中可以存放3个int类型的值；

如何获取元素值呢?这里再次引入数组中一个很重要的特点：就是如何取得数组中的元素呢?
数组为每个元素都分配了编号，从0开始。获取的时候只要数组名配合编号即可。最大编号是长度-1。这个编号专业叫法称：索引。

2.静态初始化：

初始化时指定每个数组元素的初始值，数组的长度由系统给定；

格式：    数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

举例：int[] arr = new int[]{1,2,3};

定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3；

简写：int[] arr = {1,2,3};

数组常见异常

1.ArrayIndexOutOfBoundsException:数组角标越界异常（数组索引越界）

出现的原因:访问了数组中不存在的索引值;

解决方案:观察数组中到底有索引值到多少;  数组长度-1（数组名.length-1）

2.NullPointerException:空指针异常 (在实际开发中该异常是最多的)

出现的原因:对象为null,而开发者还要去使用对象,就会出现问题

解决方案:给某个对象进行非空判断,防止程序程序空指针异常

为什么要记住这些小问题呢?

因为写程序不仅仅是把代码写出来，还包括出现问题后要能够及时的把问题解决。而排错也应该是我们的基本功。所以，我们也应该记住一些常见的问题，以及出错原因和解决方案。

将遇见到的异常建立文档，记录出现该异常的原因以及如何解决异常！

实例练习：

遍历数组：

public class ArrayTest {
	public static void main(String[] args) {
		int [] arr= {1,2,3,4,5};
		//遍历数组
		for(int i=0;i<5;i++) {
			System.out.println(arr[i]);
		}
		System.out.println("---------华丽的分割线---------");
		//如果数组中元素非常多，难以统计元素个数，可采用数组属性：length
		int [] arr2= {1,2,3,4,5,6,7,8,9};
		for(int i=0;i<arr2.length;i++) {
			System.out.println(arr2[i]);
		}
	}
}

获取数组中的最值：

public class ArrayTest {
	public static void main(String[] args) {
		int [] arr= {5,4,2,3,1};
		//定义参照量，假设max为最大值
		int max=arr[0];
		//同理最小值
		int min=arr[0];
		/**
		 * 依次与max比较，大于max时将该元素赋值给max
		 * 以此来获取最值
		 */
		for(int i=0;i<arr.length;i++) {
			if(arr[i]>max)
				max=arr[i];
		}
		System.out.println("最大值为："+max);
		//最小值获取同理
		for(int i=0;i<arr.length;i++) {
			if(arr[i]<min)
				min=arr[i];
		}
		System.out.println("最小值为："+min);
	}		
}

逆序元素：

public class ArrayTest {
	public static void main(String[] args) {
		int [] arr= {5,4,2,3,1};
		//遍历逆序输出一次
		reverse(arr);
		printArry(arr);
		//遍历再逆序，输出原数组
		reverse2(arr);
		printArry(arr);
	}
	//定义一个逆序方法,方式1
	public static void reverse(int [] arr) {
		
		for(int i=0;i<arr.length/2;i++) {
			int temp=arr[i];
			arr[i]=arr[arr.length-1-i];
			arr[arr.length-1-i]=temp;
		}
	}
	//方式2
	public static void reverse2(int [] arr) {
		for(int start = 0,end = arr.length-1 ; start<=end ;start++,end --) {
			//temp中间变量
			int temp=arr[start] ;
			arr [start]=arr[end] ;
			arr [end]=temp ;
		}
	}
	//遍历数组
	public static void printArry(int [] arr) {
		System.out.print("[");
		for(int x = 0 ; x < arr.length ; x ++) {
			//是否是最后索引对应的元素
			if(x==arr.length -1) {
				System.out.println(arr[x] +"]");
			}else {
				System.out.print(arr[x] +", ");
			}
		}
	}
}

根据键盘录入索引查找对应星期：

public class ArrayTest{
	
	public static void main(String[] args) {
				
		//定义一个字符串数组
		String[] str = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"} ;
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//接收数据
		System.out.println("请输入一个数据:(0-6):");
		int index = sc.nextInt() ;
		
		System.out.println("你要查找的是:"+str[index]);
	}
}

数组元素查找：

public class ArrayTest5 {
	
	public static void main(String[] args) {
		
		//定义一个数组:
		int[] arr = {200,250,38,101,300} ;
		//需求1:查找250这个元素在数组中第一次出现的索引
		int index = findIndex(arr, 250) ;
		System.out.println("250元素在数组中第一次出现的索引是:"+index);
		//	//需求2:查找2500这个元素在数组中第一次出现的索引
		int index2 = findIndex(arr, 2500) ;
		System.out.println("2500元素在数组中第一次出现的索引是:"+index2);
		int index3 = getIndex(arr, 38) ;
		System.out.println("index3:"+index3);
		int index4 = getIndex(arr, 380) ;
		System.out.println("index4:"+index4);
	}
	
	/**
	 * 定义一个查找数组中元素的方法
	 * 两个明确
	 * 		1)返回值类型:int
	 * 		2)参数类型:int [] arr ,两个参数, 第二个参数:int value
	 */
	public static int findIndex(int[] arr,int value) {
		//遍历arr数组元素
		for(int x = 0 ; x < arr.length ; x ++) {
			//判断:如果查找的元素恰好就是value值,那么直接返回该索引
			if(arr[x] == value) {
				return x ;
			}
		}
		//不但要考虑找到的情况,还要考虑到找不到的情况
		//在Java中,数组查找元素,如果找不到,返回-1 ,(找不到)
		return - 1;
	}
	//方式2,假设法
	public static int getIndex(int[] arr,int value) {
		//如果没有找到这个元素,假设找不到
		int index = -1 ;
		//遍历数组
		for(int x = 0 ;  x < arr.length ; x ++) {
			//获取到每一个元素,如果找到,修改索引值
			if(arr[x] == value) {
				//修改
				index = x ;
				break ;
			}
		}
		return index ;
	}
}

二维数组    

格式

数据类型 [ ] [ ] 数组名 = new 数据类型 [m] [n] ;

m：代表当前二维数组中有多少个一位数组；

n:代表每一个一位数组的长度；

m,n 必须为正整数；

例如：String str [ ] [ ] = new String [3] [4];    //可以看做一个3行4列的数组

另外两种格式

数据类型 [ ] 数组名 [ ] = new 数据类型[m] [n];

数据类型 数组名 [ ] [ ] = new 数据类型 [m] [n];

定义数组

 1.数据类型 [ ] [ ] 数组名 = new 数据类型 [m] [n] ;

给定一维数组的个数和每个数组的长度；

2.数据类型 [ ] [ ] 数组名 = new 数据类型[m][ ]；

只给定一维数组的个数，每一个一维数组的长度动态给定；

3.数据类型[ ] [ ] 数组名称 = {{元素1,元素2,元素3},{....}，{......}} ;    //静态初始化

例如：int [ ] [ ] arr = {{1,2,3},{4,5,6},{7,8}};

二维数组的遍历

public class ArrayTest {
	public static void main(String[] args) {
		//定义一个二维数组，静态初始化
		int [][] arr = {{1,2,3},{4,5,6},{7,8,9}};
		//调用方法
		printArray(arr);
	
	}
	//写一个遍历方法
	public static void printArray(int [][]arr){
		for(int x=0;x<arr.length;x++) {
			for(int y=0;y<arr[x].length;y++) {
				System.out.print(arr[x][y]+" ");
			}
		}
	}
}

数组高级部分

1. 冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名“冒泡排序”。

两两比较,大的往后放,第一次比较完毕,最大值出现在最大索引出

package 冒泡排序;

public class BubbleSortDemo {

	public static void main(String[] args) {
		// 定义数组
		int[] arr = { 12, 15, 14, 13, 16, 11 };
		// 调用排序方法
		bubbleSort(arr);
		// 调用遍历方法
		printSort(arr);
	}

	// 冒泡排序方法
	public static void bubbleSort(int[] array) {
		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 temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
	}

	// 遍历功能
	public static void printSort(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				System.out.println(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ",");
			}
		}
	}
}

2. 选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。

选择排序: 用0索引对应的元素依次后面索引对应的元素进行比较, 1索引..... 小的数据往前方法,就可以得到一个排好序的数组

package 选择排序;

public class SelectionSort {

	public static void main(String[] args) {
		//定义数组
		int[] arr = {21,23,22,25,24,26};
		//调用排序方法
		selsctionSort(arr);
		//调用遍历输出
		printSort(arr);
		
	}
	//选择排序方法
	public static void selsctionSort(int []arr) {
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if(arr[i]>arr[i+1]) {
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}

	// 遍历功能
	public static void printSort(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				System.out.println(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ",");
			}
		}
	}
}

练习

package ArrayTest;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 把字符串中的字符进行排序。
 * 		举例："dacgebf"
 * 		结果："abcdefg"
 * 
 * 分析:
 * 		1)键盘录入一个字符串"dacgebf"
 * 		2)可以将字符串转换成字符数组
 * 		3)冒泡排序 
 * 		4)最终要字符串类型的数据
 *
 */

public class ArrayTest {

	public static void main(String[] args) {

		// 创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		// 接收数据
		System.out.println("请输入一个字符串");
		String line = sc.nextLine();

		// 字符串转字符数组
		char[] ch = line.toCharArray();
		// 调用排序方法
		bubbleSort(ch);
		// 转为字符串类型输出
		String str = Arrays.toString(ch);
		System.out.println(str);

	}

	// 冒泡排序
	public static void bubbleSort(char[] ch) {

		for (int i = 0; i < ch.length; i++) {
			for (int j = 0; j < ch.length - 1 - i; j++) {
				if (ch[j] > ch[j + 1]) {
					char temp = ch[j];
					ch[j] = ch[j + 1];
					ch[j + 1] = temp;
				}
			}
		}
	}
}