java按时间循环拉取数据失败_day05-java-（循环问题，数组）

day05-java-(循环问题，数组)

1.三种循环结构的更佳适用情况:

1)while: "当..."循环

2)do...while: "直到..."循环

要素1与要素3相同时首选

3)for:固定次数循环

循环结构的选择:

1.先看固定次数还是不固定次数:

固定次数-----首选for

不固定次数-----再看要素1与3是否相同

要素1与要素3相同时-----首选do...while

要素1与要素3不同时-----首选while

2.嵌套循环:

1)循环中套循环，一般多行多列时使用，外层控制行，内层控制列

2)执行过程:外层循环走一次，内层循环走所有次

3)建议:循环层数越少越好，能用一层就不用两层，能用两层就不用三层

若需求必须要通过三层以上循环才能解决，说明设计有问题

4)break只能跳出一层循环

3.程序=算法+数据结构

1)算法:解决问题的流程/步骤(顺序、分支、循环)

2)数据结构:将数据按照某种特定的结构来保存

数怎么存

设计良好的数据结构会导致好的算法

4.数组:

1)相同数据类型元素的集合

2)数组是一种数据类型(引用类型)

3)数组的定义:

int[] arr = new int[4];

4)数组的初始化:

int[] arr = new int[4]; //0,0,0,0

int[] arr = {1,3,5,7};  //1,3,5,7

int[] arr = new int[]{1,3,5,7}; //1,3,5,7

int[] arr;

arr = {1,3,5,7}; //编译错误

arr = new int[]{1,3,5,7}; //正确

//声明浮点型数组d，包含8个元素

//每个元素都是double型，默认值为0.0

double[] d = new double[8];

//声明布尔型数组b，包含26个元素

//每个元素都是boolean型，默认值为false

boolean[] b = new boolean[26];

//声明整型数组a，包含4个元素

//每个元素都是int类型，默认值为0

int[] a = new int[4]; //0,0,0,0

5)数组的访问:

5.1)通过(数组名.length)可以获取数组的长度

int[] arr = new int[4];

System.out.println(arr.length); //4

5.2)通过下标/索引来访问数组中的元素

下标从0开始，最大到(数组的长度-1)

int[] arr = new int[3];

arr[0] = 100; //给arr中第1个元素赋值为100

arr[1] = 200; //给arr中第2个元素赋值为200

arr[2] = 300; //给arr中第3个元素赋值为300

arr[3] = 400; //数组下标越界异常

System.out.println(arr[arr.length-1]); //输出最后一个元素的值

6)数组的遍历:

int[] arr = new int[10];

for(int i=0;i

arr[i] = 100;

}

for(int i=0;i

System.out.println(arr[i]);

}

for(int i=arr.length-1;i>=0;i--){

System.out.println(arr[i]);

}

7)数组的复制:

7.1)System.arraycopy(a,1,a1,0,4);

7.2)int[] a1 = Arrays.copyOf(a,6);

a = Arrays.copyOf(a,a.length+1); //扩容

a = Arrays.copyOf(a,a.length-1); //缩容

8)数组的排序:

8.1)Arrays.sort(arr); //升序

8.2)冒泡原理:

8.2.1)四个数冒3轮

8.2.2)每一轮都是从第1个元素开始冒

每一次都和它的下一个元素比

8.2.3)冒出来的就不带它玩了

9)计算程序执行时间：

long a = System.currentTimeMillis();

Arrays.sort(arr);

long b = System.currentTimeMillis();

System.out.println(b-a); //排序消耗的毫秒数

冒泡排序执行过程：

int[] arr = {45,8,34,1}; //升序

第一轮:

45和8比，换，8,45,34,1

45和34比，换，8,34,45,1

45和1比，换，8,34,1,45-------45冒出来了

第二轮:

8和34比，不换

34和1比，换，8,1,34,45-------34冒出来了

第三轮:

8和1比，换，1,8,34,45--------8冒出来了

找最大值算法:

int[] arr = {23,45,67,10};

1)假设第1个元素最大

