Java一维数组知识简介及相关习题

一维数组

• 存储同一种数据类型的多个元素的容器。
  1）定义格式：
• 数据类型[] 数组名; int[] a;
• 数据类型 数组名[]; int a[];
  2）对数组进行初始化
• 所谓初始化就是为数组开辟内存空间，并为每一个数组元素赋值；
• 动态初始化：只指定长度，由系统给出初始化值；
  格式： 数据类型[] 数组名 = new 数据类型[数组长度];
• 静态初始化：给出初始化值，由系统决定长度
  格式：数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，，，};
  简化格式： 数据类型 [] 数组名 = {元素1，元素2，元素3，，，};
• 不要同时动态和静态进行，会报错。

int[] arr = new int[4];//动态
int[] arr1 = {1,2,3,4};//静态初始化

（3）遍历数组

• 数组名[索引]；
• 从0开始，最大索引是数组的长度-1；
• length专门用于获取数组的长度。格式：数组名.length（返回数组的长度）
• 用方法改进进行数组的遍历

/*
	返回值类型：void
	参数列表：int[] arr
	void类型：单独调用：printArray(数组名);
*/
public static void printArray(int[] arr){
   System.out.print("[");
   	for(intx=0;x<=arr.length-1;x++){
   		if(x==arr.length-1){//这是最后一个元素的输出
   			System.out.println(arr[x]+"]");
   		}else{
   			System.out.println(arr[x]);
   		}
   	}
   }

（4）数组逆序

/*
	分析：
		把0索引和arr.length-1的数据交换
		把1索引和arr.length-2的数据交换
		...
		只要做到arr.length/2的时候即可。
*/
class ArrayTest1
{
	public static void main(String[] args) 
	{
		//定义一个数组，并进行静态初始化
		int[] arr={12,34,56,78,90,99,120};
		System.out.println("逆序前的数组：");
		printArray(arr);
		System.out.println("逆序后的数组:");
		transArray(arr);
		printArray(arr);
		System.out.println("逆序后的数组:");
		trans2Array(arr);
		printArray(arr);//两次逆序，又变成原来的数组
	}
	//遍历输出数组
	public static void printArray(int[] arr){
    	System.out.print("[");
		for(int x=0;x<=arr.length-1;x++){
			if(x==arr.length-1){//这是最后一个元素的输出
				System.out.println(arr[x]+"]");
			}else{
				System.out.print(arr[x]+",");
			}
		}
    }
	//交换进行逆序
	public static void transArray(int[] arr){
		for(int x=0;x<arr.length/2;x++){
			int temp =arr[x];
			arr[x]=arr[arr.length-1-x];
			arr[arr.length-1-x]=temp;
		}
	}
	public static void trans2Array(int[] arr){//可以同时定义两个变量，用逗号隔开
		for(int start=0,end=arr.length-1;start<=end;start++,end--){
			int temp=arr[start];
			arr[start]=arr[end];
			arr[end]=temp;
		}
	}
}

（5）数组元素查找

• 查找指定元素在数组出现的第一次索引

/*
	分析：
		遍历数组，依次获取数组中的每一个元素，和已知的数据进行比较
		如果相等，就返回当前的索引值
*/
class  ArrayTest2
{
	public static void main(String[] args) 
	{
		//定义一个数组，并静态初始化
		int[] arr ={22,32,45,56,67,78,90,32,45};
		int index=getIndex(arr,32);//返回int,定义一个int型接收调用的结果
		System.out.println(32+"在数组的第一次索引是："+index);
	}
	public static int getIndex(int[] arr,int value){//索引值为数组下标，返回int型
		int index= -1;//定义一个索引，找不到返回-1
		for(int x=0;x<arr.length;x++){
			if(arr[x]==value){
				index =x;//如果相等，就返回当前的索引值
				break;
			}
		}
		return index;
	}
}

（6）对数组进行从大到小排序（冒泡排序）

public class Test3{
  public static void main(String[]args){
    int[]arr={74,23,13,36,51,49,66,93};
    bubbleSort(arr);
  }
  /*
  	分析：从最后一个元素开始，逐一将它前面的所有元素与它进行大小比较
  */
  public static void bubbleSort(int []arr){
    int temp;
	for(int i=arr.length-1;i>0;i--){//外循环从最后一个开始
	for(int j=0;j<i;j++){//内循环控制从第一个开始比较
	  if(arr[j]>arr[j+1]){
	    temp=arr[j+1];
		arr[j+1]=arr[j];
		arr[j]=temp;
	  }
	}
	}
   for(int e:arr){//输出排序后的数组
    System.out.print(e+"  ");
   }
  }
}

（7）使用java自带的Arrays工具类进行从小到大排序

/*
  Arrays是sun提供的一个工具类
   java.util.Arrays;
   该工具类主要针对的是数组的操作
      排序，以及排好序之后的二分查找
*/
import java.util.Arrays;
public class Test4{
  public static void main(String []args){
    int[]arr1={1,5,4,2,9,6};
	//排序
	Arrays.sort(arr1);//从小到大
	//输出（从小到大）
	for(int i=0;i<arr1.length;i++){
	 	System.out.print(arr1[i]+" ");
	}
	//如果要从大到小排序，可以逆序输出
	for(int i=arr1.length-1;i>=0;i--){
		System.out.print(arr1[i]+" ");
	}
	//对排序之后的数据进行二分查找
	System.out.println();//换行
	int index=Arrays.binarySearch(arr1,1);//1的下标是0
	System.out.println("1的索引是:"+index);
  }
}

（8）使用选择排序算法

/*
	每一趟从待排序的数据元素中选出最小（或最大），
	顺序放在已排好的数列后面，直到全部排完待排序的数据元素。
*/
class Test5 
{
	public static void main(String[] args) 
	{
		int[] arr={21,23,45,67,3,4,23};
		int min;
		int temp;
		for(int i=0;i<=arr.length-1;i++){
			//假设第一个数是最小值
			min=i;
			//内循环的作用是找到每一趟真正的最小值
			for(int j=i+1;j<=arr.length-1;j++){
				if(arr[min]>arr[j])
				min=j;
			}
			if(min!=i){
				temp=arr[i];
				arr[i]=arr[min];//把最小值存放到第i次寻找的第i个位置
				arr[min]=temp;
			}
		}
		//输出（从小到大）
		for(int i=0;i<=arr.length-1;i++){
			System.out.print(arr[i]+" ");
		}
	}
}