数组知识点回顾

最新推荐文章于 2024-05-25 12:01:51 发布

@Jack:-O……

最新推荐文章于 2024-05-25 12:01:51 发布

阅读量224

点赞数

文章标签： java IT 后端数组

本文链接：https://blog.csdn.net/Jack_cherisf/article/details/89324594

版权

数组

数组的概念：
数组是一个变量,用来存放一组相同数据类型变量的容器。
数组的格式:

数据类型[ ] 数组名;
数据类型数组名[ ];
数组的属性：通过arr.length来表示数组的长度。
数组异常：
1.下标越界。比如如下代码：

 public class Array {
	
	 public static void main(String[] args) {
			// 声明数组
			int[] arr =new int[3] ;
	 		//给数组每一个元素赋值
	 		arr[0]=6;
	 		arr[1]=12;
			arr[2]=26;
			arr[3]=3;//数组的下标不在 0~arr.length之间
			System.out.println(Arrays.toString(arr));
	 }
}

2.空指针。如下代码：

public class Array {
	
	public static void main(String[] args) {
			//对象没有new,就访问对象成员
			int[] arr2 = null;
			System.out.println(arr2[1]); // java.lang.NullPointerException
	 }
}

数组的初始化
静态初始化
格式一: 数据类型[ ] 数组名 = {元素1,元素2,…元素n};
格式二: 数据类型[ ] 数组名 = new int[]{元素1,元素2,…元素n};
动态初始化
数据类型[ ] 数组名 = new 数据类型[数组的大小];
可以采用以下三种方式初始化
1.逐个初始化
2.通过键盘输入
3.通过随机数初始化

***注意不管是静态初始化还是动态初始化，一定在创建的时候，就指明数组的长度。数组的长度一旦确定，就不可以更改。

1.逐个初始化

public class Array {
	public static void main(String[] args) {
		int[] arr = new int[3];
		arr[0] =10;
		arr[1] = 8;
		arr[2] = 50;
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
	}
}

2.通过键盘输入

举例：Java考试结束后，老师给冰冰分配了一项任务，让他计算全班（30人）的平均分。

import java.util.Scanner;

public class ArraysDemo01 {

   public static void main(String[] args) {
   	// TODO Auto-generated method stub
   		Scanner input = new Scanner(System.in);
   		double [] score = new double [30];
   		double sum = 0.0;
   		double average = 0.0;
   		for (int i = 0; i < score.length; i++) {
   		 		System.out.print("请输入第" + (i + 1) + "个学生成绩: ");
   		 		score[i] = input.nextDouble();
   		 		
   		 		 sum+= score[i];
   		} 
   		average = sum/score.length;
   		System.out.println(score.length+"个学生成绩的平均分是： "+average);

   }

}

3.随机数初始化

public class Array {
	public static void main(String[] args) {
		int[] arr = new int[ ]{10,20,30,40,50};
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) (Math.random() * 10);
		}
		System.out.println(Arrays.toString(arr));
	}
}

数组的遍历
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
##举例：有一个数列：8，4，2，1，23，344，12，循环输出数列的值。

public class Array {

	public static void main(String[] args) {
		int[] arr = {8,4,2,1,23,344,12};
		String s = arrayToString(arr);
		System.out.println(arrayToString(arr));
	}
	public static String arrayToString(int[] arr) {
		String result = "";

		result += "[";

		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				
				result += arr[i];
			} else {
				
				result += arr[i] + ", ";
			}
		}
				result += "]"
				return result;
	}
}

数组的最值思想
举例：有一个数列：9，5，1，10，89，569，16，求出最大值和最小值。

//求上述数列的最大值
public class Array {
	public static void main(String[] args) {
		int[] arr = {9,5,1,10,89,569，16};
		System.out.println("最大值:" + getMaxValue(arr));
	}
    public static int getMaxValue(int[] arr) {
		// 1.假设第一个数为最大值
		int max = arr[0];
		
		// 2.遍历数组中的每一个元素
		for (int i = 0; i < arr.length; i++) {
			// 获取到每一个元素arr[i]
			// 3.判断获取的元素是否比max大
			if (arr[i] > max) {
				// 4.设置arr[i]为最大值
				max = arr[i];
			}
		}
		
		return max;
	}
}

//求上述数列的最小值
public class Array {
	public static void main(String[] args) {
		int[] arr = {9,5,1,10,89,569，16};
		System.out.println("最大值:" + getMinValue(arr));
	}
    public static int getMinValue(int[] arr) {
		// 1.假设第一个数为最小值
		int min = arr[0];
		
		// 2.遍历数组中的每一个元素
		for (int i = 0; i < arr.length; i++) {
			// 获取到每一个元素arr[i]
			// 3.判断获取的元素是否比min大
			if (arr[i] <max) {
				// 4.设置arr[i]为最小值
				min = arr[i];
			}
		}
		
		return max;
	}
}

