声明一维数组
语法:数据类型 [] 数组名;
或数据类型 数组名[]
如: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;
}
}