1、数组

数组：用来保存一组相同类型的数据
数组是定长的。定义数组后，数组的长度就固定了。例如，声明一个长度为10的数组，那么这个数组 中最多只能存放10个元素。
数组的声明和赋值：int[] a = {12,45,64,54,87};
Int[] :数组类型(引用数据类型);
创建数组：int[] a1= new int[] {45,56,88,84,41};
数组的初始化：

  1. //静态初始化
  2. int[] arr=new int[]{1,2,3};
  4. //动态初始化
  5. String[] strArr=new String[3];
  6. strArr[0]="Hello";
  7. strArr[1]="World";
  8. strArr[2]="Hello World";

数组中的每一个元素都有索引(从0开始)关键字为index;例如,a1[0] = 45; a1[1] = 56; a1[2] = 88;
数组中的length属性用来标记数组长度(a1.length);
字符串使用length() 获取长度(String name = “aa”; name.length();)
数组的遍历:

  1. For(int i = 0;i<a1.length;i++){
  2. System.out.println(a1[2]);
  3. }
  4. //foreach   增强for循环
  5. //for(元素的类型   元素的名称 :  要遍历的数组)
  6. For(int  num :  a1){
  7. System.out.println(num);
  8. }

求数组中最大值代码示例:

  1. Int[] array = {56,51,78,15,48,32};
  2. //获取array数组中的最大值
  3. //标记最大值
  4. Int max= 0;
  5. For(int  arr :  array){
  6. If(arr>=array){
  7. max = arr;
  8. }
  9. }
  10. System.out.println(max);

2、二维数组 : 数组嵌套两层;

声明与赋值:

  1. //三行四列的二维数组
  2. //大数组中有三个小数组,每个小数组中都有四个元素
  3. int[][] array = { {56,5,65,88}, {74,87,64,89}, {64,54,99,66} };

二维数组遍历：

  1. //使用foreach遍历数组
  2. For(int[] num : array){
  3. //num是小数组
  4. For(int m : num){
  5. System.out.println(m);
  6. }
  7. }

菲波那契数列:

  1. //1,1,2,3,5,8,13,21......
  2. //计算出指定的某个数字
  4. //递归:在方法内部使用直接或间接方式,调用自身方法
  5. //递归方法内一定有临界条件
  6. public static int number(int n) {
  7.         if(n==1 || n==2) {
  8.             return 1;
  9.         }else {
  10. int num= Demo.number(n-1)+Demo.number(n-2);;
  11.             return num;
  12.         }
  13.     }
  14. //计算某个数的阶乘
  15. //7! = 1*2*3*4*5*6*7
  16. Public static int fac(int n){
  17. If(n==1){
  18. Return 1;
  19. }else{
  20. Return fac(n-1)*n;
  21. }}

3、排序算法

冒泡排序(重点)、选择排序、插入排序、快速排序；
冒泡排序：依次比较相邻的两个数字，如果第一个数字比第二个数字大，交换位置，一轮比较结束后，最大的数字放在最后位置；

  1. int[] array = {54,85,66,46,23,45,74,14};
  2. for(int i=0;i<array.length-1;i++){
  3.     for(int j=0;j<array.length-1-i;j++){
  4.         //相比较的两个数字: array[j] 和 array[j+1]
  5.         if(array[j]>array[j+1]){
  6.             //交换位置
  7.             int num = array[j];
  8.             array[j] = array[j+1];
  9.             array[j+1] = num;
  10. }
  11. }
  12. //一轮排序
  13. //Arrays.toString(array)  把数组转换成String
  14. //Arrays 数组的工具类
  15. System.out.println(Arrays.toString(array));
  16. }

选择排序: 选择一个数字,使其与其他数字依次比较,如果选择的数字的大,交换位置,一轮排序结束后,最小的数字放在第一个位置上;
插入排序: 把要排序的数字,依次插入到有序数列中;
快速排序:

  1. int[] arr = {45,54,56,31,66,87};
  2. //sort()  使用的是经过优化的快速排序
  3. Arrays.sort(arr);
  4. System.out.println(Arrays.toString(arr));

二分查找(折半查找): 注意:建立在有序的数列上;

  1. //参数1:目标数组
  2. //参数2:目标元素
  3. //返回值:元素的索引,如果为负数,说明数组中没有此元素
  4. int index = Arrays.binarySearch(arr,56);
  5. System.out.println(index);

计算考试总成绩示例:

  1. //参数: 学生成绩
  2. //参数...  :表示此方法的参数数量不确定,可以是0个,也可以是无数个
  3. public static void total(int...score){
  4.     //score参数在方法中作为数组使用
  5.     int num = 0;
  6.     for(int m : score){
  7.         num +=m;
  8. }
  9.     System.out.println("总成绩:"+num);
  10. }

二维数组中求内层数组最大值中的最小值:

  1. int[][] array = {{1,84,45,88},{45,13,98,87},{94,75,61,24}};
  2. //求内层数组最大值中的最小值
  3.         int min = Integer.MAX_VALUE;
  4.         for(int[] array1:array) {
  5.             //array1:每个小数组
  6.             int max = Integer.MIN_VALUE;//定义一个int类型的最小值
  7.             for(int num:array1) {
  8.                 if(num>=max) {
  9.                     max = num;
  10.                 }
  11.             }
  12.             System.out.println(max);
  13.             //取最小值
  14.             if(max<min) {
  15.                 min = max;
  16.             }
  17.         }
  18.         System.out.println(min);