1.数组的概念与初始化
1.1概念
- 数组是一种线性表数据结构，它用一组连续的内存空间存储相同类型的数据，所以数组就是一组相同类型的变量集合，并且这些变量可以按照统一的方式进行操作。
1.2数组初始化
- 数组的初始化就是为数组开辟连续的内存空间，并为每个数组元素赋予值。数组的初始化可以分为两类，一种是动态初始化，另一种是静态初始化。动态初始化即首先开辟空间，然后再根据索引进行内容的设置；静态初始化即在数组定义的时候同时设置内容。
1.2.1 数组的动态初始化
数组类型[] 数组名 = new 数组类型[数组长度] ;
- 数组的访问
数组名[索引]
数组的索引是从0开始，所以索引的范围是0~(数组长度-1)，如果访问时超出了索引范围，会报java.lang.ArrayIndexOutOfBoundsException异常信息。
若初始化后，不对数组进行赋值，那么数组里的每个元素都是该数组类型的默认值。 - 如下代码所示，先初始化了一个int类型长度为3的数组data，然后分别给data的每一项赋值，最后输出每一项。
public class ArrayInit {
public static void main(String[] args){
int[] data = new int[3];
data[0] = 0;
data[1] = 1;
data[2] = 2;
for (int i = 0; i < data.length; i++) {
System.out.println("第"+i+"个:"+data[i]);
}
}
}
第0个:0
第1个:1
第2个:2
1.2.2数据静态初始化
数组类型[] 数组名 = {值，值，...}
public class ArrayInit {
public static void main(String[] args){
//静态初始化
int[] data = {1,2,3,4,5,6,7,8,9,0};
for(int i = 0; i < data.length; i++) {
System.out.print(data[i]);
}
}
1234567890
1.3二维数组
- 如果说一位数组像是一行变量，那么二维数组就是两行变量。
- 二维数组的初始化
动态初始化：数据类型[][] 数组名称 = new 数据类型[行数][列数];
动态初始化：数据类型[][] 数组名称 = new 数据类型[][]{{值，值，值，...},{},...};
public class ArrayInit {
public static void main(String[] args){
int[][] data = new int[][]{{1,2,3,4},{5,6,7,8}};
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data[i].length; j++) {
System.out.print(data[i][j]);
}
}
}
}
12345678
2.数组的操作
2.1比较两个数组是否相等
public class equalsArray {
public static void main(String[] args){
double[] score1 = {99,100,89,67,50};
double[] score2 = {99,100,89,67,50};
double[] score3 = {99,100,89,99,50};
if(Arrays.equals(score1,score2)){
System.out.println("score1与score2相等");
}else{
System.out.println("score1与score2不相等");
}
if(Arrays.equals(score1,score3)){
System.out.println("score1与score3相等");
}else{
System.out.println("score1与score3不相等");
}if(Arrays.equals(score2,score3)){
System.out.println("score2与score3相等");
}else{
System.out.println("score2与score3不相等");
}
}
}
输出
score1与score2相等
score1与score3不相等
score2与score3不相等
2.2数组填充
Arrays提供了一个方法fill，可以在指定位置进行数值填充。虽然可以进行填充，但是只能使用同一个数值进行填充。
public class FillArray {
public static void main(String[] args){
int[] data = new int[4];
System.out.println("一共有"+data.length+"个元素");
for (int i = 0; i < data.length; i++) {
Arrays.fill(data,i);
System.out.println("第"+i+"个，内容为"+data[i]);
}
}
}
一共有4个元素
第0个，内容为0
第1个，内容为1
第2个，内容为2
第3个，内容为3
2.3数组查找
- 从数组中查询指定位置的元素或查询某元素在指定数组中的位置。Arrays中有binarySearch()方法可以实现数组的查找，binarySearch() 方法有多种重载形式来满足不同类型数组的查找需要，常用的重载形式有两种。
- （1）binarySearch(Object[] a,Object[] key);
其中a为要搜索的数组，key为需要查找的值，如果存在，则返回索引值；否则返回-1或-插入点。在进行数组查询前，必须对数组进行排序，否则结果是不确定的；若存在多个key元素，无法确定返回的是哪一个。 - （2）binarySearch(Object[] a,int fromIndex,int toIndex,Object key);
其中a为要搜索的数组，key为需要查找的值，fromIndex指定范围的开始处索引（包含开始处），toIndex指定范围的结束处索引（不包含结束处）。 - binarySearch(Object[] a,Object[] key);
初始化data数组，进行sort排序，使用binarySearch查找对应key值的索引，注意此处查找的结果索引是排序后的，11对应的位置是7，而111不存在，返回的-10,10代表插入数组的位置，即第一个大于10的元素666的下一位。
public class BinarySearch {
public static void main(String[] args){
int[] data = {1,2,5,4,3,9,8,666,11,46};
Arrays.sort(data);
System.out.println("排序后的数组：");
for (int i = 0; i 排序后的数组：
1 2 3 4 5 8 9 11 46 666 查找11的位置是：7
查找111的位置是：-10
- binarySearch(Object[] a,int fromIndex,int toIndex,Object key);
初始化data数组，进行sort排序，使用binarySearch查找对应key值的索引，注意此处查找的结果索引是排序后的，在0-5的区间内查找11，不存在，则返回插入数组的位置，46是一个大于11的值，所以返回-6；在3-8的区间内查找111，找到111，返回索引7。
public class BinarySearch {
public static void main(String[] args){
int[] data = {1,222,5,4,3,9,8,666,111,46};
Arrays.sort(data);
System.out.println("排序后的数组：");
for (int i = 0; i 排序后的数组：
1 3 4 5 8 9 46 111 222 666 查找11的位置是：-6
查找111的位置是：7
2.4数组排序
2.4.1sort()方法
public static void main(String[] args){
int[] data = {11,33,22,4,66,55,99,88,102};
int[] result;
sort(data);
for (int i = 0; i < sort.length; i++) {
System.out.println(sort[i]);
}
}
public static void sort(int[] data){
Arrays.sort(data);
}
4 11 22 33 55 66 88 99 102
2.4.2冒泡排序
public static void bubbleSort(int[] data){
int n = data.length;
for (int pass = n-1; pass >= 0; pass--) {
for (int i = 0; i < pass; i++) {
if(data[i]>data[i+1]){
int temp = data[i];
data[i] = data[i+1];
data[i+1] = temp;
}
}
}
}
4 11 22 33 55 66 88 99 102
2.4.3快速排序
public static void quickSort(int[] data){
if(data!=null){
quickSort(data,0,data.length-1);
}
}
private static void quickSort(int[] data,int beg,int end){
if(beg>end || data ==null){
return;
}else{
int p = partition(data,beg,end);
quickSort(data,beg,p-1);
quickSort(data,p+1,end);
}
}
private static int partition(int[] data,int beg,int end){
int first = data[beg];
int i = beg, j = end;
while (i < j) {
while (data[i] <= first && i < end) {
i++;
}
while (data[j] > first && j >= beg) {
j--;
}
if (i < j) {
data[i] = data[i] ^ data[j];
data[j] = data[i] ^ data[j];
data[i] = data[i] ^ data[j];
}
}
if (j != beg) {
data[j] = data[beg] ^ data[j];
data[beg] = data[beg] ^ data[j];
data[j] = data[beg] ^ data[j];
}
return j;
}
2.4.4选择排序
public static void selectionSort(int[] data) {
int n = data.length;
int i, j, min, temp;
for (i = 0; i < n-1; i++) {
min = i;
for (j = i+1; j < n; j++) {
if(data[j]4 11 22 33 55 66 88 99 102
2.4.5插入排序
public static void insertSort(int[] data){
int temp,j;
int n = data.length;
for(int i=1;i=0&&data[j]>temp;j--)
{
data[j+1]=data[j];
}
data[j+1]=temp;
}
}
4 11 22 33 55 66 88 99 102
引用
https://blog.csdn.net/mrbacker/article/details/81638331
https://blog.csdn.net/qq_34988624/article/details/89360112
http://c.biancheng.net/view/919.html