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));    }}