Fundamental.Unit05

达内

知识体系

循环结构

• 多次重复执行一个或者多个任务的问题考虑使用循环结构
• 循环三要素：循环变量的初始状态，循环条件，循环变量的改变
• while(){} “当……”循环
• do{}while(); “直到……”循环
• for( ; ; ){} 固定次数循环

数组

什么是数组

• 程序 = 数据结构 + 算法
• 数据结构：数据按特定的某种结构来保存，设计合理的数据结构是解决问题的前提
• 数组是最基本的一种数据结构
• 数组：相同数据类型的元素组成的集合

数组的定义，初始化，访问，复制，排序

定义

• 数据类型[] 数组名 = new 数据类型[大小]
• 定义的时候，数据类型 [] 数据名三者不可少
• 执行new语句才能分配数组指定的大小

初始化

• int[] arr = new int[12];
• int[] arr = {1, 2, 3, 4, 5, 6 };
• int[] arr = new int[]{1, 2, 3, 4, 5, 6 };
• 或者也可以先声明，再初始化

访问

• 获取长度：int len = arr.length;
• 通过下标访问数组元素： a22[0] = 100;
• 遍历数组for(int i=0; i<arr.length; i++){arr[1] = 100;}或者使用新循环for(int i : arr){ i = 10}
• 遍历数组时候改变for条件可以正序或者逆序输出元素，逆序输出for(int i=(arr.length-1);i>=0;i--){sysout(arr[i])}

复制

• public static void arrarcopy(Object src, int srcPos, Object dest, int destPos, int length)
• int [] arr2 = new int[10];
System.arraycopy(arr, 0, arr2, 0, arr.length);
• Arrays.copyOf 类型[] newArray = Arrays.copyOf(类型[] original,int newLength) -- 也可用于数组的扩容和缩容
• 注意前两行代码与第三行是有区别的：

System.arraycopy(arr, 0, arr2, 0, arr.length);
System.arraycopy(arr, 0, arr3, 0, arr.length);
 // arr3 = arr2 = arr;

排序

• 排序是数组施加的最常用的算法
• 排序：将数组元素按照从大到小或从小到大重新排列
• Arrays.sort();
• 冒泡排序：比较相邻元素，违反排序规则则交换
• 第一次找出最大数放在最后一个位置上，第二次找出剩余的所有元素放在倒数第二位置上。。。直到排序完成
• 比较可以实现“下沉”或者“上浮”方式实现

经典案例

打印九九乘法表

package day01;
public class MultiplicationTable {
    public static void main(String[] args) {
        //i变量用于控制行数
        for(int i=1; i<10; i++){
            //j变量用于控制每行中参与计算的最大值：与行数相同
            for(int j=1; j<i+1; j++){
                System.out.print(j + " * " + i + " = " + i*j + "\t");
            }
            //每行输出完毕需换行
            System.out.println();
        }
    }
}

求数组中元素最大值，并扩容放在最后一位

package day01;
import java.util.Arrays;
public class MaxOfNumPlus {
    public static void main(String[] args) {
        int[] arr = new int[10];
//      for(int i : arr){
//          i = (int)(Math.random() * 100 + 1);
//      }
        for(int i=0; i<arr.length; i++){
            arr[i] = (int)(Math.random() * 100 + 1);
        }
        System.out.println("排序前：" + Arrays.toString(arr));
        //arr复制到arr2，然后arr2排序找到最大值，然后将最大值放在arr扩容之后的最后一位
//      int [] arr2 = new int[10];
//      System.arraycopy(arr, 0, arr2, 0, arr.length);
//      Arrays.sort(arr2);
//      int max‘ = arr2[arr2.length -1];
//      
//      arr = Arrays.copyOf(arr, arr.length + 1);
//      arr[arr.length - 1] = max;
//      
//      System.out.println("排序后：" + Arrays.toString(arr));
        //一般方法实现
        int [] arr2 = new int[10];
        System.arraycopy(arr, 0, arr2, 0, arr.length);
        for(int i=1; i<arr.length; i++){
            if(arr2[0] < arr2[i]){
                arr2[0] = arr2[i];
            }
        }
        int max = arr2[arr2.length -1];
        arr = Arrays.copyOf(arr, arr.length + 1);
        arr[arr.length - 1] = arr2[0];
        System.out.println("排序后：" + Arrays.toString(arr));
    }
}

冒泡排序算法实现

package day01;
import java.util.Arrays;
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for(int i=0; i<arr.length; i++){
            arr[i] = (int)(Math.random() * 100 + 1);
        }
        System.out.println("排序前：" + Arrays.toString(arr));
        for(int i=0; i<arr.length; i++){
            for(int j=0; j<arr.length -1 -i; j++){
                if(arr[j] > arr[j+1]){
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] =t;
                }
            }
        }
        System.out.println("排序后：" + Arrays.toString(arr));
    }
}

不使用实现两个数的互换

package day01;
public class Test {
    public static void main(String[] args) {
        int a=3 ,b=1;
        a = a+b;
        b = a-b;
        a = a-b;
        System.out.println(a + ",,," + b);
    }
}

课后作业

质数问题

找出2到用户输入的数之间的所有质数

package day01;
import java.util.Scanner;
public class PrimeNumProblem {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("输入最大范围值：");
        int num = scan.nextInt();
        //i是2到num之间的数，要判断是否是质数然后输出
        for(int i=3; i<num; i++){
            boolean flag = true;
            //j用来判断i是否是质数
            for(int j=2; j<i; j++){
                if(i % j == 0){
                    flag = false;
                }
                break;
            }
            if(flag){
                System.out.println("质数是："+i);
            }
        }
    }
}

笔记

• int[] 是一种数据类型
• 总结冒泡排序算法

查出数组中最小元素，扩容后在第一位

package day01;
import java.util.Arrays;
public class MinOfNumPlus {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for(int i=0; i<arr.length; i++){
            arr[i] = (int)(Math.random() * 100 + 1);
        }
        System.out.println("排序前：" + Arrays.toString(arr));
        int [] arr2 = new int[10];
        int[] arr3 = new int[10];
        System.arraycopy(arr, 0, arr2, 0, arr.length);
        System.arraycopy(arr, 0, arr3, 0, arr.length);
//      arr3 = arr2 = arr;
        Arrays.sort(arr2);
        int min = arr2[0];
        arr = Arrays.copyOf(arr, arr.length + 1);
        System.arraycopy(arr3, 0, arr, 1, arr3.length);
        arr[0] = min;
        System.out.println("排序后：" + Arrays.toString(arr));
    }
}