数组
1. 数组的创建及使用
1.1 创建数组
创建一维数组
- 先声明，再用new运算符进行内存分配：
声明：
数组元素类型 数组名字[]；
数组元素类型[] 数组名字；
例：
int arr[];
String[] str;
内存分配:
数组名字 =new 数组元素的类型 [数组元素的个数]；
例：
arr = new int[5];
str= new String [6];
- 声明的同时为数组分配内存
例：
int moth[]=new int[12];
二维数组的创建同一维数组：
例：
int arr[][];//第一种声明方式
int[][] arr2;//第二种声明方式
//内存分配
arr=new int [2][4];//第一种方式，直接分配
//分别为每一维进行分配。
arr2=new int[2][];
arr2[0]= new int[2];
arr[1]=new int [4];
1.2 数组初始化
1.初始化一维数组
int arr[]=new int[]{1,2,3,4}; //第一种方式
int arr2[]={23,45,67}; //第二种方式
2.初始化二维数组
int a[][]={{1,2},{4,3}};
a[1][1]=20;
PS:整型数组内存分配后，未对其进行赋值，其各元素初值全部为0.
2. 数组的基本操作
2.1 遍历数组
遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。
实例：
public class arr {
public static void main(String[] args) {
System.out.println("for循环遍历：");
Trap();
System.out.println("foreach遍历：");
Tautog();
}
public static void Trap()
{
//for循环遍历数组
int b[][]={{1},{1,2},{2,3,4}};
for (int k=0;k<b.length;k++)
{
for (int j=0;j<b[k].length;j++)
{
System.out.print("["+b[k][j]+"]");
}
System.out.println();
}
}
//foreach语句遍历数组
public static void Tautog()
{
int[][] a={{4,3},{2,1}};
for (int[] x:a)
{
for (int j: x)
System.out.print("["+j+"]");
System.out.println();
}
}
}
运行结果为：
2.2 替换数组元素
数组定义完成后，可以通过Array类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素进行替换。
（1）fill(int[], int value)
该方法可将指定的int至分配给int型数组的每个元素。
（2）fill(int[], int fromIndex, int toIndex, int value)
该方法是将指定的值从fromIndex（包含）位置到toIndex（不包含）位置的数组值替换为value。
import java.util.Arrays;
public class Displace {
public static void main(String[] args) {
Fill();
replace();
}
public static void Fill()
{
int[] arr=new int[5];
Arrays.fill(arr,15);
int i=0;
for (int x:arr)
{
i++;
if(i!= arr.length)
System.out.print("["+x+"],");
else
System.out.println("["+x+"]"); //[15],[15],[15],[15],[15]
}
}
public static void replace()
{
int arr[] =new int[]{45,56,798,48,45};
Arrays.fill(arr,1,2,8);
int i=0;
for (int x:arr)
{
i++;
if(i!=arr.length)
System.out.print("["+x+"],");
else
System.out.println("["+x+"]"); //[45],[8],[798],[48],[45]
}
}
}
2.3对数组进行排序
通过Arrays类的静态方法sort（）可实现对数组的排序。
升序排序：
Arrays.sort(object) 其中object为进行排序的数组名称。
import java.util.Arrays;
public class Displace {
public static void main(String[] args) {
taxis();
}
public static void taxis()
{
int arr[]={45,34,84,72,78};
Arrays.sort(arr);
for (int x:arr)
System.out.print("["+x+"]");
System.out.println();
}
//输出结果为：[34][45][72][78][84]
}
2.4 复制数组
Arrays类的copyOf()和copyOfRange()方法可以实现对数组的复制。copyOf()是复制数组至指定长度，copyOfRange()将指定数组的长度复制到一个新数组中。
copy0f(arr, int newlength)(扩充时，整型使用0填充；字符型使用null来填充。)
copyOfRange(arr ,int formIndex,int toIndex)
import java.util.Arrays;
public class Displace {
public static void main(String[] args) {
cope();repeat();
}
//数组复制
public static void cope()
{
int arr[]=new int[]{12,45,69};
int[] n_arr=Arrays.copyOf(arr,10);
for (int x:n_arr)
{
System.out.print("["+x+"]");
}
System.out.println();
} //[12][45][69][0][0][0][0][0][0][0]
public static void repeat()
{
int arr[]={23,45,78,16,41};
int m_arr[]=Arrays.copyOfRange(arr,2,10);
for (int x:m_arr)
{
System.out.print("["+x+"]");
}
System.out.println();
} //[78][16][41][0][0][0][0][0]
}
2.5 数组查询
Arrays类的binarySearch()方法，可以使用二分搜索法来搜索指定数组，以获取指定对象。该方法返回要搜索元素的索引值。
(1)binarySearch(Object[] a, Object key)
(2)binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
PS:使用Arrays.binarySearch()方法之前需要先对数组进行排序操作，才能获得唯一结果。如果数组中包含多个带有指定值的元素，无法保证找到的是哪一个。
import java.util.Arrays;
public class Displace {
public static void main(String[] args) {
reference();
frange();
}
//数组查询
public static void reference()
{
int a[]={ 4,5,2,7,3,9,1};
Arrays.sort(a); //a={1,2,3,4,5,7,9}
int index=Arrays.binarySearch(a,4);
System.out.println("4的索引位置为："+index);
int index1=Arrays.binarySearch(a,8);
System.out.println("6的索引位置为："+index1);
}
//在指定范围内查找元素
public static void frange()
{
String a[]={"DF","AB","AC","YX","XY","ABC"};
Arrays.sort(a);
int index =Arrays.binarySearch(a,0,3,"DF");
System.out.println("DF的索引位置为："+index);
}
}
3.数组排序算法
3.1 冒泡排序
基本思想：依次对相邻的两个元素进行比较，如果满足交换条件就交换元素值，把较小的元素值移到前面，把大的元素值移动到数组后面，这样较小的元素就像气泡一样从底部上升到顶部。
点击查看代码(冒泡排序示例)
public class SortArrays {
public static void main(String[] args) {
int arr[]={64,48,123,46,1,5,7,81};
SortArrays sorter=new SortArrays();
//sorter.BublleSort(arr); //[1][5][7][46][48][64][81][123]
System.out.println();
sorter.bubblesort(arr);
}
//冒泡排序
public void BublleSort(int[] array)
{
for (int i=1;i<array.length;i++) //控制冒泡排序的轮数
{
for (int j=0;j<array.length-i;j++)
{
if(array[j]>array[j+1])
{
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
showArray(array);
}
public void showArray(int[] array)
{
for (int x:array)
System.out.print("["+x+"]");
}
//逆序冒泡
public void bubblesort(int[] array)
{
for (int i=1;i<array.length;i++) //控制冒泡排序的轮数
{
for (int j=array.length-1;j>=i;j--)
{
if(array[j]<array[j-1])
{
int temp=array[j];
array[j]=array[j-1];
array[j-1]=temp;
}
}
}
showArray(array);
}
}
3.2 直接选择排序
基本思想：直接选择排序是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。
点击查看代码(直接选择排序示例)
public class SortArrays {
public static void main(String[] args) {
int arr[]={64,48,123,46,1,5,7,81};
SortArrays sorter=new SortArrays();
sorter.select(arr);
}
public void showArray(int[] array)
{
for (int x:array)
System.out.print("["+x+"]");
}
//直接选择排序
public void select(int[] array)
{
int index;
for (int i=1;i< array.length;i++) //控制循环轮数
{
index=0;
for (int j=1;j<=array.length-i;j++) //控制一趟的比较次数
{
if (array[j]>array[index]) //在一趟中找到最大的那个值的索引
{
index=j;
}
}
int temp=array[array.length-i];
array[array.length-i]=array[index];
array[index]=temp;
}
showArray(array);
}
}
3.3 反转排序
基本思想：把数组最后一个元素与第一个元素替换，倒数第二个元素和第二个元素替换，以此类推，直到把所有数组元素反转替换。反转排序是对数组两边的元素进行替换，所以只需循环数组长度的半数次。
点击查看代码(反转排序示例)
public class SortArrays {
public static void main(String[] args) {
int arr[]={64,48,123,46,1,5,7,81};
SortArrays sorter=new SortArrays();
sorter.reverse(arr);
}
public void reverse(int[] array )
{
System.out.println("原内容：");
showArray(array);
System.out.println();
int temp;
int len=array.length;
for (int i=0;i<len/2;i++)
{
temp=array[i];
array[i]=array[len-1-i];
array[len-1-i]=temp;
}
System.out.println("反转内容为：");
showArray(array);
}
}
public void showArray(int[] array)
{
for (int x:array)
System.out.print("["+x+"]");
}
/*
原内容：
[64][48][123][46][1][5][7][81]
反转内容为：
[81][7][5][1][46][123][48][64]
*/
浙公网安备 33010602011771号