【Java】数组

目录

一维数组的创建及使用

创建一维数组

先声明，再用new运算符进行内存分配

 声明的同时为数组分配内存

初始化一维数组

使用一维数组

二维数组的创建及使用

二维数组的创建

先声明，再用new运算符进行分配内存

声明的同时维数组分配内存

二维数组初始化

 二维数组的使用

数组的基本操作

遍历数组

填充替换数组元素

对数组进行排序

复制数组

数组查询

数组的排序算法

冒泡排序

直接选择排序

反转排序

---

一维数组的创建及使用

创建一维数组

先声明，再用new运算符进行内存分配

数组元素类型 数组名字[]；

数组元素类型[] 数组名字；

数组元素类型决定了数组的数据类型。

声明数组后，还不能立即访问他的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，要想真正的使用数组，还要为它分配内存空间。在为数组分配内存空间时必须指明数组的长度。

数组名字 = new 数组元素的类型[数组元素的个数] ；

 声明的同时为数组分配内存

数组元素的类型 数组名[] = new 数组元素的类型[数组元素的个数]

初始化一维数组

int arr1[] = new int[] {1,2,3,4,5};
int arr2[] = {1,2,3,4,5};

使用一维数组

public class practice {

	public static void main(String[] args) {
		int day[] = new int[] {31,28,31,30,31,30,31,31,30,31,30,31};
		for(int i=0;i<12;i++) {
			System.out.println((i+1)+ "月有" + day[i] + "天");
		}
	}

}

二分法查找某个数是不是在数组里：

import java.util.Scanner;


public class practice {

	public static void main(String[] args) {
		int start = 0, end, middle;
		int a[] = {12,45,67,89,-1523,67};
		int N = a.length;
		for(int i=0;i<N;i++) {
			for(int j=i+1;j<N;j++) {
				if(a[j]<a[i]) {
					int t = a[j];
					a[j] = a[i];
					a[i] = t;
				}
			}
		}
		System.out.println("排序以后的数组是：");
		for(int i: a) {
			System.out.print(i + " ");
		}
		System.out.println();
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入整数，程序判断改整数是否在数组中");
		int number = scanner.nextInt();
		int cnt = 0;
		end = N;
		middle = (start+end)/2;
		while(number!=a[middle]) {
			if(number>a[middle]) {
				start = middle;
			}
			else if(number<a[middle]) {
				end = middle;
			}
			middle = (start+end)/2;
			cnt++;
			if(cnt>N/2) {
				break;
			}
		}
		if(cnt>N/2) {
			System.out.printf("%d不在数组中", number);
		}
		else {
			System.out.printf("%d在数组里面",number);
			
		}
		
	}

}

二维数组的创建及使用

二维数组的创建

先声明，再用new运算符进行分配内存

声明的同时维数组分配内存

数组元素的类型 数组名字[][];

数组元素的类型[][] 数组名字[];

 同一维数组一样，二维数组在声明时也没有分配空间，同样要使用new关键字来分配内存，然后才可以访问每一个元素。

（1）直接分配内存

a = new int[2][2];

（2）分别为每一层分配内存。（比较灵活）

a = new int[2][];
a[0] = new int[2];
a[1] = new int[3];

二维数组初始化

二维数组初始化与一维数组初始化类似，同样可以使用大括号完成。

type arrayname[][] = {value1,value2,....,valuen}

 二维数组的使用

public class practice {

	public static void main(String[] args) {
			int a[][] = new int[3][4];
			for(int i=0;i<a.length;i++) {
				for(int j=0;j<a[i].length;j++) {
					System.out.print(a[i][j]);
				}
				System.out.println();
			}
	}

}
/*
0000
0000
0000
*/

数组的基本操作

遍历数组

public class practice {

	public static void main(String[] args) {
		int b[][] = {{1},{2,3},{4,5,6}};
		for(int k=0;k<b.length;k++) {
			for(int c=0;c<b[k].length;c++) {
				System.out.print(b[k][c]);
			}
			System.out.println();
		}
	}

}
/*
1
23
456
*/

