java复习笔记————数组小总结

1.数组的定义

C语言风格：int a[]={1,5,5,4,5,4};
java风格（面向对象风格,推荐！） int[] b={2,3,3,5,4,3};

静态初始化和动态初始化

int[] a=new int[]{2,423,42,3}//静态初始化
int[] a={2,3,8,5,3,123}//静态初始化简化版
int[] c=new int[5]//动态初始化
int num=sc.nextInt() int[] c=new int[num] 数组初始化的大小取决于用户输入

动态初始化后系统的默认赋值分别是多少

2.遍历数组

数组的遍历有普通for循环遍历和foreach遍历两种情况

	int[] a= {1,34,32,124,31,3};
		//普通的for循环遍历
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
		
		//foreach循环遍历

		for(int c:a) {
			//只读,不可修改数据
			System.out.println(c);
			//如果修改c的值也只是对读取的当前c值做了修改，并没有改变数组的值
		}

3.排序

冒泡排序

冒泡排序的的步骤
循环
交换
回手掏（减少比较次数）

	public static void foamsort(int[] arr) {
	    for(int i=arr.length-1;i>0;i--){
	        boolean flag = false;
	        for(int j=0;j<i;j++){
	            if(arr[j] > arr[j+1]){
	                int tmp = arr[j];
	                arr[j] = arr[j+1];
	                arr[j+1] = tmp;
	                flag = true;
	            }
	        }
	        if(!flag) break;
	    }
		for(int a:arr) {
			System.out.println(a);
		}
	}

插入排序

我用的二分法查找到对应的下标值，返回下标值，然后对于下表后面的元素进行后移

public static int insertsort(int[] arr,int l,int r,int va) {
		int mid=l+(r-l)/2;
		int index=0;
		if(l<r) {
			if(arr[mid-1]>va) {
				crsort(arr, l, mid-1, va);
			}else if(arr[mid+1]<va) {
				crsort(arr, mid+1, r, va);
			}else if(arr[mid-1]<=va&&arr[mid]>=va) {
				index=mid;
			}else if(arr[mid+1]>=va&&arr[mid]<=va) {
				index=mid+1;
			}
		}
		
		return index;
	}

选择排序：比较大小换位置
很暴力

	public static void choosesort(int[] arr) {
		for (int f = 0; f < arr.length; f++) {
			for (int i = f+1; i < arr.length; i++) {
				if(arr[i]<arr[f]) {
					arr[i]=arr[f]+arr[i];
					arr[f]=arr[i]-arr[f];
					arr[i]=arr[i]-arr[f];
				}
			}
		}
		for(int a:arr) {
			System.out.println(a);
		}
	}

4.Arrays类

Arrays类的总结来自己虎老狮，大家可以去关注一波微信公众号获取知乎

import java.util.Arrays;
public class TestArrays类 {
	public static void main(String[] args) {
		int[] arr1 = { 2, 1, 5, 4, 3 };
		String sArr1 = Arrays.toString(arr1);// 数组转为字符串
		System.out.println(sArr1);
		// Arrays.sort(arr1);//排序（升序）
		Arrays.parallelSort(arr1);// Java 8的并行排序，支持多核CPU，更快
		System.out.println("排序后：" +Arrays.toString(arr1));
		// Arrays.binarySearch：（升序排列的数组）二分查找
		// 参数2是要查找的元素。
		// 返回值为索引；找不到返回负数
		int _index = Arrays.binarySearch(arr1, arr1.length);
		System.out.println(_index);
		// Arrays.copyOf：按长度复制
		// 多的补0/false/null
		int[] b = Arrays.copyOf(arr1, 10);
		System.out.println("copyOf：" +Arrays.toString(b));
		// Arrays.fill：同值填充
		Arrays.fill(arr1, -1);
		System.out.println("fill：" +Arrays.toString(arr1));
	}
}

补充

a= Arrays.copyOf(a , 2 * a.length);这个用法通常用来增加数组的大小
C++ 注释：Java 数组与 C++ 数组在堆栈上有很大不同， 但基本上与分配在堆（heap) 上
的数组指针一样。也就是说，
intD a = new int[100]; // Java
不同于
int a[100]; // C++
而等同于
int* a = new int[100]; // C++
Java 中的 [ ] 运算符被预定义为检查数组边界，而且没有指针运算， 即不能通过 a 加
1 得到数组的下一个元素。

5.数组降序

5.1.使用list集合以及reverse：先升序排列然后通过倒置，逆序

Integer _arr[] = { 5, 3, 1, 2, 4 };
Arrays.sort(_arr);
List< Integer > asList = Arrays.asList(_arr);
Collections.reverse(asList);//

5.2使用Comparator接口，重写sort方法

public static void 降序sort版() {
		// 类,或包装类
		int[] _arr = { 5, 3, 1, 2, 4 };
		Arrays.sort(_arr, new Comparator<Integer>() {
		@Override
		public int compare(Integer o1, Integer o2)
		{
		return o2 - o1;
		}
		});
}

5.3使用Comparator接口，实现对字符串数组的排序

	public static void charsort(String[] str) {		
		//调用并且重写排序
		Arrays.sort(str,new Comparator<String>() {
			@Override
			public int compare(String o1, String o2)
				{
					int o1len=o1.length();//获取长度
					int o2len=o2.length();
				for(int i=0;i<o1.length();i++) {//遍历每一个字符
					char a=o1.charAt(i);				
					if(a>'0'&&a<='9'||a>='a'&&a<='z'||a>='A'&&a<='Z'||a==' '||a=='_') {}
					else//如果是中文就++
						o1len++;				
				}
				for(int i=0;i<o2.length();i++) {
					char a=o2.charAt(i);				
					if(a>'0'&&a<='9'||a>='a'&&a<='z'||a>='A'&&a<='Z'||a==' '||a=='_') {}
					else//如果是中文就++
						o2len++;				
				}
					return  o1len-o2len;//按长度的升序排列
				}
			});
		for (int i = 0; i < str.length; i++) {
			System.out.println(str[i]);
		}
	}

6.二维数组

数组的初始化

和一维数组一样也可以有c++的写法和java的写法，这里就不推荐用c++的写法了，直接来java的
int[][] _arr21 = { { 1, 2 }, { 3, 4 } };
int[][] _arr22 = new int[2][3];
int[][] _arr23 = new int[2][];// 第二维度可以省略

二维数组的遍历

		//二维数组的遍历
		int[][] a= {{2,3,4,5,5},{4,3,34,34,43},{67,422432,423,2,2},{6,3,2,1,19}};
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				System.out.println(a[i][j]);
			}
		}
		
		//foreach遍历
		for(int[] arr:a) {
			for(int arr1:arr) {
				System.out.println(arr1);
			}
		}

7.二维数组-矩阵乘法

代码：

import java.util.Arrays;
public class 二维矩阵相乘 {
		public static void main(String[] args) {
		int m = 2, p = 3, n = 2;
		int[][] A = { { 1, 2, 3 }, { 4, 5, 6 } };
		int[][] B = { { 1, 4 }, { 2, 5 }, { 3, 6 } };
		int[][] C = new int[m][n];
		for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++) {
						for (int k = 0; k < p; k++) {
						C[i][j] = C[i][j] + A[i][k]* B[k][j];
						}
				}
		}
		// ------------
		for (int[] is : C) {
		System.out.println(Arrays.toString(is));
		}
		}
}