java数组

声明一维数组

语法：数据类型 [] 数组名；

或数据类型 数组名[]

如：String [] args;或String args[]; 

int [] array;或int array[];

声明二维数组

语法：数据类型[][]数组名称

或数据类型 数组名称[][]

Java中建议使用第一种数组声明方式

如： int [][]array;或 String str[][];

一维数组的创建

String []str=new String[6];

int []array={1,2,3,4,5};

二维数组的创建同样有两种方式

 方式一：使用new运算符

String [][]str = new String[5][5];

方式二：声明数组并且赋初始值

int [][] array = {{23,45,45},{12,11,10,56},{23,12}};

数组的访问通过下标来访问；下标从0开始

数组的常用方法

Arrays.fill(数组，value);

Arrays.copyOf(旧数组，新数组长度）

Arrays.binarySearch(a, key)

Arrays.toString(array1)

Arrays.equals(array1, array2)

数组的排序：冒泡，选择，快速，Arrays.sort(arr)工具类；鸡尾酒排序

package com.my.test.Arrays;

import java.util.Arrays;

public class Methods {
	public static void main(String[] args) {
		int []array = new int[5];
		Arrays.fill(array, 3);//数组填充
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i]);
		}
		int[] copyOf = Arrays.copyOf(array, 10);//根据旧数组生成新数组
		System.out.println(copyOf.length);
	
		for (int i = 0; i < copyOf.length; i++) {
			System.out.print(copyOf[i]);
		}
		int []array1= {1,8,2,9,6,4};
		Arrays.sort(array1);//数组排序
		
		System.out.println(Arrays.toString(array1));//打印数组
		int []array2= {1,8,2,9,6,4};
		int binarySearch = Arrays.binarySearch(array2, 6);//返回下标
		System.out.println(binarySearch);
		System.out.println(Arrays.equals(array1, array2));//比较数组相等，顺序和值同时
		
		int[] bubbleSort = bubbleSort(array2);
		System.out.println(Arrays.toString(bubbleSort));
		int[] choseSort = choseSort(array2);
		System.out.println(Arrays.toString(choseSort));
		int[] quickSort = quickSort(array2, 0, array2.length-1);
		System.out.println(Arrays.toString(quickSort));
		
		
		
		
		
		
		
		
		
	}
	/**
	 * 
	 * <p>Title: quickSort</p>  
	 * <p>Description: 快速排序使用了递归调用，最小</p>  
	 * @param arr数组
	 * @param low 0
	 * @param high 数组长度-1
	 * @return
	 */
	private static int[] quickSort(int[] arr,int low,int high){
		int start=low;
		int end=high;
		int key=arr[low];
		while(start<end){
			//从后往前开始比较
			while(end>start && arr[end]>=key)//如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
				end--;
			if(arr[end]<=key){
				int temp=arr[end];
				arr[end]=arr[start];
				arr[start]=temp;
			}
			//从前往后比较
			while(end>start && arr[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置，然后又从后往前比较
				start++;
			if(arr[start]>=key){
				int temp=arr[start];
				arr[start]=arr[end];
				arr[end]=temp;	
			}
		//此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
		}
		//递归
		if(start>low) 
			quickSort(arr,low,start-1);
		if(start<high) 
			quickSort(arr,end+1,high);
		return arr;
				
	}
	
	


	/**
	 * 
	 * <p>Title: choseSort</p>  
	 * <p>Description:选择排序，先假设第一个数是最小的；然后查找最小的值与第一个数交换 </p>  
	 * @param array
	 * @return
	 */
private static int[] choseSort(int[] array) {
	int l = array.length;
	for (int i = 0; i <l; i++) {
		int min = array[i];
		int a = i;
		for (int j = i+1; j < array.length; j++) {
			if(array[j]<min) {
				min = array[j];
				a = j;
			}
			array[a] = array[i];
			array[i] = min;
		}
		
		
	}
	
	return array;	
		
	}
/**
 * 
 * <p>Title: bubbleSort</p>  
 * <p>Description:冒泡排序,将最值移到一端 </p>  
 * @param array
 * @return
 */
	private static int[] bubbleSort(int[] array) {
		int l = array.length;//数组长度
		for (int i = 0; i < l; i++) {
			for (int j = 0; j < l-i-1; j++) {//j<l-i-1
				//交换
				if(array[j]>array[j+1]) {
					int a = array[j];
					array[j] = array[j+1];
					array[j+1] = a;				
					
				}				
				
			}
			
		}
		
		return array;
		
		
	}

}