int max = arr[0];

2)遍历剩余元素，将剩余元素与max对比，

若剩余元素大于max，则修改max的值为较大的

for(int i=1;i

if(arr[i]>max){

max = arr[i];

}

}

max=23/45/67

数组操作代码演示：

packageday05;importjava.util.Arrays;//数组的演示

public classArrayDemo {public static voidmain(String[] args) {//6.数组的排序

int[] arr = {23,56,4,57,24,1,7,9};

Arrays.sort(arr);//对arr升序

for(int i=0;i

System.out.println(arr[i]);

}/*//5.数组的复制

int[] a = {10,20,30,40,50};

//数组的扩容(创建一个新的数组)

a = Arrays.copyOf(a,a.length+1);

for(int i=0;i

System.out.println(a[i]);

}*/

/*int[] a = {10,20,30,40,50};

//a:源数组

//a1:目标数组

//6:目标数组的长度

int[] a1 = Arrays.copyOf(a,4);

for(int i=0;i

System.out.println(a1[i]);

}*/

/*int[] a = {10,20,30,40,50};

int[] a1 = new int[6];

//a:源数组

//1:源数组的起始下标

//a1:目标数组

//0:目标数组的起始下标

//4:复制的元素个数

System.arraycopy(a,1,a1,0,4);

for(int i=0;i

System.out.println(a1[i]);

}*/

/*//4.数组的遍历

int[] arr = new int[10];

for(int i=0;i

arr[i] = (int)(Math.random()*100);

}

for(int i=0;i

System.out.println(arr[i]);

}*/

/*//3.数组的访问

int[] arr = new int[3];

System.out.println(arr.length); //3.

arr[0] = 100; //给arr中第1个元素赋值为100

arr[1] = 200;

arr[2] = 300;

//arr[3] = 400; //数组下标越界异常

System.out.println(arr[arr.length-1]); //300*/

/*//2.数组的初始化

int[] arr = new int[4]; //0,0,0,0

int[] arr1 = {1,4,6,8}; //1,4,6,8

int[] arr2 = new int[]{1,4,6,8}; //1,4,6,8

int[] arr3;

//arr3 = {1,4,6,8}; //编译错误

arr3 = new int[]{1,4,6,8}; //正确*/

/*//1.数组的定义

//声明整型数组arr，包含10个元素，每个元素都是int类型，默认值为0

int[] arr = new int[10];*/}

}

求数组元素的最大值

packageday05;importjava.util.Arrays;//求数组元素的最大值

public classMaxOfArray {public static voidmain(String[] args) {//给arr赋值

int[] arr = new int[10];for(int i=0;i

arr[i]= (int)(Math.random()*100);

System.out.println(arr[i]);

}//找arr中的最大值

int max = arr[0]; //假设第1个元素最大

for(int i=1;i

if(arr[i]>max){ //若剩余元素大于max

max=arr[i]; //修改max的值为较大的

}

}

System.out.println("最大值为:"+max);//扩容

arr = Arrays.copyOf(arr,arr.length+1);//将最大值赋值给arr中的最后一个元素

arr[arr.length-1] =max;for(int i=0;i

System.out.println(arr[i]);

}

}

}

九九乘法表

packageday05;//九九乘法表

public classMultiTable {public static voidmain(String[] args) {for(int num=1;num<=9;num++){ //控制行

for(int i=1;i<=num;i++){ //控制列

System.out.print(i+"*"+num+"="+i*num+"\t");

}

System.out.println();//换行

}/** num=4

* ......

* num=3

* i=1 1*3=3

* i=2 2*3=6

* i=3 3*3=9

* i=4

* 换行

* num=2

* i=1 1*2=2

* i=2 2*2=4

* i=3

* 换行

* num=1

* i=1 1*1=1

* i=2

* 换行*/}

}

冒泡排序算法

packageday05;//冒泡排序算法

