目录
1 简介
数组是用来存储固定数量的同类型元素的一种数据结构，它是引用类型
2 创建数组
数据类型[] 数组名 = {元素一，元素二......元素n}
或 数组类型[] 数组名 = new 数据类型[数组长度]
int [] arr1 = {1,2,3,4};
或
int [] arr1 = new int[]{1,2,3,4};
String[] arr2 = new String[5];
arr2[0]="a";
3 数组长度
数组的对象length属性，可以动态的计算出数组的长度
int length = arr1.length；4 访问数组元素
通过数组名下标的形式访问数组元素：数组名[下标]
访问包含：获取元素的值和修改元素的值
下标值：从0开始，0表示第一个
5 遍历数组
1 for循环
for(int i=0; i<arr1.length;i++){
System.out.println(i);
}2 for each循环
//增强for循环
for(int temp : arr1){
System.out.println(temp);
}6 排序算法
简单排序：冒泡排序，选择排序，插入排序等
时间复杂度O(n^2)
复杂排序：快速排序，希尔排序，堆排序，归并排序等
1 冒泡排序
在要排序的一组数中，对当前还未排好的序的全部范围的全部数，自前而后对相邻的两个数依次进行比较和交换位置，让较大的数往后，较小的数往前（冒泡）。
public static void bubbleSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n-1; i++) {
for (int j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
// swap arr[j] and arr[j+1]
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
2 选择排序
以下是使用Java实现选择排序的示例代码：
public class SelectionSort {
public static void sort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
int minIdx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIdx]) {
minIdx = j;
}
}
int temp = arr[i];
arr[i] = arr[minIdx];
arr[minIdx] = temp;
}
}
public static void main(String[] args) {
int[] arr = {5, 2, 8, 3, 9, 1};
sort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
选择排序的原理是，从未排序的元素中选择最小的元素，并将其放在已排序的部分的末尾。每次迭代，选择未排序部分的最小元素，然后将其放在已排序部分的末尾，直到所有的元素都排序完成。
3 插入排序
以下是使用Java实现插入排序的示例代码：
public static void insertionSort(int[] arr) {
int n = arr.length;
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
注解：
arr是要进行排序的数组；n是数组的长度；key是选中的未排序的元素；j是用于比较的元素下标；
算法流程：
- 从第二个元素开始，将其选中，即
key = arr[i]； - 将选中的元素前面的所有元素与选中元素比较大小，并向右移动大于选中元素的元素；
- 将选中元素插入到合适的位置，并重复第1步到第3步，直到所有元素排序完成。
如果要对数组进行降序排序，则需要改变比较大小的方式：while (j >= 0 && arr[j] < key) { ... }。
7 数组元素查找
顺序查找
int [] source = {1,2,3,4,5,6,7};
int target = 4;
for(int i=0;i<source.length;i++){
if(source[i]==target){
System.out.println(i);
}
}二分查找
二分查找又叫折半查找，其思想是：要求待查找的序列有序（前提：必须给数组排好序），每次取中间位置的值与待查关键字比较，如果中间位置的值比特值关键字大，则在前半部分循环这个查找的过程，如果中间位置比特待查关键字小，则在后半部位循环这个查找的过程。直到查到了为止，否则序列中没有待查的关键字，其时间复杂度O(logN)。
以下是使用Java实现二分查找的示例代码：
public static int binarySearch(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == target) {
return mid;
} else if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}
注解：
arr是要进行查找的有序数组；target是要查找的目标元素；left是左边指针，初始值为0；right是右边指针，初始值为arr.length - 1；mid是中间指针，初始值为left + (right - left) / 2；
注意：二分查找的前提是要求数据元素是有序的。
8 可变长参数
JDK1.5增加了新特性，可变参数。使用…表示：适用于参数不确定，类型确定的情况
java把可变参数当做数组处理
注意：可变参数必须位于最后一项，当可变参数多于一个时，必须有一个不是最后一项，所以只支持有一个可变参数、因为参数个数不确定，所以当其后面还有相同类型参数时，java无法区分传入的参数属于前一个可变参数还是后面的参数，所以只能让可变参数位于最后一项。
可变参数的特点：
1 只能出现在参数列表的最后
2 …位于变量类型和变量名之间，前后有无空格都可以
3 调用可变参数的方法时，编译器为该可变参数隐含创建的一个数组，在方法体中以数组的形式访问可变参数。
public static void main(String[] args){
add(1,2);
add(1,2,3)
}
public static int add(int...args){
int sum=0;
for(int i=0;i<arg.length;i++){
sum+=args[i];
}
}9 Arrays工具类
java.util.Arrays
1 数组转字符串
Arrays.toString(arr);
2 数组赋值
//将数组中的所有元素都赋值为0
Arrays.fill(arr,0);
//fill(数组，开始下标，结束下标，替换值)
Arrays.fill(arr,1,4,8)3 数组排序
//按照元素自然顺序排序
Arrays.sort(arr)4 二分查找
int index = Arrays.binarySearch(arr,9)
//返回找不到的下标值
//找不到返回的是负数，返回负的该在第几个5 复制数组(扩容)
int [] arr4 = Arrays.copyOf(arr,10)6 比较数组
bollean tar = Arrays.equals(arr,arr2);//比较数组是否一样
10 多维数组
多维数组可以看成一个数组的数组，即数组中的元素还是数组：
创建二维数组
int [][] arr1 = ={{1,2},{2,3,4},{4,5}};
int [][] arr = new int[3][];
arr[0] = new int[]{1,2};
arr[1] = new int[]{2,3,4};
arr[2] = new int[]{3,4,5};遍历二维数组
for(intb i= 0; i<arr4.length;i++){
for(int j=0;j<arr4[i].length;j++){
int a= arr4[i][j];
}
}
127
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
