Java-03数组
一、一维数组
1、静态初始化： int[] arr = new int[]{}//可以拆分
int[] arr = {};//不可拆分
2、动态初始化：int[] arr = new int[n];//可以拆分
3、默认初始化：
整型=0
浮点型=0.0
boolean=false
char=\u0000是空但不是空格
引用数据类型=null
二、二维数组
1、静态初始化： int[][] arr = new int[][]{{1,3},{9,4,0},{-2,4}};
int[][] arr = {{1,3},{9,4,0},{-2,4}};
2、动态初始化：int[][] arr = new int[2][3];
int[][] arr = new int[2][];//注意内维必须要定义，否则空指针 arr[1]=new int{2,3,6,3}
int[][] arr =new int[][2];非法
三、内存解析
四、常用算法
1、赋值：回数，杨辉三角
练习1、杨辉三角 解析：1、每一行第一个和最后一个数是1，2、从第三行开始，中间部分满足array[i][j] = array[i-1][j-1]+array[i-1][j] // 数组的第X行有X个数值，如果不想写这个循环，初始化数组时就要给第二个中括号一个数值，按理来说也是10 int[][] array= new int[10][]; for (int i = 0; i <10 ; i++) { array[i]=new int[i+1]; } // int[][] array= new int[10][10];//可替换以上的代码 // 1、搞定前两行 array[0][0]=1; array[1][0]=1; array[1][1]=1; System.out.print(array[0][0]+"\n"); System.out.println(array[1][0]+"\t"+array[1][1]); // 2、搞定后面行 for (int i = 2; i < 10; i++) { for (int j = 0; j <= i ; j++) { if(j==0){ array[i][0]=1; System.out.print(array[i][j]+"\t");//搞定每行的第一个数 }else if(j==i){ array[i][j]=1; System.out.println(array[i][j]);//搞定每行的最后一个数 } else{//搞定每行中间部分 array[i][j] = array[i-1][j-1]+array[i-1][j]; System.out.print(array[i][j]+"\t"); } } } 练习2、杨辉三角优化 // 1、数组初始 int[][] array1= new int[10][]; for (int i = 0; i <10 ; i++) { array1[i] = new int[i + 1]; } // 2、赋值 for (int i = 0; i < array1.length; i++) { // 解决外围元素1 array1[i][0]=1; array1[i][i]=1; // 解决中间元素 for (int j = 1; j < i; j++) { array1[i][j] = array1[i-1][j-1]+array1[i-1][j]; } } // 3、遍历==有格式打印数组 for (int i = 0; i < array1.length; i++) { for (int j = 0; j < array1[i].length; j++) { System.out.print(array1[i][j]+"\t"); } System.out.println();//换行 }
练习3、回数
Scanner scanner = new Scanner(System.in); System.out.println("请输入回型数大小数值："); int n = scanner.nextInt(); int[][] arr = new int[n][n]; //坐标轴 int count = 0;//要显示的数量 int maxX = n - 1;//x轴的最大下标 int maxY = n - 1;//y轴的最大下标 int minX = 0;//x轴的最小下标 int minY = 0;//y轴的最小下表 while(minX <= maxX){ for(int x = minX; x <= maxX; x++){ arr[minY][x] = ++ count;//实现第1行 } minY ++; for(int y = minY; y <= maxY; y++){ arr[y][maxX] = ++ count;//实现第n列 } maxX --; for(int x = maxX; x >= minX; x--){ arr[maxY][x] = ++ count;//实现第n行 } maxY --; for(int y = maxY; y >= minY; y--){ arr[y][minX] = ++ count;//实现第1列 } minX ++; } for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr[i].length; j++) { System.out.print(arr[i][j] + "\t"); } System.out.println(); }
//练习4，创建长度n的数组，元素范围【1-n】，随机生成并且各不相同，可以使用set集合「不重复性」
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] array = new int[n];
for (int i = 0; i < array.length; i++) {
array[i]=(int)(Math.random()*n)+1;
for (int j = 0; j < i; j++) {
if(array[i]==array[j]){
i--;//没有i--,如果一直产生的数都重复了，最终有些下标没有执行赋值就结束了，即有默认初始值0出现
// i少1，相当于本次没有操作，又重新开始直到出现不同了才继续下一个坐标的赋值
break;
}
}
}
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+"\t");
}
2、求最大最小值
int[] arr = {1,4,-8,39,0,5,2}; int max = arr[0]; int min = arr[0]; for (int i = 1; i < arr.length; i++) { if(arr[i]>max){ max=arr[i]; } if(arr[i]<min){ min=arr[i]; } } System.out.println("最大值："+max+"最小值："+min);
3、反转，复制，查找（线性+二分法）
练习 反转 int[] array = {5, 2, 4, 8, 3}; int len = array.length; System.out.println("数组长度："+len); //原本顺序 for (int j = 0; j < 5; j++) { System.out.println(array[j]); } //方法1 int [] arrayReverse =new int [len];//创建新空数组用来放置数据 for (int i = 0; i < 5; i++) { arrayReverse[i] = array[len - 1 - i];//把反方向的值存储下来 } System.out.println("#########方法1结果"); array=arrayReverse;//赋值 for (int i = 0; i < 5; i++) { System.out.println(array[i]); } // 方法2 int min =0; int max =0; for (int i = 0; i < 5; i++) { if(i<=(len+1)/2-1){//对于len=偶数，则到len/2停止，奇数，则(len+1)/2-1 min=array[i]; max=array[len-i-1]; array[i]=max; array[len-i-1]=min; } } System.out.println("#########方法2结果"); for (int i = 0; i < 5; i++) { System.out.println(array[i]); }
练习 线性查找 String[] strings = new String[]{"AA","DD","GG","BB","TT"}; String str = "DD"; // 方法1==优化 boolean isFlag = true;//初始 for (int i = 0; i < strings.length; i++) { if(strings[i]==str){ System.out.println("找到了，位置"+i); isFlag=false; break;//如果进入此if，则isFlag就是false，反之就没进去过，没进去就是true } } if(isFlag){ System.out.println("no found"); } // 方法2 boolean isFlag1 = true; for (int i = 0; i < strings.length; i++) { if(strings[i]==str){ System.out.println("找到了，位置"+i); isFlag1=false; break; } if(i==strings.length-1){//最后一个都没有进去过第一个if System.out.println("no found"); } }
练习 二分法查找 int[] arr = {1,3,5,6,9,32,56,90};//有序 int num =5; int head =0; int end=arr.length-1; boolean isFlag = true; while (head<=end) { int middle =(head+end)/2; if(num==arr[middle]){ System.out.println("找到啦，位置"+middle); isFlag=false; break; }else if(num>arr[middle]){ head=middle+1; }else{ end=middle-1; } } if(isFlag|num<arr[0]|num>arr[arr.length-1]){ System.out.println("no found"); }
4、排序
排序目的为了快速查找，对象也可以排序，不过是对里边item的关键字排序
算法的优劣：时间，空间复杂度
排序算法优劣：时间，空间复杂度，稳定性
常用8大排序算法
-
选择排序
直接选择排序、堆排序 -
交换排序
冒泡排序、快速排序【开发多用】 -
插入排序
直接插入排序、折半插入排序、Shell排序
-
归并排序
算法特征：输入，输出，有效，确定性，可行性
//快排
public static void main(String[] args) { int[] arr = {20,40,37,21,29,22,-6,-4,0,70,45,30,-3,-6,20,40}; quickSort(arr,0,arr.length-1); System.out.println(arrayToString(arr,"排序")); } public static void quickSort(int[] arr,int left,int right){ if(left>=right){ return; } int base = arr[left]; int i = left; int j = right; while (i<j){ // 步骤1，左右两边走，当不满足条件就继续走 while(arr[j]>=base && i<j){//如果大于基准数就继续往左走,i>j必须同时成立，否则说明两个交汇了，跳出外层的大while j--; } while(arr[i]<=base && i<j){//如果小于基准数就继续往右走，i>j必须同时成立，否则说明两个交汇了，跳出外层的大while i++; } // 步骤2，当上述两个while都不满足就跳出来，即左边找到了第一个大于base的数，右边找到了第一个小于base的数 // 如果两者没有相遇，那么交换位置 /*if(i<j){*///两者没有相遇，那么交换位置，上面2个while已作出判断了，这里的判断可以省略 int temp =arr[i] ; arr[i] = arr[j]; arr[j] = temp; // } } // 步骤3，i=j，即跳出整个外层的while，base与相遇的数交换 arr[left]=arr[i];//i给基数base arr[i]=base;//基数base给i // 步骤4，重复以上操作，递归 quickSort(arr,left,i-1); quickSort(arr,i+1,arr.length-1); } private static String arrayToString(int[] arr,String flag) { String str = "数组为("+flag+")："; for(int a : arr) { str += a + "\t"; } return str; }
public static void main(String[] args) { int[] arr = {20,40,37,21,29,22,-6,-4,0,70,45,30}; // 冒泡 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 = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } System.out.println(Arrays.toString(arr));//每一轮比较后数组 } System.out.println(Arrays.toString(arr));//排序后的数组 /* [20, 37, 21, 29, 22, -6, -4, 0, 40, 45, 30, 70] [20, 21, 29, 22, -6, -4, 0, 37, 40, 30, 45, 70] [20, 21, 22, -6, -4, 0, 29, 37, 30, 40, 45, 70] [20, 21, -6, -4, 0, 22, 29, 30, 37, 40, 45, 70] [20, -6, -4, 0, 21, 22, 29, 30, 37, 40, 45, 70] [-6, -4, 0, 20, 21, 22, 29, 30, 37, 40, 45, 70] [-6, -4, 0, 20, 21, 22, 29, 30, 37, 40, 45, 70] [-6, -4, 0, 20, 21, 22, 29, 30, 37, 40, 45, 70] [-6, -4, 0, 20, 21, 22, 29, 30, 37, 40, 45, 70] [-6, -4, 0, 20, 21, 22, 29, 30, 37, 40, 45, 70] [-6, -4, 0, 20, 21, 22, 29, 30, 37, 40, 45, 70] [-6, -4, 0, 20, 21, 22, 29, 30, 37, 40, 45, 70] 第六次排序结束后，其实数组就已经排序结束了，后面可以不用再排序了，因为每次都是把最大的数往后移， 所以可以优化，如果第一个数是最小的数，则说明结束了 */ }
//冒泡 变形 public static void main(String[] args) { int[] arr = {20,40,37,21,29,22,-6,-4,0,70,45,30}; // 冒泡 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 = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } System.out.println("每一轮比较后数组"+Arrays.toString(arr));//每一轮比较后数组 boolean isFlag = true; for (int j = 1; j < arr.length; j++) { if(arr[0]>arr[j]){ isFlag = false; } } if(isFlag){ System.out.println("最终数组"+Arrays.toString(arr));//最终数组 break; } } /* 每一轮比较后数组[20, 37, 21, 29, 22, -6, -4, 0, 40, 45, 30, 70] 每一轮比较后数组[20, 21, 29, 22, -6, -4, 0, 37, 40, 30, 45, 70] 每一轮比较后数组[20, 21, 22, -6, -4, 0, 29, 37, 30, 40, 45, 70] 每一轮比较后数组[20, 21, -6, -4, 0, 22, 29, 30, 37, 40, 45, 70] 每一轮比较后数组[20, -6, -4, 0, 21, 22, 29, 30, 37, 40, 45, 70] 每一轮比较后数组[-6, -4, 0, 20, 21, 22, 29, 30, 37, 40, 45, 70] 最终数组[-6, -4, 0, 20, 21, 22, 29, 30, 37, 40, 45, 70] 第六次排序结束后，其实数组就已经排序结束了，后面可以不用再排序了，因为每次都是 把最大的数往后移， 所以可以优化，如果第一个数是最小的数，则说明结束了 */ }
public static void main(String[] args) { int[] arr = {20,40,37,21,29,22,-6,-4,0,70,45,30}; // 选择:每一轮从中找出最小值及对应下标，一轮结束后，与第一位交换位置,第一轮从i=0开始，后面依次+ // int len = arr.length;//12,i=0-10,j=1-11 for (int i = 0; i < arr.length-1; i++) { int min_index = i; for (int j =i+1; j < arr.length; j++) { if(arr[j]<arr[min_index]){ min_index = j;//记住最小数的下标 } } // 一轮结束后，j=min_index,最小数和arr[i]交换位置 int temp = arr[i]; arr[i]=arr[min_index]; arr[min_index]=temp;// System.out.println("每"+(i+1)+"轮结果："+Arrays.toString(arr)); } System.out.println(Arrays.toString(arr)); }
public static void main(String[] args) { int[] arr = {20,40,37,21,29,22,-6,-4,0,70,45,30}; /* 直接插入：拿出数组每个数i与前i-1到0进行比较，将i插入合适的位置（当小于的时候该数等于前一个的数， 然后把小于的数填到前一个位置，其实就是互换位置，后面i继续向前比较，当大于的时候说明位置不变，因为之前的数都是排好位置的，不用比较了，直接下一个数i+1） 第一轮：i=1，40与20比较，大于不用交换break 第二轮：i=2，37和40比较，小于，往前排列变成【20，37，40，...],37和20比较，大于break； 第三轮：i=3，21和40比较，小于，往前排列变成【20，37，21，40，...],21和37比较，小于，往前排列变成【20，21，37，40，...],21和20比较，大于break .... 第length-1轮： */ for (int i = 1; i <arr.length ; i++) { int min = arr[i]; for (int j = i; j > 0 ; j--) { if(min<arr[j-1]){ arr[j]=arr[j-1]; arr[j-1]=min; }else { break; } } System.out.println("每"+i+"轮结果"+Arrays.toString(arr)); } System.out.println(Arrays.toString(arr)); }
五、Arrays工具类
java.util.Arrays数组工具类，调用其中静态方法，变量，可以直接类名称调用
public static String toString（数组）//打印数组
public static void sort(数组)升序排序
如果数值，sort按数字升序，如果字符，按a-z排序，如果自定义类型，这个自定义的类需要comparable或者comparator接口的支持
// public static String toString(数组)=打印数组 int [] array = {1,23,5}; String str = Arrays.toString(array);//[1,23,5] System.out.println(str); // public static boolean equals(数组1，数组2) int [] array1 = {3,7,4,8,2}; System.out.println(Arrays.equals(array,array1));//false System.out.println(array1);//[I@61bbe9ba // public static void sort(数组) Arrays.sort(array1);//无返回值类型 System.out.println(array1);//[I@61bbe9ba数组array1并没有改变内存位置，只是内容改变了 System.out.println(Arrays.toString(array1));//[2, 3, 4, 7, 8] // public static void fill(数组,val)，val替换所有元素 String [] str1 ={"bbb","dd5","aaa"}; Arrays.fill(str1,"java");//每个元素都被替换成Java System.out.println(Arrays.toString(str1));//[java, java, java] // public static int binaryResearch(数组，key) int[] array0={1,2,5};//必须保证数组有序 int index = Arrays.binarySearch(array0,5); System.out.println(index);//没有找到输出负数
浙公网安备 33010602011771号