public classBubbleSort {public static voidmain(String[] args) {/** 要求:

* 1.声明整型数组arr包含10个元素，

* 每个元素为0到99之间的随机数，

* 输出每个元素的值

* 2.冒泡方式对arr进行升序排列

* 3.输出arr排序后的数据*/

int[] arr = new int[10];for(int i=0;i

arr[i]= (int)(Math.random()*100);

System.out.println(arr[i]);

}for(int i=0;i

for(int j=0;j

if(arr[j]

int t = arr[j]; //满足条件则交换

arr[j] = arr[j+1];

arr[j+1] =t;

}//若前数大于后数则交换，保证前数小于后数(升序)//若前数小于后数则交换，保证前数大于后数(降序)

}

}

System.out.println("排序后:");for(int i=0;i

System.out.println(arr[i]);

}

}

}

课后作业：

判断一个数字是否是质数：

方法一，判断？是否为质数：packageday06;public classTest01 {public static voidmain(String[] args) {int num = 1;boolean flag = true; //1.假设是质数//for(int i=2;i

for(int i=2;i<=Math.sqrt(num);i++){ //2/3/4/.../9/10

if(num%i==0){

flag= false; //2.修改为不是质数

break;

}

}if(flag){ //3.判断得结论 相当于if(flag==true){

System.out.println(num+"是质数");

}else{

System.out.println(num+"不是质数");

}

}

}

方法二，判断0~100之间的质数：packageday06;importjava.util.Scanner;public classTest01 {public static voidmain(String[] args) {int count = 0; //质数的个数

for(int num=2;num<=100;num++){boolean flag = true;for(int i=2;i<=Math.sqrt(num);i++){ //2/3/4/.../9/10

if(num%i==0){

flag= false;break;

}

}if(flag){

count++; //质数个数增1

System.out.print(num+"\t");if(count%10==0){

System.out.println();

}

}

}

}

}

方法三，判断2~？之间哪些是质数：packageday06;importjava.util.Scanner;public classTest01 {public static voidmain(String[] args) {

Scanner scanner= newScanner(System.in);

System.out.print("请输入查找质数的范围：2~");int max =scanner.nextInt();

scanner.close();int numOfPrime = 0;for (int n = 2; n <= max; n++) {//判断n是否是质数

int m = (int) Math.sqrt(n);int i = 2;for (; i <= m; i++) {if (n % i == 0)break;

}if (i >m) {

System.out.print(n+ " ");if (++numOfPrime % 10 == 0)

System.out.println();

}

}

System.out.println("\n共有" + numOfPrime + "个质数");

}

}

求0~99之间的10个随机数，进行排序，并求出最小数为？

方法一：packageday06;importjava.util.Scanner;public classTest01 {public static voidmain(String[] args) {int[] arr = new int[10];for(int i=0;i

arr[i]= (int)(Math.random()*100);

System.out.println(arr[i]);

}int min = arr[0];for(int i=1;i

min=arr[i];

}

}

System.out.println("最小值为:"+min);int[] arr1 = new int[arr.length+1];

System.arraycopy(arr,0,arr1,1,arr.length);

arr1[0] =min;for(int i=0;i

System.out.println(arr1[i]);

}

}

}

方法二：packageday06;importjava.util.Random;importjava.util.Arrays;public classTest01 {public static voidmain(String[] args) {//创建一个 10 个长度的数组

int[] arr = new int[10];//随机生成 10 个0－99之间的数值，放入数组

Random ran = newRandom();for(int i=0;i

arr[i]= ran.nextInt(100);

}//打印数组中的数据

System.out.println("数组中的数据为：" +Arrays.toString(arr));//查询最小值

int min = arr[0];for(int i=1; iarr[i]) {

min=arr[i];

}

}

System.out.println("最小值是：" +min);//创建新数组

int[] arrNew = new int[arr.length + 1];//将原数组的元素拷贝进入新数组

System.arraycopy(arr, 0, arrNew, 1, arrNew.length-1);//最小值放入新数组第一位，并打印新数组

arrNew[0] =min;

System.out.println("新数组中的数据为：" +Arrays.toString(arrNew));

}

}