遍历数组时用foreach语句可能会更简单。下面的语句就是通过foreach语句遍历二维数组。

public class practice {

	public static void main(String[] args) {
		int arr2[][] = {{4,3},{1,2}};
		System.out.println("数组中的元素是");
		int i=0;
		for(int x[]:arr2) {
			i++;
			int j=0;
			for(int e:x) {
				j++;
				if(i==arr2.length && j==x.length) {
					System.out.print(e);
				}
				else {
					System.out.print(e+"、");
				}
			}
		}
	}

}
/*
数组中的元素是
4、3、1、2
*/

填充替换数组元素

可通过Array类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可以完成对任意类型的数组元素的替换。fill方法有两种参数类型。

（1）fill（int[] ，int value）

a是要进行元素替换的数组，value是要储存数组中所有元素的值。

（2）fill（int[] a,int fromIndex，int toIndex，int value）

该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围索引从fromIndex（包括）到toIndex（不包括）。如果fromIndex和toIndex，则填充范围为空。

import java.util.Arrays;

public class practice {

	public static void main(String[] args) {
		int arr[] = new int[] {45,12,2,10};
		Arrays.fill(arr, 0,2,8);
		for(int i=0;i<arr.length;i++) {
			System.out.println("第"+i+"个元素是："+arr[i]);
		}
	}

}
/*
第0个元素是：8
第1个元素是：8
第2个元素是：2
第3个元素是：10
*/

对数组进行排序

通过Arrays类的静态sort()方法可以实现对数组的排序。sort()方法提供了多种重载形式，可以对任意类型的数组进行升序排序。

Arrays.sort(object)

 （其中object是指定进行排序的数组名称）
Java的String类型数组的排序算法是根据字典编排顺序排序的，因此数字在字母前面，大写字母排在小写字母前面。

import java.util.Arrays;

public class practice {

	public static void main(String[] args) {
		int arr[] = {23,42,12,8};
		Arrays.sort(arr);
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
	}

}
/*
8
12
23
42
*/

复制数组

（1）copyOf(arr，newlength)

import java.util.Arrays;

public class practice {

	public static void main(String[] args) {
		int arr[] = new int[] {23,42,12};
		int newarr[] = Arrays.copyOf(arr, 5);
		for(int i=0;i<newarr.length;i++) {
			System.out.println(newarr[i]);
		}
	}

}
/*
23
42
12
0
0
*/

import java.util.Arrays;

public class practice {

	public static void main(String[] args) {
		int arr[] = new int[] {23,42,12};
		int newarr[] = Arrays.copyOf(arr, 2);
		for(int i=0;i<newarr.length;i++) {
			System.out.println(newarr[i]);
		}
	}

}
/*
23
42
*/

（2）copyOfRange()

该方法提供了多种重载形式。

arr：要进行复制的数组对象。

fromIndex：指定开始复制数组的索引位置。

toIndex：要复制范围的最后索引位置。新数组中不包括索引是toIndex的元素。

import java.util.Arrays;

public class practice {

	public static void main(String[] args) {
		int arr[] = new int[] {23,42,12,84,10};
		int newarr[] = Arrays.copyOfRange(arr, 0, 3);
		for(int i=0;i<newarr.length;i++) {
			System.out.println(newarr[i]);
		}
	}

}
/*
23
42
12
*/

数组查询

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定的数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，binarySearch()方法有两种类型的参数。

（1）binarySearch(Object[]，Object key)

a是要搜索的数组，key是要搜索的值。

如果key包含在数组中，则返回搜索值的索引；否则返回“-1”或“-”（插入点）。插入点是将搜索键将要插入数组的那个点，即第一个大于此键的元素索引。

（2）binarySearch(Object[]，int fromIndex，int toIndex，Object key)