数组倒置思想
举例：有一个数列：8，4，2，1，23，344，12,将数组倒置并输出。

public class Array {
	 public static void main(String[] args) {
		  int[] arr = {8,4,2,1,23,344,12};
		  System.out.println("倒置前: " + Arrays.toString(arr));
		  reverseArray(arr);
		  System.out.println("倒置后: " + Arrays.toString(arr));
	 }
	 public static void reverseArray(int[] arr) {
		
		  for (int i = 0; i < arr.length / 2; i++) {
			 int temp = 0;
			 temp = arr[i];
			 arr[i] = arr[arr.length - 1 - i];
			 arr[arr.length - 1 - i] = temp;
	}
		
}

数组查找思想
举例：有一个数列：8，4，2，1，23，344，12，数组查找猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数。
（1）基本查找

public class Array {
	public static void main(String[] args) {
		 int[] arr = {8,4,2,1,23,344,12};
		 Scanner input = new Scanner(System.in);
    	 int num = input.nextInt();
    	 int index = baiscSearch(arr, num);
		 System.out.println(index != -1 ? "找到了该数" + arr[index] : "该数在数组中不存在");
	}
	public static int baiscSearch(int[] arr, int num) {
		 int index = -1;
		
		 for (int i = 0; i < arr.length; i++) {
			 if (arr[i] == num) {
				index = i;
				break;
			 }
		 }
		
		return index;
	}
}

（2）二分法查找

public class Array {
	public static void main(String[] args) {
		 int[] arr = {8,4,2,1,23,344,12};
		 Scanner input = new Scanner(System.in);
		 Arrays.sort(arr);
    	 system.out.println(Arrays.toString(arr));
    	 system.out.println(baiscSearch(arr, num);)
	public static int binarySearch(int[] arr, int num) {
		 int min = 0;
		 int max = arr.length
		 int mid = (min+max)/2;
			 while (arr[mid] != num) {
				if(arr[mid]>num){
					max=mid-1;
			 	}else if(arr[mid]<num)
			 		min=mid+1;
				}
				if(min>max){
					return index;
				}
			}
	}
}

数组排列思想
（1）冒泡排列
举例：有一个数列：8，4，2，1，23，344，12，数组排序。

public class Array {
	public static void main(String[] args) {
		 int[] arr = {8,4,2,1,23,344,12};
		 bubbleSort(arr);
		 System.out.println("冒泡排序后: " + Arrays.toString(arr));
	}
	public static void bubbleSort(int[] arr) {
		 for (int i = 0; i < arr.length - 1; i++) {
			 for (int j = 0; j < arr.length - 1 - i; j++) {
				 if (arr[j] > arr[j+1]) {
					int temp = 0;
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
			      }
			}
		}
	}
}

（2）选择排序

每一个元素依次和后面的所有的元素进行比较，每一趟比较完毕，最小的数出现在最小索引处
一共比较arr.length-1趟
每一趟比上一趟少比较一趟
举例：有一个数列：8，4，2，1，23，344，12，用选择排序进项数列排序。

public class ArrayDemo06 {
	public static void main(String[] args) {
		 int[] arr = {8,4,2,1,23,344,12};
		 selectSort(arr);
		 System.out.println("选择排序后: " + Arrays.toString(arr));
	}
	public static void selectSort(int[] arr) {
		 for (int i = 0; i < arr.length - 1; i++) {
			 for (int j = i+1; j < arr.length; j++) {
				 if (arr[j] < arr[i]) {
					int temp = 0;
					temp = arr[j];
					arr[j] = arr[i];
					arr[i] = temp;
			      }
			}
		}
	}
}

foreach遍历
概念:集合和数组专有的遍历方式
foreach遍历方式的特点:

1.简化了遍历
2.foreach没有索引
3.foreach底层还是使用了普通for遍历
编译时期系统会读取foreach的格式,转化普通for格式

public class Array {
	public static void main(String[] args) {
		int[] arr = {1, 2, 3, 4, 5};
		
		for(int i : arr) {
			System.out.println(i);
		}
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
	}
}

Arrays工具类

public class ArrayDemo03 {
	public static void main(String[] args) {
		int[] arr = {56, 78, 98, 101, 99, 88};
		// Arrays的遍历输出方法
		System.out.println(Arrays.toString(arr));
		
		// Arrays的排序方法
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		
		// Arrays的二分法查找方法
		int index = Arrays.binarySearch(arr, 88);
		System.out.println(index);
		
		// System的arraycopy方法
		int[] dest = {60, 70, 80};
		
		System.arraycopy(arr, 1, dest, 0 ,3);
		System.out.println(Arrays.toString(dest));
		
		// 复制数组
		int[] newArr = Arrays.copyOf(arr, arr.length);
		System.out.println(Arrays.toString(newArr));
		
		// 数组扩容
		int[] newArr2 = Arrays.copyOf(arr, arr.length + 1);
		System.out.println(Arrays.toString(newArr2));
		
		// 缩小数组的容量
		int[] newArr3 = Arrays.copyOf(arr, arr.length - 2);
		System.out.println(Arrays.toString(newArr3));
		
		// 填充数组
		// Arrays.fill(arr, 100);
		// System.out.println(Arrays.toString(arr));
		
		// 填充数组的一部分  左闭右开原则 
		// Arrays.fill(arr, 2, 4, 100);
		// System.out.println(Arrays.toString(arr));
		
		int[] copyArr = Arrays.copyOfRange(arr, 2, 5);
		System.out.println(Arrays.toString(copyArr));
		
		int[] arr1 = {11, 22, 33, 44};
		int[] arr2 = {11, 22, 33, 44};
		System.out.println(Arrays.equals(arr1, arr2));
		
	}
}

在元素的末尾添加一个元素Add(int[] arr, int num)

public class Array {
	
