Java数组:针对数组(Array)的各种操作
Java一维数组的定义、赋值和初始化
创建一维数组:
type[] arrayName; // 数据类型[] 数组名;(一般使用这种,可读性比较好)
或者
type arrayName[]; // 数据类型 数组名[];
举个例子:
int [] socre;
String [] name;
double [] price;
特别注意,在声明数组时不需要规定长度:
int score[10]; // 这是错误的
声明数组只是得到了一个存放数组的变量,并没有为数组分配内存空间,所以不能使用,因此为数组分配空间,这样才能进行使用!
int [] socre;
score = new int[10];
为socre分配十个空间
或者直接使用:
int[] a=new int[10];
注意:一旦声明了数组的大小,就不能再修改。这里的数组长度也是必需的,不能少。
初始化一维数组
1.使用new指定数组大小进行初始化
type[] arrayName = new int[size];
- int[] number = new int[5];
- number[0] = 1;
- number[1] = 2;
- number[2] = 3;
- number[3] = 5;
- number[4] = 8;
2.使用new指定数组元素的值
type[] arrayName = new type[]{值 1,值 2,值 3,值 4,• • •,值 n};
int[] number = new int[]{1, 2, 3, 5, 8};
3.直接指定元素的值
type[] arrayName = {值 1,值 2,值 3,…,值 n};
int[] number = {1,2,3,5,8};
获取数组的值,number[index]
Java二维数组详解
在 Java 中二维数组被看作数组的数组,即二维数组为一个特殊的一维数组,其每个元素又是一个一维数组。Java 并不直接支持二维数组,但是允许定义数组元素是一维数组的一维数组,以达到同样的效果。声明二维数组的语法如下:
type arrayName[][]; // 数据类型 数组名[][];
type[][] arrayName; // 数据类型[][] 数组名;
int [][] age;
char [][] sex;
初始化二维数组
二维数组可以初始化,和一维数组一样,可以通过 3 种方式来指定元素的初始值。这 3 种方式的语法如下:
type[][] arrayName = new type[][]{值 1,值 2,值 3,…,值 n}; // 在定义时初始化
type[][] arrayName = new type[size1][size2]; // 给定空间,在赋值
type[][] arrayName = new type[size][]; // 数组第二维长度为空,可变化
double [][] s={{ 100, 99, 99 }, { 100, 98, 97 }, { 100, 100, 99.5 }, { 99.5, 99, 98.5 }};
for (int i=0;i<s.length;i++){
for(int j=0;j<s[i].length;j++){
System.out.println("class_score[" + i + "][" + j + "]=" + s[i][j]);
}
}
Java不规则数组
首先初始化有两种
1.int intArray[][] = {{1,2}, {11}, {21,22,23}, {31,32,33}};
int intArray[][] = new int[4][]; //先初始化高维数组为4
// 逐一初始化低维数组
intArray[0] = new int[2];
intArray[1] = new int[1];
intArray[2] = new int[3];
intArray[3] = new int[3];
Java Arrays工具类
1)int binarySearch(type[] a, type key)
使用二分法查询 key 元素值在 a 数组中出现的索引,如果 a 数组不包含 key 元素值,则返回负数。调用该方法时要求数组中元素己经按升序排列,这样才能得到正确结果。
2)int binarySearch(type[] a, int fromIndex, int toIndex, type key)
这个方法与前一个方法类似,但它只搜索 a 数组中 fromIndex 到 toIndex 索引的元素。调用该方法时要求数组中元素己经按升序排列,这样才能得到正确结果。
3)type[] copyOf(type[] original, int length)
这个方法将会把 original 数组复制成一个新数组,其中 length 是新数组的长度。如果 length 小于 original 数组的长度,则新数组就是原数组的前面 length 个元素,如果 length 大于 original 数组的长度,则新数组的前面元索就是原数组的所有元素,后面补充 0(数值类型)、false(布尔类型)或者 null(引用类型)。
4)type[] copyOfRange(type[] original, int from, int to)
这个方法与前面方法相似,但这个方法只复制 original 数组的 from 索引到 to 索引的元素。
5)boolean equals(type[] a, type[] a2)
如果 a 数组和 a2 数组的长度相等,而且 a 数组和 a2 数组的数组元素也一一相同,该方法将返回 true。
6)void fill(type[] a, type val)
该方法将会把 a 数组的所有元素都赋值为 val。
7)void fill(type[] a, int fromIndex, int toIndex, type val)
该方法与前一个方法的作用相同,区别只是该方法仅仅将 a 数组的 fromIndex 到 toIndex 索引的数组元素赋值为 val。
8)void sort(type[] a)
该方法对 a 数组的数组元素进行排序。
9)void sort(type[] a, int fromIndex, int toIndex)
该方法与前一个方法相似,区别是该方法仅仅对 fromIndex 到 toIndex 索引的元素进行排序。
10)String toString(type[] a)
该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起,多个数组元素使用英文逗号,
和空格隔开。
Java中数组和字符串的相互转换
这里只介绍两种方法
1.char[]转String直接使用定义
String str=new String(char[]);
2.String转char[],使用String.toCharArray()
String str=new String("123abc");
char[] arr=str.toCharArray();
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
String str1=new String(arr);
System.out.println(str1);
Java比较两个数组是否相等(equals())
Arrays.equals(array A,array B);
double[] s1=new double[]{1,2,3,56.7};
double[] s2=new double[5];
for(int i=0;i<s2.length;i++)
{
s2[i]=i;
}
double[] s3={99, 96.5, 98.5, 100, 72};
System.out.println(Arrays.equals(s1,s3));
Java数组填充(fill())
Arrays.fill(array,value);这个是固定的填充数值是依次进行的。
int[] number=new int[5];
for (int i = 0; i < number.length; i++){
Arrays.fill(number,i);
System.out.println(number[i]);
}
Java数组使用binarySearch()方法查找指定元素
查找数组是指从数组中查询指定位置的元素,或者查询某元素在指定数组中的位置。使用 Arrays 类的 binarySearch() 方法可以实现数组的查找,该方法可使用二分搜索法来搜索指定数组,以获得指定对象,该方法返回要搜索元素的索引值。
第一种形式:
binarySearch(Object[] a,Object key);
如果找到就返回搜索值的索引,否则返回-1或者负的插入值。
在进行数组查询之前,必须对数组进行排序(可以使用 sort() 方法)。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个带有指定值的元素,则无法确认找到的是哪一个。
int[] arr=new int[]{1,3,5,4,7};
int key=2;
int value=4;
Arrays.sort(arr);//排序
System.out.println(Arrays.binarySearch(arr,value));
System.out.println(Arrays.binarySearch(arr,key));
- 除了上述形式外,binarySearch() 还有另一种常用的形式,这种形式用于在指定的范围内查找某一元素。语法如下:
binarySearch(Object[] a,int fromIndex,int toIndex,Object key);
这个也需要提前进行排序
int []arr=new int[]{2,5,8,9,6,3};
Arrays.sort(arr);
int key=6;
int fromindex=2;
int endindex=5;
System.out.println(Arrays.binarySearch(arr,fromindex,endindex,key));
Java复制(拷贝)数组的4种方法:arraycopy()方法、clone() 方法、copyOf()和copyOfRan
java中的四种拷贝方式:
1.Arrays类中的copyOf()方法;
2.Arrays类中的copyOfRange()方法;
3.System类的arraycopy方法
4.Object类的clone方法
1. 使用 copyOf() 方法对数组进行复制
Arrays.copyOf(dataType[] srcArray,int length);
其中,srcArray 表示要进行复制的数组,length 表示复制后的新数组的长度。
使用这种方法复制数组时,默认从原数组的第一个元素(索引值为 0)开始复制,目标数组的长度将为 length。如果 length 大于 srcArray.length,则目标数组中采用默认值填充;如果 length 小于 srcArray.length,则复制到第 length 个元素(索引值为 length-1)即止。
注意:目标数组如果已经存在,将会被重构。
int []arr=new int[]{57,81,68,75,91};
int []arrcopy=(int[])Arrays.copyOf(arr,8);
for(int i=0;i<arrcopy.length;i++){
System.out.print(arrcopy[i]+"\t");
}
//57 81 68 75 91 0 0 0
2. 使用 CopyOfRange() 方法对数组进行复制
Arrays 类的 CopyOfRange() 方法是另一种复制数组的方法,其语法形式如下:
Arrays.copyOfRange(dataType[] srcArray,int startIndex,int endIndex)
- srcArray 表示原数组。
- startIndex 表示开始复制的起始索引,目标数组中将包含起始索引对应的元素,另外,startIndex 必须在 0 到 srcArray.length 之间。
- endIndex 表示终止索引,目标数组中将不包含终止索引对应的元素,endIndex 必须大于等于 startIndex,可以大于 srcArray.length,如果大于 srcArray.length,则目标数组中使用默认值填充.
int []arraycopyOfRange=(int[])Arrays.copyOfRange(arr,0,3);
for(int i=0;i<arraycopyOfRange.length;i++){
System.out.print(arraycopyOfRange[i]+"\t");
}//57 81 68
3.使用 arraycopy() 方法
arraycopy() 方法位于 java.lang.System 类中,其语法形式如下:
System.arraycopy(dataType[] srcArray,int srcIndex,int destArray,int destIndex,int length)
其中,srcArray 表示原数组;srcIndex 表示原数组中的起始索引;destArray 表示目标数组;destIndex 表示目标数组中的起始索引;length 表示要复制的数组长度。
int[] arr=new int[]{ 100, 81, 68, 75, 91, 66, 75, 100 };
int newScores[] = new int[] { 80, 82, 71, 92, 68, 71, 87, 88, 81, 79, 90, 77 };
int sindex=0;
int tindex=2;
for (int k = 0; k < newScores.length; k++) {
System.out.print(newScores[k] + "\t");
}
System.out.println();
System.arraycopy(arr,sindex,newScores,tindex,8);
for (int k = 0; k < newScores.length; k++) {
System.out.print(newScores[k] + "\t");
}
//80 82 71 92 68 71 87 88 81 79 90 77
//80 82 100 81 68 75 91 66 75 100 90 77
4.使用clone的方法
clone() 方法也可以实现复制数组。该方法是类 Object 中的方法,可以创建一个有单独内存空间的对象。因为数组也是一个 Object 类,因此也可以使用数组对象的 clone() 方法来复制数组。
clone() 方法的返回值是 Object 类型,要使用强制类型转换为适当的类型。其语法形式比较简单:
array_name.clone()
//int[] targetArray=(int[])sourceArray.clone();
int []s=new int[]{1,3,5,7,9};
int []a=(int[]) s.clone();
System.out.println(Arrays.equals(a,s));\\True
Java sort()数组排序(升序和降序)
使用 java.util.Arrays 类中的 sort() 方法对数组进行升序分为以下两步:
- 导入 java.util.Arrays 包。
- 使用 Arrays.sort(数组名) 语法对数组进行排序,排序规则是从小到大,即升序。
Arrays.sort(s);
降序
1)利用 Collections.reverseOrder() 方法(Collections 是一个包装类。大家可以学习《Java Collections类》一节详细了解):
这里必须使用类进行排序
Integer[] t={9,6,2,5,1};
Arrays.sort(t,Collections.reverseOrder());
2)实现 Comparator 接口的复写 compare() 方法,代码如下:
有错误!!!
Java冒泡排序法(非常重要)
冒泡排序的基本思想是:对比相邻的元素值,如果满足条件就交换元素值,把较小的元素值移动到数组前面,把大的元素值移动到数组后面(也就是交换两个元素的位置),这样数组元素就像气泡一样从底部上升到顶部。
Scanner sc=new Scanner(System.in);
double[] socre=new double[5];
for(int i=0;i<socre.length;i++){
System.out.print("请输入第 " + (i + 1) + " 个成绩:");
socre[i]=sc.nextDouble();
}
System.out.println("排序前的元素值:");
for(double var:socre){
System.out.print(var+"\t");
}
System.out.println();
System.out.println("通过冒泡排序方法对数组进行排序:");
for(int i=0;i<socre.length-1;i++){
for(int k=0;k<socre.length-1-i;k++){
if(socre[k]>socre[k+1]){
double tmp=socre[k+1];
socre[k+1]=socre[k];
socre[k]=tmp;
}
}
}
System.out.println("排序后的元素值:");
for(double var:socre){
System.out.print(var+"\t");
}
\\\
请输入第 1 个成绩:5
请输入第 2 个成绩:3
请输入第 3 个成绩:7
请输入第 4 个成绩:1
请输入第 5 个成绩:4
排序前的元素值:
5.0 3.0 7.0 1.0 4.0
通过冒泡排序方法对数组进行排序:
排序后的元素值:
1.0 3.0 4.0 5.0 7.0
\\\
Java快速排序法(Quicksort)
快速排序的基本思想是:通过一趟排序,将要排序的数据分隔成独立的两部分,其中一部分的所有数据比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此使整个数据变成有序序列。
具体做法是:假设要对某个数组进行排序,首先需要任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它小的数都放到它的前面,所有比它大的数都放到它的后面。这个过程称为一趟快速排序;递归调用此过程,即可实现数据的快速排序。
int[] number={13,15,24,99,14,11,1,2,3};
System.out.print("排序前:");
for(int var:number){
System.out.print(var+"\t");
}
quick(number);
System.out.println("\n排序后:");
for(int val:number) {
System.out.print(val +" ");
}
}
public static int getMiddle(int []list,int low,int high){
int tmp=list[low];
while(low<high){
while(low<high&&list[high]>tmp){high--;}
list[low]=list[high];
while (low<high&&list[low]<tmp){low++;}
list[high]=list[low];
}
list[low]=tmp;
return low;
}
public static void unckSort(int[] list,int low,int high){
if(low<high){
int middle =getMiddle(list, low, high);
unckSort(list,low,middle);
unckSort(list,middle+1,high);
}
}
public static void quick(int[] str){
if(str.length>0){
unckSort(str,0,str.length-1);
}
}
Java选择排序法
使用选择排序法也可以对上述数组中的元素进行排序,但是它与冒泡排序不同。选择排序是指每一趟从待排序的数据元素中选出最大(或最小)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。例如,使用选择排序法重新对 number 数组中的元素进行排序,那么第一趟排序后的结果如下:
int[] number = {13,15,24,99,4,1};
System.out.println("排序前:");
for(int var:number){System.out.print(var+"\t");}
String end="\n";
int index;
for(int i=1;i<number.length;i++){
index=0;
for(int j=1;j<=number.length-i;j++){
if(number[j]>number[index]){index=j;}
}
int tmp=number[number.length-i];
number[number.length-i]=number[index];
number[index]=tmp;
}
System.out.println();
System.out.println("排序后:");
for(int var:number){System.out.print(var+"\t");}
Java直接插入排序法
直接插入排序的基本思想是:将 n 个有序数存放在数组 a 中,要插入的数为 x,首先确定 x 插在数组中的位置 p,然后将 p 之后的元素都向后移一个位置,空出 a§,将 x 放入 a§,这样可实现插入 x 后仍然有序。
int[] number = { 13, 15, 24, 99, 4, 1 };
System.out.println("排序前:");
for (int val : number) { // 遍历数组元素
System.out.print(val + " "); // 输出数组元素
}
int temp,j;
for (int i=1;i<number.length;i++){
temp=number[i];
for(j=i-1;j>=0&&number[j]>temp;j--)
{number[j+1]=number[j];}
number[j+1]=temp;
}
System.out.println("排序hou:");
for (int val : number) { // 遍历数组元素
System.out.print(val + " "); // 输出数组元素
}