Java基础05-循环问题,数组

补充

1.变量的作用域
- 从变量的声明开始，到离该变量最近的大括号结束
2.变量的重名问题
- 作用域重叠时，变量名不能相同

嵌套循环

1. 循环中套循环，多行多列时使用，外层控制行，内层控制列
2. 执行过程:外层循环走一次，内层循环走所有次
3. 建议:层数越少越好，若需要超三层才能解决，说明设计有问题
4. breka;只能跳出一层循环

程序=算法+数据结构

1. 算法:解决问题的流程/步骤(顺序，分支，循环)
2. 数据结构:将某些数按照特定的结构来保存
3. 好的数据结构，会导致好的算法

数组

1. 相同数据类型元素的集合
2. 数组是一种数据类型(引用类型)
3. 数组的定义:int[] arr=new int[3];
定义一个整数类型的数组，其中有三个元素都为整数
4. 数组的初始化
int[] arr=new int[3]; //默认元素都为0
int[] arr={1,2,3}; //声明同时初始化
int[] arr=new int[]{1,2,3}; //声明同时初始化
int[] arr;
arr=new int[]{1,2,3}; //先声明后初始化
5. 数组的访问
. int[] arr=new int[4];
*通过 arr.length 来访问数组arr的长度
System.out.println(arr.length); // 4
*通过下标/索引来访问数组中的元素
下标从0开始最大到arr.length-1
6. 数组的遍历,用for循环的方式来表示
int[] arr=new int[arr.length];
for(int i=0;i<arr.length;i++){ //正序遍历
arr[i]=n;
}
7. 数组的复制和排序
1)System.arraycopy(a,1,b,0,4); //比较灵活
-*a—源数组
-*1—源数组起始元素
-*b—目标数组
-*0—目标数组起始位置
-*4—复制的元素个数
2)数组的排序 :Arrays.sort(arr); //对数组arr进行升序排列
3)数组的扩容(相当于创建一个新数组)
int[] arr=new int[arr.length];
arr1=Arrays.copyOf(arr,arr.length+1);
4)int[] brr=Arrays.copyOf(arr,n);
-*从数组arr中复制n个元素到brr中
-*若brr.length>arr.length 剩余元素用0或者null填充,反之，则进行截取

案例

1.九九乘法表

//九九乘法表
public class Haskell {
    public static void main(String[] args) {
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}

2.1~100以内的质数

//1~100以内的质数
public class Prime {
    public static void main(String[] args) {        
        int num=0; //质数个数
        for(int i=1;i<=100;i++){
            int num1=0;  //能被整除的数的个数
            for(int j=1;j<=i;j++){
                if(i%j==0){
                    num1++;  //被整除依次则加1
                }
            }
            if(num1==2){   //质数只能被它自身和1整除 所以能被整除的数的个数只为2
                System.out.print(i+",");
                num++;  //统计质数个数
            }
        }
        System.out.println();
        System.out.println("共有质数"+num+"个");
    }
}

3.求数组最小值，并扩容，把最小值放在第一个元素

//求数组最小值并扩容放在第一位
import java.util.Scanner;
import java.util.Random;
import java.util.Arrays;
public class Array {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        Random ra=new Random();
        System.out.print("请输入要创建的数组的长度:");
        int a=sc.nextInt();
        int[] arr=new int[a];  //创建一个新数组 长度为a
        for(int i=0;i<a;i++){  //数组遍历
            arr[i]=ra.nextInt(100);
        }
        System.out.println("数组是:"+Arrays.toString(arr));
        int min=arr[0];  //假设第一个数为最小值
        for(int j=1;j<a;j++){  //依次比较
            if(min>arr[j]){
                min=arr[j];
            }
        }
        System.out.println("数组最小值是:"+min);
        int[] brr=new int[a+1];  //创建一个新数组
        System.arraycopy(arr, 0, brr, 1, a);  //将数组arr中的元素复制到brr中
        brr[0]=min;  //最小值放在第一个元素
        System.out.println("扩容后的新数组是:"+Arrays.toString(brr)); //Arrays.toString()方法可以直接遍历数组
    }
}

4.冒泡排序

//冒泡排序
import java.util.Scanner;
import java.util.Arrays;
import java.util.Random;
public class Bubble {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        Random ra=new Random();
        System.out.print("请输入数组的长度:");
        int len=sc.nextInt();
        int[] arr=new int[len];
        for(int i=0;i<len;i++){
            arr[i]=ra.nextInt(100);
        }
        System.out.println("冒泡前的数组是:"+Arrays.toString(arr));
        System.out.println("冒泡开始！");
        for(int i=0;i<len-1;i++){
            for(int j=0;j<len-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int x=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=x;
                }
            }           
        } 
        System.out.println("冒泡结束后的数组是:"+Arrays.toString(arr));
    }
}