fromIndex，指定范围的开始处索引（包含）

toIndex，指定范围的结束处索引。（不包含）

如果key包含在数组中，则返回搜索值的索引；否则返回“-1”或“-”（插入点）。如果范围中的所有元素都小于指定的键，则为toIndex。

import java.util.Arrays;

public class practice {

	public static void main(String[] args) {
		int arr[] = new int[] {4,25, 10};
		Arrays.sort(arr);
		int index = Arrays.binarySearch(arr, 0, 1, 8);
		System.out.println(index); //-2
	}

}

index的值是元素“8”在数组arr中索引0~1内的索引位置。由于在指定的范围内并不存在“8”，index的值是“-”（插入点）。如果对数组进行排序，元素“8”应该在25的前面，因此插入点应是元素“25”的索引值2，所以index的值是-2。

import java.util.Arrays;

public class practice {

	public static void main(String[] args) {
		int arr[] = new int[] {4, 25, 10, 25, 465};
		Arrays.sort(arr);
		int index = Arrays.binarySearch(arr, 25);
		System.out.println(index); 
	}

}

import java.util.Arrays;

public class practice {

	public static void main(String[] args) {
		String str[] = new String[] {"ab","cd","ef","aba"};
		Arrays.sort(str);
		for(int i=0;i<str.length;i++) {
			System.out.print(str[i] + " ");
		}
		System.out.println();
		int index = Arrays.binarySearch(str, 0, 2, "cd");
		System.out.println(index);
	}

}
/*
ab aba cd ef 
-3
*/

数组的排序算法

冒泡排序

基本思想：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面。

public class practice {

	
	public static void main(String[] args) {
		int[] arr = {1,43,5,4,33,66,54,100,0,-1,-9};
		System.out.println("排序前");
		show(arr);
		System.out.println();
		System.out.println("排序后：");
		sort(arr);
		show(arr);
	}
	
	public static void sort(int[] arr) {
		for(int i=1;i<arr.length;i++) {
			for(int j=0;j<arr.length-i;j++) {
				if(arr[j]>arr[j+1]) {
					int t = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = t;
				}
			}
		}
	}
	
	public static void show(int []arr) {
		for(int i=0;i<arr.length;i++) {
			if(i!=0)
				System.out.print(",");
			System.out.print(arr[i]);
		}
	}
}

直接选择排序

基本思想：是将制定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都已成为已经排序好的格式。

public class practice {

	public static void main(String[] args) {
		int arr[] = {64,4,14,1,3,54};
		practice p = new practice();
		p.sort(arr);
		
	}
	
	public void sort(int[] arr) {
		int index;
		for(int i=1;i<arr.length;i++) {
			index = 0;
			for(int j=1;j<=arr.length-i;j++) {
				if(arr[j]>arr[index]) {
					index = j;
				}
			}
			int temp = arr[arr.length-i];
			arr[arr.length-i] = arr[index];
			arr[index] = temp;
		}
		showArray(arr);
	}
	
	public void showArray(int[] arr) {
		for(int i:arr) {
			System.out.print(i + " ");
		}
		System.out.println();
	}

}

反转排序

基本思想：就是把数组的最后一个元素与数组的第一个元素替换，倒数第二个元素与第二个元素替换。

public class practice {

	public static void main(String[] args) {
		int[] arr = {10,20,30,40,50,60};
		practice p = new practice();
		p.sort(arr);
		
	}
	
	public void sort(int[] arr) {
		System.out.println("数组原有内容：");
		showArray(arr);
		int temp;
		int len = arr.length;
		for(int i=0;i<len/2;i++) {
			temp = arr[i];
			arr[i] = arr[len-i-1];
			arr[len-i-1] = temp;
		}
		System.out.println("数组反转后的内容");
		showArray(arr);
		
	}
	
	public void showArray(int[] arr) {
		for(int i:arr) {
			System.out.print(i + " ");
		}
		System.out.println();
	}

}