一、数组的含义
数组是一个具有相同数据类型的一组数据的集合。例如，球类的集合——排球、篮球、乒乓球球等；电器集合——冰箱、空调、电热水器等。数组有两种，一维数组和二维数组。
二、一维数组的创建和使用
1、创建一维数组
数组作为对象允许使用new关键字进行内存分配。符号“[ ]”：指明该变量是一个数组类型变量，单个“[ ]”表示要创建的数组是一维数组
声明一维数组有两种形式，语法如下所示：
数组元素类型 ?数组名字[ ];
例如：int arr[]? ??
数组元素类型[ ] ?数组名字;
例如：int []arr
数组名字 =new?数组元素类型[数组元素的个数]
例如：arr=new int[8]
2、初始化一维数组
数组可以与基本数据类型一样进行初始化操作，数组的初始化可分别初始化数组中每个元素。
int arr[] = new int[]{1,2,3,5,25};?? ?//第一种初始化方式
int arr2[] = {34,23,12,6};?? ??? ?//第二种初始化方式
3、使用一维数组
String zhou[]=new String[] {"周日","周一","周二","周三","周四","周五","周六"};
//含有7个字符串元素
for(int i=0;i<=6;i++){ //由于素组是0开始，用for循环一一展现
System.out.println(zhou[i]);
}
/*输出结果：
周日
周一
周二
周三
周四
周五
周六
*/
三、二维数组的创建及使用
1、二维数组的创建??
符号“[ ]”：指明该变量是一个数组类型变量，两个“[ ]”表示要创建的数组是二维数组。
数组元素类型 数组名字[ ][ ];
例如：int arr[][]
数组元素类型[ ][ ] 数组名字;
例如：int [][]arr
2、二维数组初始化
type arrayname[][] = {value1,value2…valuen};
type：数组数据类型
arrayname：数组名称，一个合法的标识符
value：数组中各元素的值
例如：int arr[][]={{11,0},{55,33}}
3、使用二维数组
int arr[][]=new int[5][6]; //定义二维数组
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
System.out.print(arr[i][j]);
}
System.out.println();
}
/*输出结果：
000000
000000
000000
000000
000000
*/
四、数组的基本操作
1、遍历数组
遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。
int arr[][]=new int[][] {{23,24},{11,17,13}}; //定义二维数组
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
System.out.print(arr[i][j]);
System.out.print(",");
}
System.out.println();
}
/*输出结果：
23,24,
11,17,13,
*/
2、填充替换数组元素
数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。
（1）fill(int[] a,int value)
int[] a：需要替换的数组
value：替换的值
int arr[]=new int[5]; //定义二维数组
Arrays.fill(arr, 8); //对数组进行填充
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]);
}
//输出结果：88888
（2）fill(int[] a,int fromIndex,int toIndex,int value)
int[] a：需要替换的数组
fromIndex：指定填充第一个元素（包括）
toIndex：指定填充最后一个元素（不包括）
value：替换的值
int arr[]=new int[] {1,2,3,4,5,6,7,8,9}; //定义二维数组
Arrays.fill(arr,1,2,23 ); //对数组1至2之间进行填充
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]);
System.out.print(" ");
}
//输出结果：1 23 3 4 5 6 7 8 9
3、对数组进行排序
通过Arrays类的静态sort()方法可实现对数组排序，可对任意类型数组进行升序排序。
Arrays.sort(object)
object：指进行排序的数组名称
int arr[]=new int[] {5,2,1,4,3,6,8,7,9}; //定义二维数组
Arrays.sort(arr); //进行数组排序（升序）
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]);
System.out.print(" ");
}
//输出结果：1 2 3 4 5 6 7 8 9
4、复制数组
Arrarys类的copyOf()方法与copyOfRange()方法可实现对数组的复制。
copyOf(arr,int newlength)方法是复制数组至指定长度
arr：要复制的数组。
newlength：新数组长度。
int arr[]=new int[] {5,2,1,4,3}; //定义二维数组
int arr11[]=Arrays.copyOf(arr, 8); //进行数组排序（升序）
for(int i=0;i<arr11.length;i++){
System.out.print(arr11[i]);
System.out.print(" ");
}
//输出结果：5 2 1 4 3
copyOfRange(arr,int fromIdenx,int toIndex)方法则将指定数组的指定长度复制到一个新数组中。
arr：要复制的数组。
fromIdenx:开始的索引位置。
toIndex：要复制的最后索引位置。
int arr[]=new int[] {5,2,1,4,3}; //定义二维数组
int arr11[]=Arrays.copyOfRange(arr, 0,2); //进行数组排序（升序）
for(int i=0;i<arr11.length;i++){
System.out.print(arr11[i]);
System.out.print(" ");
}
//输出结果：5 2
5、数组查询
Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。
（1）binarySearch(Object[] a,Object key)
a:搜索的数组。
key:要搜索的值。
int arr[]=new int[] {5,2,1,4,3}; //定义二维数组
int arr11=Arrays.binarySearch(arr, 1); //数组查询
System.out.print(arr11);
//输出结果：2
（2）binarySearch(Object[] a,int fromIndex , int toIndex,Object key)
a:搜索的数组。
key:要搜索的值。
fromIndex：指定搜索第一个元素（包括）
toIndex：指定搜索最后一个元素（不包括）
int arr[]=new int[] {5,2,1,4,3,2,2}; //定义二维数组
int arr11=Arrays.binarySearch(arr,1,3,2); //数组查询1至3之间搜索2
System.out.print(arr11);
//输出结果：1
五、数组排序算法
1、冒泡排序
冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是小数往前放，大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。
package bao;
import java.util.Arrays;
public class Demo1 {
public static void main(String[] args) {
int arr[]= {54,33,23,24,17,13,2}; //创建一维数组
Demo1 demo=new Demo1(); //创建冒泡排序类对象
demo.sort(arr);//调用冒泡排序
}
/*
冒泡排序
*/
public void sort(int[]arr) {
for(int i=1;i<arr.length;i++) {
//比较相邻的两个元素，较大的往后排序
for(int j=0;j<arr.length-1;j++) {
if(arr[j]>arr[j+1]) {
int temp=arr[j]; //第一个元素保存到临时变量
arr[j]=arr[j+1]; //第二元素保存到第一个元素单元单元中
arr[j+1]=temp; //把临时变量保存到第二个单元
}
}
}
showArr(arr);
}
/*
* 显示数组所有元素
*/
public void showArr(int[] arr) {
for(int i:arr) {
System.out.print(" "+i);
}
}
}
//输出结果： 2 13 17 23 24 33 54
2、直接选择排序???????
package bao;
import java.util.Arrays;
public class Demo1 {
public static void main(String[] args) {
int arr[]= {54,33,23,24,17,13,2}; //创建一维数组
Demo1 demo=new Demo1(); //创建冒泡排序类对象
demo.sort(arr);//调用冒泡排序
}
/*
直接选择排序
*/
public void sort(int[]arr) {
int ido;
for(int i=1;i<arr.length;i++) {
ido=0;
for(int j=0;j<arr.length-1;j++) {
if(arr[j]>arr[ido]) {
ido=j;
}
}
//交换位置array.length-i和ido（最大值）
int temp=arr[arr.length-i];
arr[arr.length-i]=arr[ido];
arr[ido]=temp;
}
showArr(arr);
}
/*
* 显示数组所有元素
*/
public void showArr(int[] arr) {
for(int i:arr) {
System.out.print(" "+i);
}
}
}
//输出结果： 2 13 17 23 24 33 54
3、反转排序?
反转数组就是以相反的顺序把原有数组的内容重新排序。
package bao;
import java.util.Arrays;
public class Demo1 {
public static void main(String[] args) {
int arr[]= {1,2,3,4,5,6,7}; //创建一维数组
Demo1 demo=new Demo1(); //创建冒泡排序类对象
demo.sort(arr);//调用冒泡排序
}
/*
反转排序
*/
public void sort(int[]arr) {
System.out.println("原来数组：");
showArr(arr);
int temp;
int arrlen=arr.length;
for(int i=0;i<=arrlen/2;i++) {
//交换位置array.length-i和ido（最大值）
temp=arr[i];
arr[i]=arr[arrlen-1-i];
arr[arrlen-1-i]=temp;
}
System.out.println();
System.out.println("反转后数组：");
showArr(arr);
}
/*
* 显示数组所有元素
*/
public void showArr(int[] arr) {
for(int i:arr) {
System.out.print(" "+i);
}
}
}
/*输出结果：
原来数组：
1 2 3 4 5 6 7
反转后数组：
7 6 5 4 3 2 1
*/
|