	static int[] arr;
	
	public static void main(String[] args) {
		arr = new int[] {22, 32, 42, 52};
     	System.out.println(Arrays.toString(arr));
		add(62);
		System.out.println(Arrays.toString(arr));
	}
	public static void add(int num) {
		// 利用System.arraycopy方法处理
		int[] descArr = new int[arr.length + 1];
		// 复制数组
		System.arraycopy(arr, 0, descArr, 0, arr.length);
		// 将num赋值到目标数组的最后一个位置
		descArr[descArr.length - 1] = num;
		// 地址传递
		arr = descArr;
    }
}

实现数组在指定位置插入元素（insert(int[] arr, int index,int num
）

public class Array {
	
	static int[] arr;
	
	public static void main(String[] args) {
		arr = new int[] {12, 32, 52, 62};
     	System.out.println(Arrays.toString(arr));
     	insert(arr.length, 100);
		System.out.println(Arrays.toString(arr));
	}
	public static void insert(int index, int num) {
		int[] descArr = new int[arr.length + 1];
		System.arraycopy(arr, 0, descArr, 0, index);
		descArr[index] = num;
		System.arraycopy(arr, index, descArr, index + 1, arr.length - index);
		arr = descArr;
    }
}

删除某一个指定位置的元素（delete(int[] arr, int index,int num)）

public class Array {
	
	static int[] arr;
	
	public static void main(String[] args) {
		arr = new int[] {12, 32, 52, 62};
		System.out.println(Arrays.toString(arr));
     	delete(6);
		System.out.println(Arrays.toString(srcArr));
	}
	public static void delete(int index) {
		int[] descArr = new int[srcArr.length - 1];
		System.arraycopy(arr, 0, descArr, 0, index);
		System.arraycopy(arr, index + 1, descArr, index, descArr.length - index);
		arr = descArr;
    }
}

查询某个元素 get(int[] arr, int index)

public class Array {
	
	static int[] arr;
	
	public static void main(String[] args) {
		arr = new int[] {12, 32, 52, 62};
		System.out.println(Arrays.toString(arr));
     	System.out.println(get(0));
	}
	public static int get(int index) {
		return arr[index];
    }
}

修改元素的值 set(int[] arr, int index, int num)

public class Array {
	
	static int[] arr;
	
	public static void main(String[] args) {
		arr = new int[] {12, 32, 52, 62};
		System.out.println(Arrays.toString(arr));
     	set(1, 200);
		System.out.println(Arrays.toString(arr));
	}
	public static void set(int index, int num) {
		arr[index] = num;
    }
}

二维数组

就是存放了一维数组的数组

多维数组

本质也是一维数组

访问二维数组中每一个元素的格式:

数组名[m][n];

@Jack:-O……

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数组知识点回顾

数组数组的概念：数组是一个变量,用来存放一组相同数据类型变量的容器。数组的格式:数据类型[ ] 数组名;数据类型数组名[ ];数组的属性：通过arr.length来表示数组的长度。数组异常：1.下标越界。比如如下代码： public class Array { public static void main(String[] args) { // 声明数组 ...
复制链接

扫一扫